static void uriSchemeRequestCallback(WebKitURISchemeRequest* request, gpointer userData)
{
URISchemeTest* test = static_cast<URISchemeTest*>(userData);
test->m_uriSchemeRequest = request;
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
g_assert(webkit_uri_scheme_request_get_web_view(request) == test->m_webView);
GRefPtr<GInputStream> inputStream = adoptGRef(g_memory_input_stream_new());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(inputStream.get()));
const char* scheme = webkit_uri_scheme_request_get_scheme(request);
g_assert(scheme);
g_assert(test->m_handlersMap.contains(String::fromUTF8(scheme)));
if (!g_strcmp0(scheme, "error")) {
GUniquePtr<GError> error(g_error_new_literal(g_quark_from_string(errorDomain), errorCode, errorMessage));
webkit_uri_scheme_request_finish_error(request, error.get());
return;
}
const URISchemeHandler& handler = test->m_handlersMap.get(String::fromUTF8(scheme));
if (!g_strcmp0(scheme, "echo")) {
char* replyHTML = g_strdup_printf(handler.reply.data(), webkit_uri_scheme_request_get_path(request));
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), replyHTML, strlen(replyHTML), g_free);
} else if (!g_strcmp0(scheme, "closed"))
g_input_stream_close(inputStream.get(), 0, 0);
else if (!handler.reply.isNull())
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), handler.reply.data(), handler.reply.length(), 0);
webkit_uri_scheme_request_finish(request, inputStream.get(), handler.replyLength, handler.mimeType.data());
}
static void uriSchemeRequestCallback(WebKitURISchemeRequest* request, gpointer userData)
{
URISchemeTest* test = static_cast<URISchemeTest*>(userData);
test->m_uriSchemeRequest = request;
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
g_assert(webkit_uri_scheme_request_get_web_view(request) == test->m_webView);
const char* scheme = webkit_uri_scheme_request_get_scheme(request);
g_assert(scheme);
g_assert(test->m_handlersMap.contains(String::fromUTF8(scheme)));
const URISchemeHandler& handler = test->m_handlersMap.get(String::fromUTF8(scheme));
GRefPtr<GInputStream> inputStream = adoptGRef(g_memory_input_stream_new());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(inputStream.get()));
const gchar* requestPath = webkit_uri_scheme_request_get_path(request);
if (!g_strcmp0(scheme, "error")) {
if (!g_strcmp0(requestPath, "before-response")) {
GUniquePtr<GError> error(g_error_new_literal(g_quark_from_string(errorDomain), errorCode, beforeReceiveResponseErrorMessage));
// We call finish() and then finish_error() to make sure that not even
// the didReceiveResponse message is processed at the time of failing.
webkit_uri_scheme_request_finish(request, G_INPUT_STREAM(inputStream.get()), handler.replyLength, handler.mimeType.data());
webkit_uri_scheme_request_finish_error(request, error.get());
} else if (!g_strcmp0(requestPath, "after-first-chunk")) {
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), handler.reply.data(), handler.reply.length(), 0);
webkit_uri_scheme_request_finish(request, inputStream.get(), handler.replyLength, handler.mimeType.data());
// We need to wait until we reach the load-committed state before calling webkit_uri_scheme_request_finish_error(),
// so we rely on the test using finishOnCommittedAndWaitUntilLoadFinished() to actually call it from loadCommitted().
} else {
GUniquePtr<GError> error(g_error_new_literal(g_quark_from_string(errorDomain), errorCode, genericErrorMessage));
webkit_uri_scheme_request_finish_error(request, error.get());
}
return;
}
if (!g_strcmp0(scheme, "echo")) {
char* replyHTML = g_strdup_printf(handler.reply.data(), requestPath);
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), replyHTML, strlen(replyHTML), g_free);
} else if (!g_strcmp0(scheme, "closed"))
g_input_stream_close(inputStream.get(), 0, 0);
else if (!handler.reply.isNull())
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), handler.reply.data(), handler.reply.length(), 0);
webkit_uri_scheme_request_finish(request, inputStream.get(), handler.replyLength, handler.mimeType.data());
}
static void
process_line (char *line,
gpointer data)
{
FrCommandUnarchiver *unar_comm = FR_COMMAND_UNARCHIVER (data);
g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (unar_comm->stream), line, -1, NULL);
}
static void
save_snapshot_get_message_cb (EMsgComposer *composer,
GAsyncResult *result,
GSimpleAsyncResult *simple)
{
SaveContext *context;
CamelMimeMessage *message;
GInputStream *input_stream;
CamelStream *camel_stream;
GByteArray *buffer;
GError *local_error = NULL;
context = g_simple_async_result_get_op_res_gpointer (simple);
message = e_msg_composer_get_message_draft_finish (
composer, result, &local_error);
if (local_error != NULL) {
g_warn_if_fail (message == NULL);
g_simple_async_result_take_error (simple, local_error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));
/* Decode the message to an in-memory buffer. We have to do this
* because CamelStreams are synchronous-only, and using threads is
* dangerous because CamelDataWrapper is not reentrant. */
buffer = g_byte_array_new ();
camel_stream = camel_stream_mem_new ();
camel_stream_mem_set_byte_array (
CAMEL_STREAM_MEM (camel_stream), buffer);
camel_data_wrapper_decode_to_stream_sync (
CAMEL_DATA_WRAPPER (message), camel_stream, NULL, NULL);
g_object_unref (camel_stream);
g_object_unref (message);
/* Load the buffer into a GMemoryInputStream. */
input_stream = g_memory_input_stream_new ();
if (buffer->len > 0)
g_memory_input_stream_add_data (
G_MEMORY_INPUT_STREAM (input_stream),
buffer->data, (gssize) buffer->len,
(GDestroyNotify) g_free);
g_byte_array_free (buffer, FALSE);
/* Splice the input and output streams. */
g_output_stream_splice_async (
context->output_stream, input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, context->cancellable,
(GAsyncReadyCallback) save_snapshot_splice_cb,
simple);
g_object_unref (input_stream);
}
static GInputStream *
soup_request_data_send (SoupRequest *request,
GCancellable *cancellable,
GError **error)
{
SoupRequestData *data = SOUP_REQUEST_DATA (request);
SoupURI *uri = soup_request_get_uri (request);
GInputStream *memstream;
const char *comma, *start, *end;
gboolean base64 = FALSE;
char *uristr;
uristr = soup_uri_to_string (uri, FALSE);
start = uristr + 5;
comma = strchr (start, ',');
if (comma && comma != start) {
/* Deal with MIME type / params */
if (comma >= start + BASE64_INDICATOR_LEN && !g_ascii_strncasecmp (comma - BASE64_INDICATOR_LEN, BASE64_INDICATOR, BASE64_INDICATOR_LEN)) {
end = comma - BASE64_INDICATOR_LEN;
base64 = TRUE;
} else
end = comma;
if (end != start)
data->priv->content_type = soup_uri_decoded_copy (start, end - start, NULL);
}
memstream = g_memory_input_stream_new ();
if (comma)
start = comma + 1;
if (*start) {
int decoded_length = 0;
guchar *buf = (guchar *) soup_uri_decoded_copy (start, strlen (start),
&decoded_length);
if (base64)
buf = g_base64_decode_inplace ((gchar*) buf, &data->priv->content_length);
else
data->priv->content_length = decoded_length;
g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (memstream),
buf, data->priv->content_length,
g_free);
}
g_free (uristr);
return memstream;
}
static void ekg_gnutls_async_handshake(struct ekg_gnutls_connection_starter *gcs) {
gint ret = gnutls_handshake(gcs->conn->session);
switch (ret) {
case GNUTLS_E_SUCCESS:
{
struct ekg_gnutls_connection *gc = gcs->conn;
struct ekg_connection_starter *cs = gcs->parent;
GInputStream *mi = g_memory_input_stream_new();
GOutputStream *mo = g_memory_output_stream_new(
NULL, 0, g_realloc, g_free);
/* set streams */
gc->instream = G_MEMORY_INPUT_STREAM(mi);
gc->outstream = G_MEMORY_OUTPUT_STREAM(mo);
/* switch handlers */
gc->connection->callback = ekg_gnutls_handle_data;
gc->connection->failure_callback = ekg_gnutls_handle_data_failure;
gc->connection->priv_data = gc;
gc->connection->flush_handler = ekg_gnutls_flush;
/* this cleans up the socket, and cs */
succeeded_async_connect(gcs->sockclient, gc->connection->conn,
cs, mi, mo);
/* and this cleans up gcs */
ekg_gnutls_free_connection_starter(gcs);
}
break;
case GNUTLS_E_AGAIN:
case GNUTLS_E_INTERRUPTED:
break;
default:
{
GError *err = g_error_new_literal(EKG_GNUTLS_ERROR,
ret, gnutls_strerror(ret));
ekg_gnutls_handle_handshake_failure(NULL, err, gcs);
g_error_free(err);
}
}
}
GDataInputStream *
http_data_input_stream(GInputStream * stream,gsize * length,GCancellable * cancellable,GError ** error)
{
GMemoryOutputStream
* out = G_MEMORY_OUTPUT_STREAM(g_memory_output_stream_new_resizable());
gchar * content = NULL;
guint8 byte = 0;
while(g_input_stream_read(stream,&byte,1,cancellable,error))
{
if(g_memory_output_stream_get_data_size(out) > 2048)
{
g_output_stream_close(G_OUTPUT_STREAM(out),NULL,NULL);
g_free(g_memory_output_stream_steal_data(out));
g_object_unref(out);
return NULL;
}
g_output_stream_write_all(G_OUTPUT_STREAM(out),&byte,1,NULL,NULL,NULL);
if(g_memory_output_stream_get_data_size(out) >= 4)
{
content = g_memory_output_stream_get_data(out);
if(strncmp((content + g_memory_output_stream_get_data_size(out) - 4),"\r\n\r\n",4) == 0)
break;
}
}
g_output_stream_close(G_OUTPUT_STREAM(out),NULL,NULL);
GMemoryInputStream
* result = G_MEMORY_INPUT_STREAM(g_memory_input_stream_new_from_data(
g_memory_output_stream_steal_data(out),
g_memory_output_stream_get_data_size(out),
g_free
));
g_object_unref(out);
GDataInputStream
* dis = g_data_input_stream_new(G_INPUT_STREAM(result));
g_data_input_stream_set_newline_type(dis,G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
return dis;
}
static GdkPixbuf*
load_pixbuf_from_archive(const char* archive, const char* file)
{
if (archive == NULL || file == NULL) {
return NULL;
}
struct archive* a = archive_read_new();
if (a == NULL) {
return NULL;
}
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
int r = archive_read_open_filename(a, archive, LIBARCHIVE_BUFFER_SIZE);
if (r != ARCHIVE_OK) {
return NULL;
}
struct archive_entry* entry = NULL;
while ((r = archive_read_next_header(a, &entry)) != ARCHIVE_EOF) {
if (r < ARCHIVE_WARN) {
archive_read_close(a);
archive_read_free(a);
return NULL;
}
const char* path = archive_entry_pathname(entry);
if (compare_path(path, file) != 0) {
continue;
}
GInputStream* is = g_memory_input_stream_new();
if (is == NULL) {
archive_read_close(a);
archive_read_free(a);
return NULL;
}
GMemoryInputStream* mis = G_MEMORY_INPUT_STREAM(is);
size_t size = 0;
const void* buf = NULL;
off_t offset = 0;
while ((r = archive_read_data_block(a, &buf, &size, &offset)) != ARCHIVE_EOF) {
if (r < ARCHIVE_WARN) {
archive_read_close(a);
archive_read_free(a);
g_object_unref(mis);
return NULL;
}
if (size == 0) {
continue;
}
void* tmp = g_malloc0(size);
if (tmp == NULL) {
archive_read_close(a);
archive_read_free(a);
g_object_unref(mis);
return NULL;
}
memcpy(tmp, buf, size);
g_memory_input_stream_add_data(mis, tmp, size, g_free);
}
GdkPixbuf* pixbuf = gdk_pixbuf_new_from_stream(is, NULL, NULL);
if (pixbuf == NULL) {
archive_read_close(a);
archive_read_free(a);
g_object_unref(mis);
return NULL;
}
archive_read_close(a);
archive_read_free(a);
g_object_unref(mis);
return pixbuf;
}
archive_read_close(a);
archive_read_free(a);
return NULL;
}
static GInputStream *
soup_request_data_send (SoupRequest *request,
GCancellable *cancellable,
GError **error)
{
SoupRequestData *data = SOUP_REQUEST_DATA (request);
SoupURI *uri = soup_request_get_uri (request);
GInputStream *memstream;
const char *comma, *start, *end;
gboolean base64 = FALSE;
char *uristr;
uristr = soup_uri_to_string (uri, FALSE);
start = uristr + 5;
comma = strchr (start, ',');
if (comma && comma != start) {
/* Deal with MIME type / params */
if (comma > start + BASE64_INDICATOR_LEN && !g_ascii_strncasecmp (comma - BASE64_INDICATOR_LEN, BASE64_INDICATOR, BASE64_INDICATOR_LEN)) {
end = comma - BASE64_INDICATOR_LEN;
base64 = TRUE;
} else
end = comma;
if (end != start) {
char *encoded_content_type = g_strndup (start, end - start);
if (base64)
data->priv->content_type = encoded_content_type;
else {
data->priv->content_type = soup_uri_decode (encoded_content_type);
g_free (encoded_content_type);
}
}
}
memstream = g_memory_input_stream_new ();
if (comma)
start = comma + 1;
if (*start) {
guchar *buf;
if (base64) {
int inlen, state = 0;
guint save = 0;
inlen = strlen (start);
buf = g_malloc0 (inlen * 3 / 4 + 3);
data->priv->content_length =
g_base64_decode_step (start, inlen, buf,
&state, &save);
if (state != 0) {
g_free (buf);
goto fail;
}
} else {
buf = (guchar *) soup_uri_decode (start);
data->priv->content_length = strlen ((const char *) buf);
}
g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (memstream),
buf, data->priv->content_length,
g_free);
}
g_free (uristr);
return memstream;
fail:
g_free (uristr);
g_set_error (error, SOUP_REQUESTER_ERROR, SOUP_REQUESTER_ERROR_BAD_URI,
_("Unable to decode URI: %s"), start);
g_object_unref (memstream);
return NULL;
}
static gboolean
log_load (GIOSchedulerJob *io_job,
GCancellable *cancellable,
gpointer user_data)
{
/* this runs in a separate i/o thread */
LoadJob *job = user_data;
LogviewLog *log = job->log;
GFile *f = log->priv->file;
GFileInfo *info;
GInputStream *is;
const char *peeked_buffer;
const char * parse_data[2];
GSList *days;
const char *content_type;
GFileType type;
GError *err = NULL;
GTimeVal timeval;
gboolean is_archive, can_read;
info = g_file_query_info (f,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED ",",
0, NULL, &err);
if (err) {
if (err->code == G_IO_ERROR_PERMISSION_DENIED) {
/* TODO: PolicyKit integration */
}
goto out;
}
can_read = g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
if (!can_read) {
/* TODO: PolicyKit integration */
err = g_error_new_literal (LOGVIEW_ERROR_QUARK, LOGVIEW_ERROR_PERMISSION_DENIED,
_("You don't have enough permissions to read the file."));
g_object_unref (info);
goto out;
}
type = g_file_info_get_file_type (info);
content_type = g_file_info_get_content_type (info);
is_archive = g_content_type_equals (content_type, "application/x-gzip");
if (type != (G_FILE_TYPE_REGULAR || G_FILE_TYPE_SYMBOLIC_LINK) ||
(!g_content_type_is_a (content_type, "text/plain") && !is_archive))
{
err = g_error_new_literal (LOGVIEW_ERROR_QUARK, LOGVIEW_ERROR_NOT_A_LOG,
_("The file is not a regular file or is not a text file."));
g_object_unref (info);
goto out;
}
log->priv->file_size = g_file_info_get_size (info);
g_file_info_get_modification_time (info, &timeval);
log->priv->file_time = timeval.tv_sec;
log->priv->display_name = g_strdup (g_file_info_get_display_name (info));
g_object_unref (info);
/* initialize the stream */
is = G_INPUT_STREAM (g_file_read (f, NULL, &err));
if (err) {
if (err->code == G_IO_ERROR_PERMISSION_DENIED) {
/* TODO: PolicyKit integration */
}
goto out;
}
if (is_archive) {
#ifdef HAVE_ZLIB
GZHandle *gz;
gboolean res;
guchar * buffer;
gsize bytes_read;
GInputStream *real_is;
time_t mtime; /* seconds */
/* this also skips the header from |is| */
res = read_gzip_header (is, &mtime);
if (!res) {
g_object_unref (is);
err = create_zlib_error ();
goto out;
}
log->priv->file_time = mtime;
gz = gz_handle_new (f, is);
res = gz_handle_init (gz);
if (!res) {
g_object_unref (is);
gz_handle_free (gz);
err = create_zlib_error ();
goto out;
}
real_is = g_memory_input_stream_new ();
do {
buffer = g_malloc (1024);
res = gz_handle_read (gz, buffer, 1024, &bytes_read);
g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (real_is),
buffer, bytes_read, g_free);
} while (res == TRUE && bytes_read > 0);
if (!res) {
gz_handle_free (gz);
g_object_unref (real_is);
g_object_unref (is);
err = create_zlib_error ();
goto out;
}
g_object_unref (is);
is = real_is;
gz_handle_free (gz);
#else /* HAVE_ZLIB */
g_object_unref (is);
err = g_error_new_literal (LOGVIEW_ERROR_QUARK, LOGVIEW_ERROR_NOT_SUPPORTED,
_("This version of System Log does not support GZipped logs."));
goto out;
#endif /* HAVE_ZLIB */
}
log->priv->stream = g_data_input_stream_new (is);
/* sniff into the stream for a timestamped line */
g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (log->priv->stream),
(gssize) g_buffered_input_stream_get_buffer_size (G_BUFFERED_INPUT_STREAM (log->priv->stream)),
NULL, &err);
if (err == NULL) {
peeked_buffer = g_buffered_input_stream_peek_buffer
(G_BUFFERED_INPUT_STREAM (log->priv->stream), NULL);
parse_data[0] = peeked_buffer;
parse_data[1] = NULL;
if ((days = log_read_dates (parse_data, time (NULL))) != NULL) {
log->priv->has_days = TRUE;
g_slist_foreach (days, (GFunc) logview_utils_day_free, NULL);
g_slist_free (days);
} else {
log->priv->has_days = FALSE;
}
} else {
log->priv->has_days = FALSE;
g_clear_error (&err);
}
g_object_unref (is);
out:
if (err) {
job->err = err;
}
g_io_scheduler_job_send_to_mainloop_async (io_job,
log_load_done,
job, NULL);
return FALSE;
}
/**
* seahorse_util_memory_input_string:
* @string: The string to create the stream from
* @length: The length of this string
*
* Returns: The new input stream of type #GMemoryInputStream
*/
GMemoryInputStream*
seahorse_util_memory_input_string (const gchar *string, gsize length)
{
g_return_val_if_fail (string, NULL);
return G_MEMORY_INPUT_STREAM (g_memory_input_stream_new_from_data (g_strndup (string, length), length, g_free));
}
