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);
}
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_core_debug_log_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
{
GDataOutputStream *stream = user_data;
g_log_default_handler(log_domain, log_level, message, NULL);
const gchar *prg_name;
gchar pid[128];
prg_name = g_get_prgname();
g_sprintf(pid, "%lu", (gulong) getpid());
g_data_output_stream_put_string(stream, "(", NULL, NULL);
if ( prg_name != NULL )
{
g_data_output_stream_put_string(stream, prg_name, NULL, NULL);
g_data_output_stream_put_string(stream, ":", NULL, NULL);
}
else
g_data_output_stream_put_string(stream, "process:", NULL, NULL);
g_data_output_stream_put_string(stream, pid, NULL, NULL);
g_data_output_stream_put_string(stream, ") ", NULL, NULL);
const gchar *log_level_message = "";
switch ( log_level & G_LOG_LEVEL_MASK )
{
case G_LOG_LEVEL_ERROR:
log_level_message = "ERROR";
break;
case G_LOG_LEVEL_CRITICAL:
log_level_message = "CRITICAL";
break;
case G_LOG_LEVEL_WARNING:
log_level_message = "WARNING";
break;
case G_LOG_LEVEL_MESSAGE:
log_level_message = "MESSAGE";
break;
case G_LOG_LEVEL_INFO:
log_level_message = "INFO";
break;
case G_LOG_LEVEL_DEBUG:
log_level_message = "DEBUG";
break;
}
g_data_output_stream_put_string(stream, log_level_message, NULL, NULL);
if ( log_domain != NULL )
{
g_data_output_stream_put_string(stream, " [", NULL, NULL);
g_data_output_stream_put_string(stream, log_domain, NULL, NULL);
g_data_output_stream_put_string(stream, "]", NULL, NULL);
}
g_data_output_stream_put_string(stream, ": ", NULL, NULL);
g_data_output_stream_put_string(stream, message, NULL, NULL);
g_data_output_stream_put_byte(stream, '\n', NULL, NULL);
}
static VALUE
stream_put_byte(int argc, VALUE *argv, VALUE self)
{
VALUE value, cancellable;
GError *error = NULL;
rb_scan_args(argc, argv, "11", &value, &cancellable);
if (!g_data_output_stream_put_byte(_SELF(self), FIX2UINT(value),
RVAL2GCANCELLABLE(cancellable), &error))
rbgio_raise_io_error(error);
return self;
}
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);
}
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;
}
void
g_vfs_afp_command_put_byte (GVfsAfpCommand *comm, guint8 byte)
{
g_data_output_stream_put_byte (G_DATA_OUTPUT_STREAM (comm), byte, NULL, NULL);
}
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;
}
