static void
g_filter_input_stream_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GFilterInputStream *filter_stream;
GObject *obj;
filter_stream = G_FILTER_INPUT_STREAM (object);
switch (prop_id)
{
case PROP_BASE_STREAM:
obj = g_value_dup_object (value);
filter_stream->base_stream = G_INPUT_STREAM (obj);
break;
case PROP_CLOSE_BASE:
g_filter_input_stream_set_close_base_stream (filter_stream,
g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* hwp_hwp3_parser_parse:
* @parser: a #HwpHWP3Parser
* @file: a #HwpHWP3File
* @error: a #GError
*
* Since: 0.0.1
*/
void hwp_hwp3_parser_parse (HwpHWP3Parser *parser,
HwpHWP3File *file,
GError **error)
{
g_return_if_fail (HWP_IS_HWP3_FILE (file));
parser->stream = file->priv->stream;
_hwp_hwp3_parser_parse_signature (parser, file, error);
_hwp_hwp3_parser_parse_doc_info (parser, file, error);
_hwp_hwp3_parser_parse_summary_info (parser, file, error);
_hwp_hwp3_parser_parse_info_block (parser, file, error);
if (file->is_compress) {
GZlibDecompressor *zd;
GInputStream *cis;
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (file->priv->stream, G_CONVERTER (zd));
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis),
TRUE);
g_object_unref (file->priv->stream);
file->priv->stream = g_object_ref (cis);
g_object_unref (zd);
}
parser->stream = file->priv->stream;
_hwp_hwp3_parser_parse_font_names (parser, file, error);
_hwp_hwp3_parser_parse_styles (parser, file, error);
_hwp_hwp3_parser_parse_paragraphs (parser, file, error);
_hwp_hwp3_parser_parse_supplementary_info_block1 (parser, file, error);
_hwp_hwp3_parser_parse_supplementary_info_block2 (parser, file, error);
}
static void
create_input_stream (GVfsFtpConnection *conn)
{
if (conn->commands_in)
{
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (conn->commands_in), FALSE);
g_object_unref (conn->commands_in);
}
conn->commands_in = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (conn->commands)));
g_data_input_stream_set_newline_type (conn->commands_in, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
}
static void make_stream (HwpHWP5File *file, GError **error)
{
GsfInput *input = NULL;
GsfInfile *ole = GSF_INFILE (file->priv->olefile);
gint n_root_entry = gsf_infile_num_children (ole);
if (n_root_entry < 1)
{
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
/* 우선 순위에 따라 스트림을 만든다 */
input = gsf_infile_child_by_name (ole, "FileHeader");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->file_header_stream = input;
input = NULL;
parse_file_header (file);
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "DocInfo");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (input);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
file->doc_info_stream = cis;
g_object_unref (zd);
g_object_unref (gis);
input = NULL;
}
else
{
file->doc_info_stream = (GInputStream *) gsf_input_stream_new (input);
}
}
else
{
goto FAIL;
}
if (!file->is_distribute)
input = gsf_infile_child_by_name (ole, "BodyText");
else
input = gsf_infile_child_by_name (ole, "ViewText");
if (input)
{
for (gint i = 0; i < gsf_infile_num_children (GSF_INFILE (input)); i++)
{
GsfInput *section =
gsf_infile_child_by_name (GSF_INFILE (input),
g_strdup_printf("Section%d", i));
if (gsf_infile_num_children (GSF_INFILE (section)) != -1)
{
if (GSF_IS_INPUT (section))
g_object_unref (section);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
if (file->is_distribute)
{
guint8 *data = g_malloc0 (256);
gsf_input_read (section, 4, NULL);
gsf_input_read (section, 256, data);
guint32 seed = GSF_LE_GET_GUINT32 (data);
msvc_srand (seed);
gint n = 0, val = 0, offset;
for (guint i = 0; i < 256; i++)
{
if (n == 0)
{
val = msvc_rand() & 0xff;
n = (msvc_rand() & 0xf) + 1;
}
data[i] ^= val;
n--;
}
offset = 4 + (seed & 0xf);
gchar *key = g_malloc0 (16);
memcpy (key, (const gchar *) data + offset, 16);
#ifdef HWP_ENABLE_DEBUG
gchar *sha1 = g_convert ((const gchar *) data + offset, 80,
"UTF-8", "UTF-16LE", NULL, NULL, error);
printf ("sha1: %s\n", sha1);
printf ("key: %s\n", key);
g_free (sha1);
#endif
g_free (data);
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new ();
EVP_CIPHER_CTX_init (ctx);
EVP_DecryptInit_ex (ctx, EVP_aes_128_ecb(), NULL,
(unsigned char *) key, NULL);
g_free (key);
EVP_CIPHER_CTX_set_padding(ctx, 0); /* no padding */
gsf_off_t encrypted_data_len = gsf_input_remaining (section);
guint8 const *encrypted_data = gsf_input_read (section, encrypted_data_len, NULL);
guint8 *decrypted_data = g_malloc (encrypted_data_len);
int decrypted_data_len, len;
EVP_DecryptUpdate (ctx, decrypted_data, &len, encrypted_data, encrypted_data_len);
decrypted_data_len = len;
EVP_DecryptFinal_ex (ctx, decrypted_data + len, &len);
decrypted_data_len += len;
EVP_CIPHER_CTX_free (ctx);
g_object_unref (section);
section = gsf_input_memory_new (decrypted_data, decrypted_data_len, TRUE);
}
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (section);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
g_ptr_array_add (file->section_streams, cis);
g_object_unref (zd);
g_object_unref (gis);
}
else
{
GInputStream *stream = (GInputStream *) gsf_input_stream_new (section);
g_ptr_array_add (file->section_streams, stream);
}
} /* for */
g_object_unref (input);
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "\005HwpSummaryInformation");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->summary_info_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "BinData");
if (input)
{
gint n_data = gsf_infile_num_children (GSF_INFILE (input));
for (gint i = 0; i < n_data; i++)
{
GsfInput *bin_data_input =
gsf_infile_child_by_index (GSF_INFILE (input), i);
if (gsf_infile_num_children (GSF_INFILE (bin_data_input)) != -1)
{
if (GSF_IS_INPUT (bin_data_input))
g_object_unref (bin_data_input);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (bin_data_input);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
g_ptr_array_add (file->bin_data_streams, cis);
g_object_unref (zd);
g_object_unref (gis);
}
else
{
GInputStream *stream = (GInputStream *) gsf_input_stream_new (bin_data_input);
g_ptr_array_add (file->bin_data_streams, stream);
}
}
g_object_unref (input);
input = NULL;
}
input = gsf_infile_child_by_name (ole, "PrvText");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->prv_text_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "PrvImage");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->prv_image_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
return;
FAIL:
if (GSF_IS_INPUT (input))
g_object_unref (input);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
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;
}
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;
}
