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)); }