/**
* 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
g_filter_input_stream_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GFilterInputStream *filter_stream;
filter_stream = G_FILTER_INPUT_STREAM (object);
switch (prop_id)
{
case PROP_BASE_STREAM:
g_value_set_object (value, filter_stream->base_stream);
break;
case PROP_CLOSE_BASE:
g_value_set_boolean (value, GET_PRIVATE (filter_stream)->close_base);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gssize
read_internal (GInputStream *stream,
void *buffer,
gsize count,
gboolean blocking,
GCancellable *cancellable,
GError **error)
{
SoupCacheInputStream *istream = SOUP_CACHE_INPUT_STREAM (stream);
SoupCacheInputStreamPrivate *priv = istream->priv;
GInputStream *base_stream;
gssize nread;
base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (stream));
nread = g_pollable_stream_read (base_stream, buffer, count, blocking,
cancellable, error);
if (G_UNLIKELY (nread == -1 || priv->read_finished))
return nread;
if (nread == 0) {
priv->read_finished = TRUE;
if (priv->current_writing_buffer == NULL && priv->output_stream)
notify_and_clear (istream, NULL);
} else {
SoupBuffer *soup_buffer = soup_buffer_new (SOUP_MEMORY_COPY, buffer, nread);
g_queue_push_tail (priv->buffer_queue, soup_buffer);
if (priv->current_writing_buffer == NULL && priv->output_stream)
soup_cache_input_stream_write_next_buffer (istream);
}
return nread;
}
static gboolean
is_network_stream (GInputStream *stream)
{
while (G_IS_FILTER_INPUT_STREAM (stream))
stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
return !G_IS_FILE_INPUT_STREAM (stream);
}
static gboolean
soup_content_sniffer_stream_can_poll (GPollableInputStream *pollable)
{
GInputStream *base_stream = G_FILTER_INPUT_STREAM (pollable)->base_stream;
return G_IS_POLLABLE_INPUT_STREAM (base_stream) &&
g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (base_stream));
}
gssize skip (GInputStream *stream,
gsize count,
GCancellable *cancellable,
GError **error)
{
GFilterInputStream *filter_stream = G_FILTER_INPUT_STREAM (stream);
GInputStream *base_stream = filter_stream->base_stream;
return g_input_stream_skip (base_stream, count, cancellable, error);
}
static void
g_filter_input_stream_finalize (GObject *object)
{
GFilterInputStream *stream;
stream = G_FILTER_INPUT_STREAM (object);
g_object_unref (stream->base_stream);
G_OBJECT_CLASS (g_filter_input_stream_parent_class)->finalize (object);
}
static gboolean
soup_content_sniffer_stream_is_readable (GPollableInputStream *stream)
{
SoupContentSnifferStream *sniffer = SOUP_CONTENT_SNIFFER_STREAM (stream);
if (sniffer->priv->error ||
(!sniffer->priv->sniffing && sniffer->priv->buffer))
return TRUE;
return g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (G_FILTER_INPUT_STREAM (stream)->base_stream));
}
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);
}
const gchar *
checkcopy_input_stream_get_checksum (CheckcopyInputStream * stream, CheckcopyChecksumType type)
{
CheckcopyInputStreamPrivate *priv = GET_PRIVATE (stream);
GFilterInputStream *filter = G_FILTER_INPUT_STREAM (stream);
GInputStream *base = filter->base_stream;
const gchar *checksum;
if (g_input_stream_is_closed (base)) {
checksum = checksum_get_string (type, priv->checksum[type]);
} else {
checksum = NULL;
}
return checksum;
}
static gboolean
g_filter_input_stream_close_finish (GInputStream *stream,
GAsyncResult *result,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gboolean res;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
res = g_input_stream_close_finish (stream,
result,
error);
return res;
}
static gboolean
g_filter_input_stream_close (GInputStream *stream,
GCancellable *cancellable,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gboolean res;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
res = g_input_stream_close (base_stream,
cancellable,
error);
return res;
}
static gssize
g_filter_input_stream_skip_finish (GInputStream *stream,
GAsyncResult *result,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gssize nskipped;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
nskipped = g_input_stream_skip_finish (base_stream,
result,
error);
return nskipped;
}
static gssize
read_and_sniff (GInputStream *stream, gboolean blocking,
GCancellable *cancellable, GError **error)
{
SoupContentSnifferStreamPrivate *priv = SOUP_CONTENT_SNIFFER_STREAM (stream)->priv;
gssize nread;
GError *my_error = NULL;
SoupBuffer *buf;
do {
nread = g_pollable_stream_read (G_FILTER_INPUT_STREAM (stream)->base_stream,
priv->buffer + priv->buffer_nread,
priv->buffer_size - priv->buffer_nread,
blocking, cancellable, &my_error);
if (nread <= 0)
break;
priv->buffer_nread += nread;
} while (priv->buffer_nread < priv->buffer_size);
/* If we got EAGAIN or cancellation before filling the buffer,
* just return that right away. Likewise if we got any other
* error without ever reading any data. Otherwise, save the
* error to return after we're done sniffing.
*/
if (my_error) {
if (g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK) ||
g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
priv->buffer_nread == 0) {
g_propagate_error (error, my_error);
return -1;
} else
priv->error = my_error;
}
/* Sniff, then return the data */
buf = soup_buffer_new (SOUP_MEMORY_TEMPORARY, priv->buffer, priv->buffer_nread);
priv->sniffed_type =
soup_content_sniffer_sniff (priv->sniffer, priv->msg, buf,
&priv->sniffed_params);
soup_buffer_free (buf);
priv->sniffing = FALSE;
return priv->buffer_nread;
}
static gssize
read_internal (GInputStream *stream,
void *buffer,
gsize count,
gboolean blocking,
GCancellable *cancellable,
GError **error)
{
SoupContentSnifferStream *sniffer = SOUP_CONTENT_SNIFFER_STREAM (stream);
gssize nread;
if (sniffer->priv->error) {
g_propagate_error (error, sniffer->priv->error);
sniffer->priv->error = NULL;
return -1;
}
if (sniffer->priv->sniffing) {
nread = read_and_sniff (stream, blocking, cancellable, error);
if (nread <= 0)
return nread;
}
if (sniffer->priv->buffer) {
nread = MIN (count, sniffer->priv->buffer_nread);
memcpy (buffer, sniffer->priv->buffer, nread);
if (nread == sniffer->priv->buffer_nread) {
g_free (sniffer->priv->buffer);
sniffer->priv->buffer = NULL;
} else {
/* FIXME, inefficient */
memmove (sniffer->priv->buffer,
sniffer->priv->buffer + nread,
sniffer->priv->buffer_nread - nread);
sniffer->priv->buffer_nread -= nread;
}
} else {
nread = g_pollable_stream_read (G_FILTER_INPUT_STREAM (stream)->base_stream,
buffer, count, blocking,
cancellable, error);
}
return nread;
}
static gssize
g_filter_input_stream_skip (GInputStream *stream,
gsize count,
GCancellable *cancellable,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gssize nskipped;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
nskipped = g_input_stream_skip (base_stream,
count,
cancellable,
error);
return nskipped;
}
static void
g_filter_input_stream_close_async (GInputStream *stream,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
g_input_stream_close_async (base_stream,
io_priority,
cancellable,
callback,
user_data);
}
static GSource *
soup_content_sniffer_stream_create_source (GPollableInputStream *stream,
GCancellable *cancellable)
{
SoupContentSnifferStream *sniffer = SOUP_CONTENT_SNIFFER_STREAM (stream);
GSource *base_source, *pollable_source;
if (sniffer->priv->error ||
(!sniffer->priv->sniffing && sniffer->priv->buffer))
base_source = g_timeout_source_new (0);
else
base_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (G_FILTER_INPUT_STREAM (stream)->base_stream), cancellable);
g_source_set_dummy_callback (base_source);
pollable_source = g_pollable_source_new (G_OBJECT (stream));
g_source_add_child_source (pollable_source, base_source);
g_source_unref (base_source);
return pollable_source;
}
gssize read_fn (GInputStream *stream,
void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
CheckcopyInputStreamPrivate *priv = GET_PRIVATE (CHECKCOPY_INPUT_STREAM (stream));
GFilterInputStream *filter_stream = G_FILTER_INPUT_STREAM (stream);
GInputStream *base_stream = filter_stream->base_stream;
gssize nread;
int i;
nread = g_input_stream_read (base_stream, buffer, count, cancellable, error);
for (i=CHECKCOPY_NO_CHECKSUM+1; i<CHECKCOPY_ALL_CHECKSUMS; i++) {
checksum_update (i, &(priv->checksum[i]), buffer, nread);
}
return nread;
}
static gssize
g_filter_input_stream_read (GInputStream *stream,
void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gssize nread;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
nread = g_input_stream_read (base_stream,
buffer,
count,
cancellable,
error);
return nread;
}
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;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
sysroot_stdout_ready_cb (GPollableInputStream *pollable_stream,
StdoutClosure *closure)
{
glnx_unref_object RpmostreedSysroot *sysroot = NULL;
glnx_unref_object RpmostreedTransaction *transaction = NULL;
GMemoryInputStream *memory_stream;
GBufferedInputStream *buffered_stream;
char buffer[1024];
gconstpointer stream_buffer;
gsize stream_buffer_size;
gsize total_bytes_read = 0;
gboolean have_line = FALSE;
GError *local_error = NULL;
sysroot = g_weak_ref_get (&closure->sysroot);
if (sysroot != NULL)
transaction = rpmostreed_transaction_monitor_ref_active_transaction (sysroot->transaction_monitor);
/* XXX Would very much like g_buffered_input_stream_fill_nonblocking().
* Much of this function is a clumsy and inefficient attempt to
* achieve the same thing.
*
* See: https://bugzilla.gnome.org/726797
*/
buffered_stream = G_BUFFERED_INPUT_STREAM (closure->data_stream);
memory_stream = (GMemoryInputStream *) g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (buffered_stream));
while (local_error == NULL)
{
gssize n_read;
n_read = g_pollable_input_stream_read_nonblocking (pollable_stream,
buffer,
sizeof (buffer),
NULL, &local_error);
if (n_read > 0)
{
/* XXX Gotta use GBytes so the data gets copied. */
g_autoptr(GBytes) bytes = g_bytes_new (buffer, n_read);
g_memory_input_stream_add_bytes (memory_stream, bytes);
total_bytes_read += n_read;
}
}
if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
goto out;
g_clear_error (&local_error);
read_another_line:
/* Fill the buffered stream with the data we just put in the
* memory stream, then peek at the buffer to see if it's safe
* to call g_data_input_stream_read_line() without blocking.
*
* XXX Oye, there's gotta be an easier way to do this...
*/
/* This should never fail since it's just reading from memory. */
g_buffered_input_stream_fill (buffered_stream, total_bytes_read, NULL, NULL);
stream_buffer = g_buffered_input_stream_peek_buffer (buffered_stream, &stream_buffer_size);
have_line = (memchr (stream_buffer, '\n', stream_buffer_size) != NULL);
if (have_line)
{
g_autofree char *line = NULL;
gsize length;
line = g_data_input_stream_read_line (closure->data_stream,
&length, NULL, &local_error);
if (local_error != NULL)
goto out;
/* If there's an active transaction, forward the line to the
* transaction's owner through the "Message" signal. Otherwise
* dump it to the non-redirected standard output stream. */
if (transaction != NULL)
{
rpmostree_transaction_emit_message (RPMOSTREE_TRANSACTION (transaction), line);
}
else
{
/* This is essentially puts(), don't care about errors. */
g_output_stream_write_all (closure->real_stdout,
line, length, NULL, NULL, NULL);
g_output_stream_write_all (closure->real_stdout,
"\n", 1, NULL, NULL, NULL);
}
goto read_another_line;
}
out:
if (local_error != NULL)
{
g_warning ("Failed to read stdout pipe: %s", local_error->message);
g_clear_error (&local_error);
}
return G_SOURCE_CONTINUE;
}
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;
}
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;
}
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;
}
