void
test_int_set_serialize_failure_noncanon(void)
{
GOutputStream *stream = g_memory_output_stream_new(NULL, 0,
g_realloc, g_free);
GDataOutputStream *datastream = g_data_output_stream_new(stream);
g_data_output_stream_set_byte_order(datastream,
G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
data_stream_put_string0(datastream, "GwyIntSet", NULL, NULL);
g_data_output_stream_put_uint64(datastream, 0, NULL, NULL);
guint len = 8;
data_stream_put_string0(datastream, "ranges", NULL, NULL);
g_data_output_stream_put_byte(datastream, GWY_SERIALIZABLE_INT32_ARRAY,
NULL, NULL);
g_data_output_stream_put_uint64(datastream, len, NULL, NULL);
for (guint i = 0; i < len; i++)
g_data_output_stream_put_uint32(datastream, i/3, NULL, NULL);
GwyErrorList *error_list = NULL;
gwy_error_list_add(&error_list,
GWY_DESERIALIZE_ERROR, GWY_DESERIALIZE_ERROR_INVALID,
"GwyIntSet ranges are not in canonical form.");
deserialize_assert_failure(G_MEMORY_OUTPUT_STREAM(stream), error_list);
gwy_error_list_clear(&error_list);
g_object_unref(datastream);
g_object_unref(stream);
}
GSpeechdClient *
gspeechd_client_new (GSocketConnection *connection)
{
GSpeechdClient *client;
GOutputStream *output_stream;
GInputStream *input_stream;
client = g_slice_new0 (GSpeechdClient);
client->ref_count = 1;
client->cancellable = g_cancellable_new ();
client->connection = g_object_ref (connection);
client->failed = FALSE;
/*
* Start listening for the message
*/
input_stream = g_io_stream_get_input_stream(G_IO_STREAM(connection));
client->input = g_data_input_stream_new (input_stream);
g_data_input_stream_read_line_async(client->input,
G_PRIORITY_DEFAULT,
client->cancellable,
(GAsyncReadyCallback)gspeechd_client_read_line_cb,
gspeechd_client_ref (client));
output_stream = g_io_stream_get_output_stream (G_IO_STREAM(connection));
client->output = g_data_output_stream_new (output_stream);
return (client);
}
/*
* This function will be called when our CGI is accessed.
*/
static void
request_handler(const gchar *path,
const gchar *method,
const gchar *query,
GHashTable *params,
GOutputStream *output_stream,
gpointer user_data)
{
GDataOutputStream *dos;
guint *timer = (guint*) user_data;
gchar msg[128];
dos = g_data_output_stream_new(output_stream);
/* Send out the HTTP response status code */
g_data_output_stream_put_string(dos,"Content-Type: text/plain\r\n", NULL, NULL);
g_data_output_stream_put_string(dos,"Status: 200 OK\r\n\r\n", NULL, NULL);
/* Our custom message */
g_snprintf(msg, sizeof(msg),"You have accessed '%s'\n", path ? path:"(NULL)");
g_data_output_stream_put_string(dos, msg, NULL, NULL);
g_snprintf(msg, sizeof(msg), "\n%s() [%s:%d] \n\n"
"- Hello World! -\n"
"I've been running for %d seconds\n",
__FUNCTION__, __FILE__, __LINE__, *timer );
g_data_output_stream_put_string(dos, msg, NULL, NULL);
g_object_unref(dos);
}
void
test_int_set_serialize_failure_odd(void)
{
GOutputStream *stream = g_memory_output_stream_new(NULL, 0,
g_realloc, g_free);
GDataOutputStream *datastream = g_data_output_stream_new(stream);
g_data_output_stream_set_byte_order(datastream,
G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
data_stream_put_string0(datastream, "GwyIntSet", NULL, NULL);
g_data_output_stream_put_uint64(datastream, 0, NULL, NULL);
guint len = 5;
data_stream_put_string0(datastream, "ranges", NULL, NULL);
g_data_output_stream_put_byte(datastream, GWY_SERIALIZABLE_INT32_ARRAY,
NULL, NULL);
g_data_output_stream_put_uint64(datastream, len, NULL, NULL);
for (guint i = 0; i < len; i++)
g_data_output_stream_put_uint32(datastream, i, NULL, NULL);
GwyErrorList *error_list = NULL;
gwy_error_list_add(&error_list,
GWY_DESERIALIZE_ERROR, GWY_DESERIALIZE_ERROR_INVALID,
"Data length of ‘GwyIntSet’ is %lu which is not "
"a multiple of 2.",
(gulong)len);
deserialize_assert_failure(G_MEMORY_OUTPUT_STREAM(stream), error_list);
gwy_error_list_clear(&error_list);
g_object_unref(datastream);
g_object_unref(stream);
}
static void
_j4status_io_stream_set_connection(J4statusIOStream *self, GSocketConnection *connection)
{
self->connection = connection;
self->out = g_data_output_stream_new(g_io_stream_get_output_stream(G_IO_STREAM(self->connection)));
self->in = g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(self->connection)));
if ( ! self->header_sent )
_j4status_io_stream_put_header(self, self->io->header);
g_data_input_stream_read_line_async(self->in, G_PRIORITY_DEFAULT, NULL, _j4status_io_stream_read_callback, self);
}
GDataOutputStream *ekg_connection_add(
GSocketConnection *conn,
GInputStream *raw_instream,
GOutputStream *raw_outstream,
ekg_input_callback_t callback,
ekg_failure_callback_t failure_callback,
gpointer priv_data)
{
struct ekg_connection *c = g_slice_new(struct ekg_connection);
GOutputStream *bout = g_buffered_output_stream_new(raw_outstream);
c->conn = conn;
c->instream = g_data_input_stream_new(raw_instream);
c->outstream = g_data_output_stream_new(bout);
c->cancellable = g_cancellable_new();
c->wr_buffer = g_string_new("");
c->callback = callback;
c->failure_callback = failure_callback;
c->priv_data = priv_data;
#if NEED_SLAVERY
c->master = get_slave_connection_by_conn(conn);
c->slave = NULL;
/* be a good slave.. er, servant */
if (G_UNLIKELY(c->master)) {
struct ekg_connection *ci;
c->master->slave = c;
/* shift flush handlers (if set)
* this is required in order to be able to easily set flush
* handlers for future slaves */
for (ci = c;
ci->master && (ci->master->flush_handler != setup_async_write);
ci = ci->master)
ci->flush_handler = ci->master->flush_handler;
ci->flush_handler = setup_async_write;
} else
#endif
c->flush_handler = setup_async_write;
/* LF works fine for CRLF */
g_data_input_stream_set_newline_type(c->instream, G_DATA_STREAM_NEWLINE_TYPE_LF);
/* disallow any blocking writes */
g_buffered_output_stream_set_auto_grow(G_BUFFERED_OUTPUT_STREAM(bout), TRUE);
connections = g_slist_prepend(connections, c);
#if NEED_SLAVERY
if (G_LIKELY(!c->master))
#endif
setup_async_read(c);
return c->outstream;
}
static TestClient *
test_client_new (const char *id,
MetaWindowClientType type,
GError **error)
{
TestClient *client = g_new0 (TestClient, 1);
GSubprocessLauncher *launcher;
GSubprocess *subprocess;
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE);
g_assert (meta_is_wayland_compositor ());
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
g_subprocess_launcher_setenv (launcher,
"WAYLAND_DISPLAY", meta_wayland_get_wayland_display_name (compositor),
TRUE);
g_subprocess_launcher_setenv (launcher,
"DISPLAY", meta_wayland_get_xwayland_display_name (compositor),
TRUE);
subprocess = g_subprocess_launcher_spawn (launcher,
error,
test_client_path,
"--client-id",
id,
type == META_WINDOW_CLIENT_TYPE_WAYLAND ? "--wayland" : NULL,
NULL);
g_object_unref (launcher);
if (!subprocess)
return NULL;
client->type = type;
client->id = g_strdup (id);
client->cancellable = g_cancellable_new ();
client->subprocess = subprocess;
client->in = g_data_output_stream_new (g_subprocess_get_stdin_pipe (subprocess));
client->out = g_data_input_stream_new (g_subprocess_get_stdout_pipe (subprocess));
client->loop = g_main_loop_new (NULL, FALSE);
if (client->type == META_WINDOW_CLIENT_TYPE_X11)
client->waiter = async_waiter_new ();
return client;
}
static VALUE
stream_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE base_stream,
byte_order;
rb_scan_args(argc, argv, "11", &base_stream, &byte_order);
G_INITIALIZE(self,
g_data_output_stream_new(RVAL2GOUTPUTSTREAM(base_stream)));
if (!NIL_P(byte_order))
g_data_output_stream_set_byte_order(_SELF(self),
RVAL2GDATASTREAMBYTEORDER(byte_order));
return Qnil;
}
static void
extract_content_child_process (PopplerDocument *document,
gsize n_bytes,
int fd[2])
{
GString *str;
gint64 size;
GOutputStream *output_stream;
GDataOutputStream *dataout_stream;
/* This is the child extracting the content, hopefully in time */
output_stream = g_unix_output_stream_new (fd[1], FALSE);
dataout_stream = g_data_output_stream_new (output_stream);
str = extract_content_text (document, n_bytes);
size = (gint64) str->len;
/* Write the results to the pipe */
if (g_data_output_stream_put_int64 (dataout_stream, size, NULL, NULL)) {
g_output_stream_write_all (output_stream,
str->str,
str->len,
NULL,
NULL,
NULL);
}
g_debug ("Child: Content extraction now finished in child process, "
"written %" G_GSIZE_FORMAT " bytes to parent process",
size);
g_string_free (str, TRUE);
g_object_unref (dataout_stream);
g_object_unref (output_stream);
close (fd[1]);
exit (0);
}
static void
disabled_repos_free (GHashTable *disabled)
{
GHashTableIter iter;
GFile *file;
GFileOutputStream *file_stream;
GDataOutputStream *data_stream;
const gchar *line = PACMAN_REPO_LIST_HEADER "\n";
g_return_if_fail (disabled != NULL);
g_debug ("pacman: storing disabled repos in %s", PACMAN_REPO_LIST);
file = g_file_new_for_path (PACMAN_REPO_LIST);
file_stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL);
if (file_stream == NULL) {
g_object_unref (file);
g_hash_table_unref (disabled);
return;
}
g_hash_table_iter_init (&iter, disabled);
data_stream = g_data_output_stream_new (G_OUTPUT_STREAM (file_stream));
/* write header, then all disabled repos line by line */
if (g_data_output_stream_put_string (data_stream, line, NULL, NULL)) {
while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) &&
g_data_output_stream_put_string (data_stream, line, NULL, NULL) &&
g_data_output_stream_put_string (data_stream, "\n", NULL, NULL));
}
g_object_unref (data_stream);
g_object_unref (file_stream);
g_object_unref (file);
g_hash_table_unref (disabled);
}
static void
disabled_repos_free (GHashTable *table)
{
GHashTableIter iter;
GFile *file;
GFileOutputStream *os;
GDataOutputStream *output;
const gchar *line;
g_return_if_fail (table != NULL);
g_debug ("storing disabled repos in %s", PK_BACKEND_REPO_FILE);
file = g_file_new_for_path (PK_BACKEND_REPO_FILE);
os = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL);
if (os == NULL) {
g_object_unref (file);
g_hash_table_unref (table);
return;
}
g_hash_table_iter_init (&iter, table);
output = g_data_output_stream_new (G_OUTPUT_STREAM (os));
/* write all disabled repos line by line */
while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) &&
g_data_output_stream_put_string (output, line, NULL, NULL) &&
g_data_output_stream_put_byte (output, '\n', NULL, NULL));
g_object_unref (output);
g_object_unref (os);
g_object_unref (file);
g_hash_table_unref (table);
}
/* Save app data lists to file */
static gboolean
idle_save_application_usage (gpointer data)
{
ShellAppUsage *self = SHELL_APP_USAGE (data);
UsageIterator iter;
const char *current_context;
const char *context;
const char *id;
UsageData *usage;
GFileOutputStream *output;
GOutputStream *buffered_output;
GDataOutputStream *data_output;
GError *error = NULL;
self->save_id = 0;
/* Parent directory is already created by shell-global */
output = g_file_replace (self->configfile, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
if (!output)
{
g_debug ("Could not save applications usage data: %s", error->message);
g_error_free (error);
return FALSE;
}
buffered_output = g_buffered_output_stream_new (G_OUTPUT_STREAM (output));
g_object_unref (output);
data_output = g_data_output_stream_new (G_OUTPUT_STREAM (buffered_output));
g_object_unref (buffered_output);
if (!g_data_output_stream_put_string (data_output, "<?xml version=\"1.0\"?>\n<application-state>\n", NULL, &error))
goto out;
usage_iterator_init (self, &iter);
current_context = NULL;
while (usage_iterator_next (self, &iter, &context, &id, &usage))
{
ShellApp *app;
app = shell_app_system_lookup_app (shell_app_system_get_default(), id);
if (!app)
continue;
if (context != current_context)
{
if (current_context != NULL)
{
if (!g_data_output_stream_put_string (data_output, " </context>", NULL, &error))
goto out;
}
current_context = context;
if (!g_data_output_stream_put_string (data_output, " <context", NULL, &error))
goto out;
if (!write_attribute_string (data_output, "id", context, &error))
goto out;
if (!g_data_output_stream_put_string (data_output, ">\n", NULL, &error))
goto out;
}
if (!g_data_output_stream_put_string (data_output, " <application", NULL, &error))
goto out;
if (!write_attribute_string (data_output, "id", id, &error))
goto out;
if (!write_attribute_uint (data_output, "open-window-count", shell_app_get_n_windows (app), &error))
goto out;
if (!write_attribute_double (data_output, "score", usage->score, &error))
goto out;
if (!write_attribute_uint (data_output, "last-seen", usage->last_seen, &error))
goto out;
if (!g_data_output_stream_put_string (data_output, "/>\n", NULL, &error))
goto out;
}
if (current_context != NULL)
{
if (!g_data_output_stream_put_string (data_output, " </context>\n", NULL, &error))
goto out;
}
if (!g_data_output_stream_put_string (data_output, "</application-state>\n", NULL, &error))
goto out;
out:
if (!error)
g_output_stream_close_async (G_OUTPUT_STREAM (data_output), 0, NULL, NULL, NULL);
g_object_unref (data_output);
if (error)
{
g_debug ("Could not save applications usage data: %s", error->message);
g_error_free (error);
}
return FALSE;
}
gboolean
_g_dbus_auth_run_server (GDBusAuth *auth,
GDBusAuthObserver *observer,
const gchar *guid,
gboolean allow_anonymous,
GDBusCapabilityFlags offered_capabilities,
GDBusCapabilityFlags *out_negotiated_capabilities,
GCredentials **out_received_credentials,
GCancellable *cancellable,
GError **error)
{
gboolean ret;
ServerState state;
GDataInputStream *dis;
GDataOutputStream *dos;
GError *local_error;
guchar byte;
gchar *line;
gsize line_length;
GDBusAuthMechanism *mech;
gchar *s;
GDBusCapabilityFlags negotiated_capabilities;
GCredentials *credentials;
debug_print ("SERVER: initiating");
ret = FALSE;
dis = NULL;
dos = NULL;
mech = NULL;
negotiated_capabilities = 0;
credentials = NULL;
if (!g_dbus_is_guid (guid))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"The given guid `%s' is not valid",
guid);
goto out;
}
dis = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (auth->priv->stream)));
dos = G_DATA_OUTPUT_STREAM (g_data_output_stream_new (g_io_stream_get_output_stream (auth->priv->stream)));
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (dis), FALSE);
g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (dos), FALSE);
g_data_input_stream_set_newline_type (dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
/* first read the NUL-byte (TODO: read credentials if using a unix domain socket) */
#ifdef G_OS_UNIX
if (G_IS_UNIX_CONNECTION (auth->priv->stream) && g_unix_credentials_message_is_supported ())
{
local_error = NULL;
credentials = g_unix_connection_receive_credentials (G_UNIX_CONNECTION (auth->priv->stream),
cancellable,
&local_error);
if (credentials == NULL)
{
g_propagate_error (error, local_error);
goto out;
}
}
else
{
local_error = NULL;
byte = g_data_input_stream_read_byte (dis, cancellable, &local_error);
if (local_error != NULL)
{
g_propagate_error (error, local_error);
goto out;
}
}
#else
local_error = NULL;
byte = g_data_input_stream_read_byte (dis, cancellable, &local_error);
if (local_error != NULL)
{
g_propagate_error (error, local_error);
goto out;
}
#endif
if (credentials != NULL)
{
if (G_UNLIKELY (_g_dbus_debug_authentication ()))
{
s = g_credentials_to_string (credentials);
debug_print ("SERVER: received credentials `%s'", s);
g_free (s);
}
}
else
{
debug_print ("SERVER: didn't receive any credentials");
}
state = SERVER_STATE_WAITING_FOR_AUTH;
while (TRUE)
{
switch (state)
{
case SERVER_STATE_WAITING_FOR_AUTH:
debug_print ("SERVER: WaitingForAuth");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
debug_print ("SERVER: WaitingForAuth, read `%s'", line);
if (line == NULL)
goto out;
if (g_strcmp0 (line, "AUTH") == 0)
{
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
g_free (line);
}
else if (g_str_has_prefix (line, "AUTH "))
{
gchar **tokens;
const gchar *encoded;
const gchar *mech_name;
GType auth_mech_to_use_gtype;
tokens = g_strsplit (line, " ", 0);
g_free (line);
switch (g_strv_length (tokens))
{
case 2:
/* no initial response */
mech_name = tokens[1];
encoded = NULL;
break;
case 3:
/* initial response */
mech_name = tokens[1];
encoded = tokens[2];
break;
default:
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Unexpected line `%s' while in WaitingForAuth state",
line);
g_strfreev (tokens);
goto out;
}
/* TODO: record that the client has attempted to use this mechanism */
//g_debug ("client is trying `%s'", mech_name);
auth_mech_to_use_gtype = find_mech_by_name (auth, mech_name);
if ((auth_mech_to_use_gtype == (GType) 0) ||
(!allow_anonymous && g_strcmp0 (mech_name, "ANONYMOUS") == 0))
{
/* We don't support this auth mechanism */
g_strfreev (tokens);
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
/* stay in WAITING FOR AUTH */
state = SERVER_STATE_WAITING_FOR_AUTH;
}
else
{
gchar *initial_response;
gsize initial_response_len;
mech = g_object_new (auth_mech_to_use_gtype,
"stream", auth->priv->stream,
"credentials", credentials,
NULL);
initial_response = NULL;
initial_response_len = 0;
if (encoded != NULL)
{
initial_response = hexdecode (encoded, &initial_response_len, error);
if (initial_response == NULL)
{
g_prefix_error (error, "Initial response is malformed: ");
/* invalid encoding, disconnect! */
g_strfreev (tokens);
goto out;
}
}
_g_dbus_auth_mechanism_server_initiate (mech,
initial_response,
initial_response_len);
g_free (initial_response);
g_strfreev (tokens);
change_state:
switch (_g_dbus_auth_mechanism_server_get_state (mech))
{
case G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED:
if (observer != NULL &&
!g_dbus_auth_observer_authorize_authenticated_peer (observer,
auth->priv->stream,
credentials))
{
/* disconnect */
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Cancelled via GDBusAuthObserver::authorize-authenticated-peer"));
goto out;
}
else
{
s = g_strdup_printf ("OK %s\r\n", guid);
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
state = SERVER_STATE_WAITING_FOR_BEGIN;
}
break;
case G_DBUS_AUTH_MECHANISM_STATE_REJECTED:
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
state = SERVER_STATE_WAITING_FOR_AUTH;
break;
case G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA:
state = SERVER_STATE_WAITING_FOR_DATA;
break;
case G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND:
{
gchar *data;
gsize data_len;
gchar *encoded_data;
data = _g_dbus_auth_mechanism_server_data_send (mech, &data_len);
encoded_data = hexencode (data);
s = g_strdup_printf ("DATA %s\r\n", encoded_data);
g_free (encoded_data);
g_free (data);
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
}
goto change_state;
break;
default:
/* TODO */
g_assert_not_reached ();
break;
}
}
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Unexpected line `%s' while in WaitingForAuth state",
line);
g_free (line);
goto out;
}
break;
case SERVER_STATE_WAITING_FOR_DATA:
debug_print ("SERVER: WaitingForData");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
debug_print ("SERVER: WaitingForData, read `%s'", line);
if (line == NULL)
goto out;
if (g_str_has_prefix (line, "DATA "))
{
gchar *encoded;
gchar *decoded_data;
gsize decoded_data_len;
encoded = g_strdup (line + 5);
g_free (line);
g_strstrip (encoded);
decoded_data = hexdecode (encoded, &decoded_data_len, error);
g_free (encoded);
if (decoded_data == NULL)
{
g_prefix_error (error, "DATA response is malformed: ");
/* invalid encoding, disconnect! */
goto out;
}
_g_dbus_auth_mechanism_server_data_receive (mech, decoded_data, decoded_data_len);
g_free (decoded_data);
/* oh man, this goto-crap is so ugly.. really need to rewrite the state machine */
goto change_state;
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Unexpected line `%s' while in WaitingForData state",
line);
g_free (line);
}
goto out;
case SERVER_STATE_WAITING_FOR_BEGIN:
debug_print ("SERVER: WaitingForBegin");
/* Use extremely slow (but reliable) line reader - this basically
* does a recvfrom() system call per character
*
* (the problem with using GDataInputStream's read_line is that because of
* buffering it might start reading into the first D-Bus message that
* appears after "BEGIN\r\n"....)
*/
line = _my_g_input_stream_read_line_safe (g_io_stream_get_input_stream (auth->priv->stream),
&line_length,
cancellable,
error);
debug_print ("SERVER: WaitingForBegin, read `%s'", line);
if (line == NULL)
goto out;
if (g_strcmp0 (line, "BEGIN") == 0)
{
/* YAY, done! */
ret = TRUE;
g_free (line);
goto out;
}
else if (g_strcmp0 (line, "NEGOTIATE_UNIX_FD") == 0)
{
g_free (line);
if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING)
{
negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
s = "AGREE_UNIX_FD\r\n";
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
else
{
s = "ERROR \"fd passing not offered\"\r\n";
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
}
else
{
g_debug ("Unexpected line `%s' while in WaitingForBegin state", line);
g_free (line);
s = "ERROR \"Unknown Command\"\r\n";
debug_print ("SERVER: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
break;
default:
g_assert_not_reached ();
break;
}
}
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Not implemented (server)");
out:
if (mech != NULL)
g_object_unref (mech);
if (dis != NULL)
g_object_unref (dis);
if (dos != NULL)
g_object_unref (dos);
/* ensure return value is FALSE if error is set */
if (error != NULL && *error != NULL)
{
ret = FALSE;
}
if (ret)
{
if (out_negotiated_capabilities != NULL)
*out_negotiated_capabilities = negotiated_capabilities;
if (out_received_credentials != NULL)
*out_received_credentials = credentials != NULL ? g_object_ref (credentials) : NULL;
}
if (credentials != NULL)
g_object_unref (credentials);
debug_print ("SERVER: Done, authenticated=%d", ret);
return ret;
}
int
main(int argc, char *argv[])
{
EventdCoreContext *context;
gchar *runtime_dir = NULL;
gchar *control_socket = NULL;
gchar **binds = NULL;
gboolean take_over_socket = FALSE;
gboolean enable_relay = TRUE;
gboolean enable_sd_modules = TRUE;
gchar *config_dir = NULL;
gboolean daemonize = FALSE;
gboolean print_paths = FALSE;
gboolean print_version = FALSE;
EventdReturnCode retval = EVENTD_RETURN_CODE_OK;
GError *error = NULL;
GOptionContext *option_context = NULL;
#ifdef EVENTD_DEBUG
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
#endif /* EVENTD_DEBUG */
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, EVENTD_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
if ( ! g_get_filename_charsets(NULL) )
{
g_warning(PACKAGE_NAME " does not support non-UTF-8 filename encoding");
return EVENTD_RETURN_CODE_FILESYSTEM_ENCODING_ERROR;
}
if ( G_UNLIKELY(! g_module_supported()) )
{
g_warning("No loadable module support");
return EVENTD_RETURN_CODE_NO_MODULE_SUPPORT_ERROR;
}
#ifdef EVENTD_DEBUG
setvbuf(stdout, NULL, _IOLBF, 0);
const gchar *debug_log_filename = g_getenv("EVENTD_DEBUG_LOG_FILENAME");
GDataOutputStream *debug_stream = NULL;
if ( debug_log_filename != NULL )
{
GFile *debug_log;
debug_log = g_file_new_for_path(debug_log_filename);
GError *error = NULL;
GFileOutputStream *debug_log_stream;
debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error);
if ( debug_log_stream == NULL )
{
g_warning("Couldn't open debug log file: %s", error->message);
g_clear_error(&error);
}
else
{
debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream));
g_object_unref(debug_log_stream);
g_log_set_default_handler(_eventd_core_debug_log_handler, debug_stream);
}
g_object_unref(debug_log);
}
#endif /* EVENTD_DEBUG */
context = g_new0(EventdCoreContext, 1);
context->interface.get_sockets = eventd_core_get_sockets;
context->interface.push_event = eventd_core_push_event;
#ifdef G_OS_UNIX
context->system_mode = ( g_getenv("XDG_RUNTIME_DIR") == NULL );
if ( context->system_mode )
g_setenv("XDG_RUNTIME_DIR", "/run", TRUE);
#endif /* G_OS_UNIX */
GOptionEntry entries[] =
{
{ "private-socket", 'i', 0, G_OPTION_ARG_FILENAME, &control_socket, "Socket to listen for internal control", "<socket>" },
{ "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &binds, "Add a socket to listen to", "<socket>" },
{ "take-over", 't', GIO_UNIX_OPTION_FLAG, G_OPTION_ARG_NONE, &take_over_socket, "Take over socket", NULL },
{ "no-relay", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_relay, "Disable the relay feature", NULL },
{ "no-service-discovery", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_sd_modules, "Disable the service discovery feature", NULL },
{ "config-dir", 'c', 0, G_OPTION_ARG_FILENAME, &config_dir, "Additionnal configuration directory", "<directory>" },
{ "daemonize", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &daemonize, NULL, NULL },
{ "paths", 'P', 0, G_OPTION_ARG_NONE, &print_paths, "Print search paths", NULL },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL },
{ .long_name = NULL }
};
int
main(int argc, char *argv[])
{
gboolean print_version = FALSE;
gboolean one_shot = FALSE;
gchar *output_plugin = NULL;
gchar **servers_desc = NULL;
gchar **streams_desc = NULL;
gchar **input_plugins = NULL;
gchar **order = NULL;
gchar *config = NULL;
int retval = 0;
GError *error = NULL;
GOptionContext *option_context = NULL;
GOptionGroup *option_group;
#if DEBUG
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
#endif /* ! DEBUG */
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
#if DEBUG
const gchar *debug_log_filename = g_getenv("J4STATUS_DEBUG_LOG_FILENAME");
GDataOutputStream *debug_stream = NULL;
if ( debug_log_filename != NULL )
{
GFile *debug_log;
debug_log = g_file_new_for_path(debug_log_filename);
GError *error = NULL;
GFileOutputStream *debug_log_stream;
debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error);
if ( debug_log_stream == NULL )
{
g_warning("Couldn't open debug log file: %s", error->message);
g_clear_error(&error);
}
else
{
debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream));
g_object_unref(debug_log_stream);
g_log_set_default_handler(_j4status_core_debug_log_handler, debug_stream);
}
g_object_unref(debug_log);
}
#endif /* DEBUG */
GOptionEntry entries[] =
{
{ "output", 'o', 0, G_OPTION_ARG_STRING, &output_plugin, "Output plugin to use", "<plugin>" },
{ "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &servers_desc, "Socket to listen on, will create a stream on connection (may be specified several times)", "<listen description>" },
{ "stream", 't', 0, G_OPTION_ARG_STRING_ARRAY, &streams_desc, "Stream to read from/write to (may be specified several times)", "<stream description>" },
{ "input", 'i', 0, G_OPTION_ARG_STRING_ARRAY, &input_plugins, "Input plugins to use (may be specified several times)", "<plugin>" },
{ "order", 'O', 0, G_OPTION_ARG_STRING_ARRAY, &order, "Order of sections, specified once a section (see man)", "<section id>" },
{ "one-shot", '1', 0, G_OPTION_ARG_NONE, &one_shot, "Tells j4status to stop right after starting", NULL },
{ "config", 'c', 0, G_OPTION_ARG_STRING, &config, "Config file to use", "<config>" },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL },
{ NULL }
};
option_context = g_option_context_new("- status line generator");
option_group = g_option_group_new(NULL, NULL, NULL, NULL, NULL);
g_option_group_set_translation_domain(option_group, GETTEXT_PACKAGE);
g_option_group_add_entries(option_group, entries);
g_option_context_set_main_group(option_context, option_group);
if ( ! g_option_context_parse(option_context, &argc, &argv, &error) )
{
g_warning("Option parsing failed: %s\n", error->message);
g_clear_error(&error);
retval = 1;
goto end;
}
g_option_context_free(option_context);
if ( print_version )
{
g_fprintf(stdout, PACKAGE_NAME " " PACKAGE_VERSION "\n");
goto end;
}
if ( config != NULL )
{
g_setenv("J4STATUS_CONFIG_FILE", config, TRUE);
g_free(config);
}
GKeyFile *key_file;
key_file = j4status_config_get_key_file("Plugins");
if ( key_file != NULL )
{
if ( output_plugin == NULL )
output_plugin = g_key_file_get_string(key_file, "Plugins", "Output", NULL);
if ( input_plugins == NULL )
input_plugins = g_key_file_get_string_list(key_file, "Plugins", "Input", NULL, NULL);
if ( order == NULL )
order = g_key_file_get_string_list(key_file, "Plugins", "Order", NULL, NULL);
g_key_file_free(key_file);
}
J4statusCoreContext *context;
context = g_new0(J4statusCoreContext, 1);
J4statusCoreInterface interface = {
.context = context,
.add_section = _j4status_core_add_section,
.remove_section = _j4status_core_remove_section,
.trigger_generate = _j4status_core_trigger_generate,
.trigger_action = _j4status_core_trigger_action,
};
#ifdef G_OS_UNIX
g_unix_signal_add(SIGTERM, _j4status_core_source_quit, context);
g_unix_signal_add(SIGINT, _j4status_core_source_quit, context);
g_unix_signal_add(SIGUSR1, _j4status_core_signal_usr1, context);
g_unix_signal_add(SIGUSR2, _j4status_core_signal_usr2, context);
/* Ignore SIGPIPE as it is useless */
signal(SIGPIPE, SIG_IGN);
#endif /* G_OS_UNIX */
context->output_plugin = j4status_plugins_get_output_plugin(&interface, output_plugin);
if ( context->output_plugin == NULL )
{
g_warning("No usable output plugin, tried '%s'", output_plugin);
retval = 10;
goto end;
}
gchar *header = NULL;
if ( context->output_plugin->interface.generate_header != NULL )
header = context->output_plugin->interface.generate_header(context->output_plugin->context);
/* Creating input/output stream */
context->io = j4status_io_new(context, header, (const gchar * const *) servers_desc, (const gchar * const *) streams_desc);
if ( context->io == NULL )
{
g_warning("Couldn't create input/output streams");
retval = 2;
goto end;
}
if ( order != NULL )
{
context->order_weights = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
gchar **id;
for ( id = order ; *id != NULL ; ++id )
g_hash_table_insert(context->order_weights, *id, GINT_TO_POINTER(1 + id - order));
g_free(order);
}
context->sections_hash = g_hash_table_new(g_str_hash, g_str_equal);
context->input_plugins = j4status_plugins_get_input_plugins(&interface, input_plugins);
if ( context->input_plugins == NULL )
{
g_warning("No input plugins, will stop early");
one_shot = TRUE;
retval = 11;
}
context->sections = g_list_reverse(context->sections);
if ( context->order_weights != NULL )
context->sections = g_list_sort(context->sections, _j4status_core_compare_sections);
_j4status_core_start(context);
if ( one_shot )
g_idle_add(_j4status_core_source_quit, context);
context->loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(context->loop);
g_main_loop_unref(context->loop);
context->loop = NULL;
GList *input_plugin_;
J4statusInputPlugin *input_plugin;
for ( input_plugin_ = context->input_plugins ; input_plugin_ != NULL ; input_plugin_ = g_list_next(input_plugin_) )
{
input_plugin = input_plugin_->data;
input_plugin->interface.uninit(input_plugin->context);
}
if ( context->output_plugin->interface.uninit != NULL )
context->output_plugin->interface.uninit(context->output_plugin->context);
j4status_io_free(context->io);
if ( context->order_weights != NULL )
g_hash_table_unref(context->order_weights);
g_hash_table_unref(context->sections_hash);
end:
#if DEBUG
if ( debug_stream != NULL )
g_object_unref(debug_stream);
#endif /* DEBUG */
return retval;
}
GCabFolder *cabfolder = g_ptr_array_index (self->folders, 0);
GCabFile *file;
gsize nfiles = gcab_folder_get_nfiles (cabfolder);
GInputStream *in = NULL;
GDataOutputStream *dstream = NULL;
gboolean success = FALSE;
gssize len, offset = 0;
cdata_t block = { 0, };
guint8 data[DATABLOCKSIZE];
gsize written;
size_t sumstr = 0;
GSList *l, *files;
cfile_t *prevf = NULL;
int i;
dstream = g_data_output_stream_new (out);
g_data_output_stream_set_byte_order (dstream, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
files = gcab_folder_get_files (cabfolder);
for (l = files; l != NULL; l = l->next)
sumstr += strlen (GCAB_FILE (l->data)->name) + 1;
folder.typecomp = cabfolder->comptype;
folder.offsetdata = CFI_START + nfiles * 16 + sumstr;
folder.ndatab = gcab_folder_get_ndatablocks (cabfolder);
/* avoid seeking to allow growing output streams */
for (i = 0; i < folder.offsetdata; i++)
if (!g_data_output_stream_put_byte (dstream, 0, cancellable, error))
goto end;
gchar *
_g_dbus_auth_run_client (GDBusAuth *auth,
GDBusCapabilityFlags offered_capabilities,
GDBusCapabilityFlags *out_negotiated_capabilities,
GCancellable *cancellable,
GError **error)
{
gchar *s;
GDataInputStream *dis;
GDataOutputStream *dos;
GCredentials *credentials;
gchar *ret_guid;
gchar *line;
gsize line_length;
gchar **supported_auth_mechs;
GPtrArray *attempted_auth_mechs;
GDBusAuthMechanism *mech;
ClientState state;
GDBusCapabilityFlags negotiated_capabilities;
debug_print ("CLIENT: initiating");
ret_guid = NULL;
supported_auth_mechs = NULL;
attempted_auth_mechs = g_ptr_array_new ();
mech = NULL;
negotiated_capabilities = 0;
credentials = NULL;
dis = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (auth->priv->stream)));
dos = G_DATA_OUTPUT_STREAM (g_data_output_stream_new (g_io_stream_get_output_stream (auth->priv->stream)));
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (dis), FALSE);
g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (dos), FALSE);
g_data_input_stream_set_newline_type (dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
#ifdef G_OS_UNIX
if (G_IS_UNIX_CONNECTION (auth->priv->stream) && g_unix_credentials_message_is_supported ())
{
credentials = g_credentials_new ();
if (!g_unix_connection_send_credentials (G_UNIX_CONNECTION (auth->priv->stream),
cancellable,
error))
goto out;
}
else
{
if (!g_data_output_stream_put_byte (dos, '\0', cancellable, error))
goto out;
}
#else
if (!g_data_output_stream_put_byte (dos, '\0', cancellable, error))
goto out;
#endif
if (credentials != NULL)
{
if (G_UNLIKELY (_g_dbus_debug_authentication ()))
{
s = g_credentials_to_string (credentials);
debug_print ("CLIENT: sent credentials `%s'", s);
g_free (s);
}
}
else
{
debug_print ("CLIENT: didn't send any credentials");
}
/* TODO: to reduce roundtrips, try to pick an auth mechanism to start with */
/* Get list of supported authentication mechanisms */
s = "AUTH\r\n";
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
state = CLIENT_STATE_WAITING_FOR_REJECT;
while (TRUE)
{
switch (state)
{
case CLIENT_STATE_WAITING_FOR_REJECT:
debug_print ("CLIENT: WaitingForReject");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
debug_print ("CLIENT: WaitingForReject, read '%s'", line);
foobar:
if (!g_str_has_prefix (line, "REJECTED "))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"In WaitingForReject: Expected `REJECTED am1 am2 ... amN', got `%s'",
line);
g_free (line);
goto out;
}
if (supported_auth_mechs == NULL)
{
supported_auth_mechs = g_strsplit (line + sizeof ("REJECTED ") - 1, " ", 0);
#if 0
for (n = 0; supported_auth_mechs != NULL && supported_auth_mechs[n] != NULL; n++)
g_printerr ("supported_auth_mechs[%d] = `%s'\n", n, supported_auth_mechs[n]);
#endif
}
g_free (line);
mech = client_choose_mech_and_send_initial_response (auth,
credentials,
(const gchar* const *) supported_auth_mechs,
attempted_auth_mechs,
dos,
cancellable,
error);
if (mech == NULL)
goto out;
if (_g_dbus_auth_mechanism_client_get_state (mech) == G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA)
state = CLIENT_STATE_WAITING_FOR_DATA;
else
state = CLIENT_STATE_WAITING_FOR_OK;
break;
case CLIENT_STATE_WAITING_FOR_OK:
debug_print ("CLIENT: WaitingForOK");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
debug_print ("CLIENT: WaitingForOK, read `%s'", line);
if (g_str_has_prefix (line, "OK "))
{
if (!g_dbus_is_guid (line + 3))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Invalid OK response `%s'",
line);
g_free (line);
goto out;
}
ret_guid = g_strdup (line + 3);
g_free (line);
if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING)
{
s = "NEGOTIATE_UNIX_FD\r\n";
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
state = CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD;
}
else
{
s = "BEGIN\r\n";
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
goto out;
}
}
else if (g_str_has_prefix (line, "REJECTED "))
{
goto foobar;
}
else
{
/* TODO: handle other valid responses */
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"In WaitingForOk: unexpected response `%s'",
line);
g_free (line);
goto out;
}
break;
case CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD:
debug_print ("CLIENT: WaitingForAgreeUnixFD");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
debug_print ("CLIENT: WaitingForAgreeUnixFD, read=`%s'", line);
if (g_strcmp0 (line, "AGREE_UNIX_FD") == 0)
{
g_free (line);
negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
s = "BEGIN\r\n";
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
goto out;
}
else if (g_str_has_prefix (line, "ERROR") && (line[5] == 0 || g_ascii_isspace (line[5])))
{
//g_strstrip (line + 5); g_debug ("bah, no unix_fd: `%s'", line + 5);
g_free (line);
s = "BEGIN\r\n";
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
goto out;
}
else
{
/* TODO: handle other valid responses */
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"In WaitingForAgreeUnixFd: unexpected response `%s'",
line);
g_free (line);
goto out;
}
break;
case CLIENT_STATE_WAITING_FOR_DATA:
debug_print ("CLIENT: WaitingForData");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
debug_print ("CLIENT: WaitingForData, read=`%s'", line);
if (g_str_has_prefix (line, "DATA "))
{
gchar *encoded;
gchar *decoded_data;
gsize decoded_data_len;
encoded = g_strdup (line + 5);
g_free (line);
g_strstrip (encoded);
decoded_data = hexdecode (encoded, &decoded_data_len, error);
g_free (encoded);
if (decoded_data == NULL)
{
g_prefix_error (error, "DATA response is malformed: ");
/* invalid encoding, disconnect! */
goto out;
}
_g_dbus_auth_mechanism_client_data_receive (mech, decoded_data, decoded_data_len);
g_free (decoded_data);
if (_g_dbus_auth_mechanism_client_get_state (mech) == G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND)
{
gchar *data;
gsize data_len;
gchar *encoded_data;
data = _g_dbus_auth_mechanism_client_data_send (mech, &data_len);
encoded_data = hexencode (data);
s = g_strdup_printf ("DATA %s\r\n", encoded_data);
g_free (encoded_data);
g_free (data);
debug_print ("CLIENT: writing `%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
goto out;
}
g_free (s);
}
state = CLIENT_STATE_WAITING_FOR_OK;
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"In WaitingForData: unexpected response `%s'",
line);
g_free (line);
goto out;
}
break;
default:
g_assert_not_reached ();
break;
}
}; /* main authentication client loop */
out:
if (mech != NULL)
g_object_unref (mech);
g_ptr_array_unref (attempted_auth_mechs);
g_strfreev (supported_auth_mechs);
g_object_unref (dis);
g_object_unref (dos);
/* ensure return value is NULL if error is set */
if (error != NULL && *error != NULL)
{
g_free (ret_guid);
ret_guid = NULL;
}
if (ret_guid != NULL)
{
if (out_negotiated_capabilities != NULL)
*out_negotiated_capabilities = negotiated_capabilities;
}
if (credentials != NULL)
g_object_unref (credentials);
debug_print ("CLIENT: Done, authenticated=%d", ret_guid != NULL);
return ret_guid;
}
static void
_j4status_io_add_stream(J4statusIOContext *self, const gchar *stream_desc)
{
J4statusIOStream *stream;
if ( g_strcmp0(stream_desc, "std") == 0 )
{
GOutputStream *out;
GInputStream *in;
#ifdef G_OS_UNIX
out = g_unix_output_stream_new(1, FALSE);
in = g_unix_input_stream_new(0, FALSE);
#else /* ! G_OS_UNIX */
return;
#endif /* ! G_OS_UNIX */
stream = _j4status_io_stream_new(self);
stream->out = g_data_output_stream_new(out);
stream->in = g_data_input_stream_new(in);
g_object_unref(out);
g_object_unref(in);
_j4status_io_stream_put_header(stream, self->header);
g_data_input_stream_read_line_async(stream->in, G_PRIORITY_DEFAULT, NULL, _j4status_io_stream_read_callback, stream);
goto end;
}
GSocketAddress *address = NULL;
if ( g_str_has_prefix(stream_desc, "tcp:") )
{
const gchar *uri = stream_desc + strlen("tcp:");
gchar *port_str = g_utf8_strrchr(uri, -1, ':');
if ( port_str == NULL )
/* No port, illegal stream description */
return;
*port_str = '\0';
++port_str;
guint64 port;
port = g_ascii_strtoull(port_str, NULL, 10);
if ( port > 65535 )
return;
GInetAddress *inet_address;
inet_address = g_inet_address_new_from_string(uri);
address = g_inet_socket_address_new(inet_address, port);
}
#ifdef G_OS_UNIX
if ( g_str_has_prefix(stream_desc, "unix:") )
{
const gchar *path = stream_desc + strlen("unix:");
address = g_unix_socket_address_new(path);
}
#endif /* G_OS_UNIX */
if ( address == NULL )
return;
stream = _j4status_io_stream_new(self);
stream->address = address;
_j4status_io_stream_connect(stream);
end:
self->streams = g_list_prepend(self->streams, stream);
}
char *
gvfs_file_info_marshal (GFileInfo *info,
gsize *size)
{
GOutputStream *memstream;
GDataOutputStream *out;
GFileAttributeType type;
GFileAttributeStatus status;
GObject *obj;
char **attrs, *attr;
char *data;
int i;
memstream = g_memory_output_stream_new (NULL, 0, g_realloc, NULL);
out = g_data_output_stream_new (memstream);
g_object_unref (memstream);
attrs = g_file_info_list_attributes (info, NULL);
g_data_output_stream_put_uint32 (out,
g_strv_length (attrs),
NULL, NULL);
for (i = 0; attrs[i] != NULL; i++)
{
attr = attrs[i];
type = g_file_info_get_attribute_type (info, attr);
status = g_file_info_get_attribute_status (info, attr);
put_string (out, attr);
g_data_output_stream_put_byte (out, type,
NULL, NULL);
g_data_output_stream_put_byte (out, status,
NULL, NULL);
switch (type)
{
case G_FILE_ATTRIBUTE_TYPE_STRING:
put_string (out, g_file_info_get_attribute_string (info, attr));
break;
case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING:
put_string (out, g_file_info_get_attribute_byte_string (info, attr));
break;
case G_FILE_ATTRIBUTE_TYPE_STRINGV:
put_stringv (out, g_file_info_get_attribute_stringv (info, attr));
break;
case G_FILE_ATTRIBUTE_TYPE_BOOLEAN:
g_data_output_stream_put_byte (out,
g_file_info_get_attribute_boolean (info, attr),
NULL, NULL);
break;
case G_FILE_ATTRIBUTE_TYPE_UINT32:
g_data_output_stream_put_uint32 (out,
g_file_info_get_attribute_uint32 (info, attr),
NULL, NULL);
break;
case G_FILE_ATTRIBUTE_TYPE_INT32:
g_data_output_stream_put_int32 (out,
g_file_info_get_attribute_int32 (info, attr),
NULL, NULL);
break;
case G_FILE_ATTRIBUTE_TYPE_UINT64:
g_data_output_stream_put_uint64 (out,
g_file_info_get_attribute_uint64 (info, attr),
NULL, NULL);
break;
case G_FILE_ATTRIBUTE_TYPE_INT64:
g_data_output_stream_put_int64 (out,
g_file_info_get_attribute_int64 (info, attr),
NULL, NULL);
break;
case G_FILE_ATTRIBUTE_TYPE_OBJECT:
obj = g_file_info_get_attribute_object (info, attr);
if (obj == NULL)
{
g_data_output_stream_put_byte (out, 0,
NULL, NULL);
}
else if (G_IS_ICON (obj))
{
char *icon_str;
icon_str = g_icon_to_string (G_ICON (obj));
g_data_output_stream_put_byte (out, 1,
NULL, NULL);
put_string (out, icon_str);
g_free (icon_str);
}
else
{
g_warning ("Unsupported GFileInfo object type %s\n",
g_type_name_from_instance ((GTypeInstance *)obj));
g_data_output_stream_put_byte (out, 0,
NULL, NULL);
}
break;
case G_FILE_ATTRIBUTE_TYPE_INVALID:
default:
break;
}
}
data = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (memstream));
*size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (memstream));
g_object_unref (out);
g_strfreev (attrs);
return data;
}
