/* Read one uncompressed scanline row. Updates cursor on success. */ static gboolean rgbe_read_uncompressed (const rgbe_file *file, goffset *cursor, gfloat *pixels) { const guint8 *data; guint i; g_return_val_if_fail (file, FALSE); g_return_val_if_fail (file->file, FALSE); g_return_val_if_fail (cursor && *cursor > 0, FALSE); g_return_val_if_fail (pixels, FALSE); data = (guint8 *)g_mapped_file_get_contents (file->file) + *cursor; for (i = 0; i < file->header.x_axis.size; ++i) { rgbe_rgbe_to_float (file, data, pixels); data += RGBE_NUM_RGBE; pixels += RGBE_NUM_RGBE; } *cursor = GPOINTER_TO_UINT (data) - GPOINTER_TO_UINT (g_mapped_file_get_contents (file->file)); return TRUE; }
/* Parse the orientation/resolution line. The following format is repeated * twice: "[+-][XY] \d+" It specifies column or row major ordering, and the * direction of pixel indices (eg, mirrored). * * Updates cursor on success. */ static gboolean rgbe_header_read_orientation (rgbe_file *file, goffset *cursor) { const gchar *data; rgbe_orientation orient; rgbe_axis *axis; gchar firstaxis = '?'; gboolean success = FALSE; g_return_val_if_fail (file, FALSE); g_return_val_if_fail (file->file, FALSE); g_return_val_if_fail (cursor && *cursor > 0, FALSE); data = g_mapped_file_get_contents (file->file) + *cursor; /* Read each direction, axis, and size until a newline is reached */ do { orient = rgbe_char_to_orientation (*data++); if (orient == ORIENT_UNKNOWN) goto cleanup; /* Axis can be ordered with X major, which we don't currently handle */ if (firstaxis == '?' && *data != 'Y' && *data != 'y') goto cleanup; else firstaxis = *data; axis = rgbe_char_to_axis (file, *data++); if (!axis) goto cleanup; axis->orient = orient; if (*data++ != ' ') goto cleanup; errno = 0; axis->size = g_ascii_strtoull (data, (gchar **)&data, 0); if (errno) goto cleanup; /* The termination check is simplified to a space check, as each set of * axis parameters are space separated. We double check for a newline next * though. */ } while (*data++ == ' '); if (data[-1] != '\n') goto cleanup; *cursor = data - g_mapped_file_get_contents (file->file); success = TRUE; cleanup: return success; }
/** * rgbe_mapped_file_remaining: * @f: the file to read the image data from * @data: the current file read cursor * * Calculates the number of bytes remaining to be read in a mapped file. **/ static guint rgbe_mapped_file_remaining (GMappedFile *f, const void *data) { g_return_val_if_fail (f, 0); g_return_val_if_fail (GPOINTER_TO_UINT (data) > GPOINTER_TO_UINT (g_mapped_file_get_contents (f)), 0); return GPOINTER_TO_UINT (data) - GPOINTER_TO_UINT (g_mapped_file_get_contents (f)) - g_mapped_file_get_length (f); }
/* Peek on each scanline row to dispatch to decoders. * * - Assumes row major ordering. * - Assumes cursor is at the start of a scanline * - Updates cursor, which is undefined on error. */ gfloat * rgbe_read_scanlines (rgbe_file *file) { guint i; gboolean success = FALSE; gfloat *pixels = NULL, *pixel_cursor; goffset offset; g_return_val_if_fail (file, NULL); g_return_val_if_fail (file->scanlines, NULL); pixels = pixel_cursor = g_new (gfloat, file->header.x_axis.size * file->header.y_axis.size * RGBE_NUM_RGBE); offset = GPOINTER_TO_UINT (file->scanlines) - GPOINTER_TO_UINT (g_mapped_file_get_contents (file->file)); for (i = 0; i < file->header.y_axis.size; ++i) { const gchar *data = g_mapped_file_get_contents (file->file); if (data[offset + OFFSET_R] == 1 && data[offset + OFFSET_G] == 1 && data[offset + OFFSET_B] == 1) success = rgbe_read_old_rle (file, &offset, pixel_cursor); else if (data[offset + OFFSET_R] == 2 && data[offset + OFFSET_G] == 2) success = rgbe_read_new_rle (file, &offset, pixel_cursor); else success = rgbe_read_uncompressed (file, &offset, pixel_cursor); if (!success) { g_warning ("Unable to parse rgbe scanlines, fail at row %u\n", i); goto cleanup; } pixel_cursor += file->header.x_axis.size * RGBE_NUM_RGBE; } success = TRUE; cleanup: if (!success) { g_free (pixels); pixels = NULL; } return pixels; }
static gboolean CompareFile(const gchar *fname1, // IN const gchar *fname2, // IN gboolean *same) // OUT { gsize num; gboolean ret = FALSE; GMappedFile *m1; GMappedFile *m2 = NULL; GError *error = NULL; m1 = g_mapped_file_new(fname1, FALSE, &error); if (m1 == NULL) { Error("Unable to map %s: %s.\n", fname1, error->message); goto exit; } m2 = g_mapped_file_new(fname2, FALSE, &error); if (m2 == NULL) { Error("Unable to map %s: %s.\n", fname2, error->message); goto exit; } ret = TRUE; *same = FALSE; num = g_mapped_file_get_length(m1); if (g_mapped_file_get_length(m2) == num) { if (num) { if (memcmp(g_mapped_file_get_contents(m1), g_mapped_file_get_contents(m2), num) == 0) { *same = TRUE; } } else { /* Two empty files */ *same = TRUE; } } exit: g_clear_error(&error); if (m1) { g_mapped_file_unref(m1); } if (m2) { g_mapped_file_unref(m2); } return ret; }
/** * Unzip a file - replacing the file with the unzipped contents of the self */ static void uncompress_zip ( gchar *name ) { GError *error = NULL; GMappedFile *mf; if ((mf = g_mapped_file_new ( name, FALSE, &error )) == NULL) { g_critical(_("Couldn't map file %s: %s"), name, error->message); g_error_free(error); return; } gchar *file_contents = g_mapped_file_get_contents ( mf ); void *unzip_mem = NULL; gulong ucsize; if ((unzip_mem = unzip_file (file_contents, &ucsize)) == NULL) { g_mapped_file_unref ( mf ); return; } // This overwrites any previous file contents if ( ! g_file_set_contents ( name, unzip_mem, ucsize, &error ) ) { g_critical ( "Couldn't write file '%s', because of %s", name, error->message ); g_error_free ( error ); } }
/** * ot_util_variant_map: * @src: a #GFile * @type: Use this for variant * @trusted: See documentation of g_variant_new_from_data() * @out_variant: (out): Return location for new variant * @error: * * Memory-map @src, and store a new #GVariant referring to this memory * in @out_variant. Note the returned @out_variant is not floating. */ gboolean ot_util_variant_map (GFile *src, const GVariantType *type, gboolean trusted, GVariant **out_variant, GError **error) { gboolean ret = FALSE; gs_unref_variant GVariant *ret_variant = NULL; GMappedFile *mfile = NULL; mfile = gs_file_map_noatime (src, NULL, error); if (!mfile) goto out; ret_variant = g_variant_new_from_data (type, g_mapped_file_get_contents (mfile), g_mapped_file_get_length (mfile), trusted, (GDestroyNotify) g_mapped_file_unref, mfile); mfile = NULL; g_variant_ref_sink (ret_variant); ret = TRUE; ot_transfer_out_value(out_variant, &ret_variant); out: if (mfile) g_mapped_file_unref (mfile); return ret; }
/*********************************************** * PUBLIC **********************************************/ WqqQQChat *wqq_qqchat_new(const gchar * base, const gchar * css_file) { WqqQQChat *chat = (WqqQQChat *) g_object_new(WQQ_TYPE_QQCHAT, NULL); GtkWidget *webview = chat->webview; GMappedFile *file = g_mapped_file_new(css_file, FALSE, NULL); if (file != NULL) { gchar *CSS = g_mapped_file_get_contents(file); gchar *tmp = g_base64_encode((guchar *) CSS, strlen((gchar *) CSS)); gchar *css = g_strconcat("data:text/css;charset=utf-8;base64,", tmp, NULL); g_object_set(webkit_web_view_get_settings (WEBKIT_WEB_VIEW(webview)), "user-stylesheet-uri", css, NULL); g_free(css); g_free(tmp); g_mapped_file_unref(file); } webkit_web_view_load_string(WEBKIT_WEB_VIEW(webview), "<html><body></body></html>", "text/html", "UTF-8", base); chat->loading = TRUE; g_signal_connect(G_OBJECT(chat->webview), "size-allocate", G_CALLBACK(_on_auto_scroll), chat); g_signal_connect(G_OBJECT(chat->webview), "context-menu", G_CALLBACK(_block_context_menu), NULL); g_signal_connect(G_OBJECT(chat->webview), "load-finished", G_CALLBACK(on_webview_load_finished), chat); return chat; }
trg_torrent_file *trg_parse_torrent_file(const gchar * filename) { GError *error = NULL; trg_torrent_file *ret = NULL; GMappedFile *mf; if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { g_message("%s does not exist", filename); return NULL; } mf = g_mapped_file_new(filename, FALSE, &error); if (error) { g_error("%s", error->message); g_error_free(error); g_mapped_file_unref(mf); return NULL; } else { ret = trg_parse_torrent_data(g_mapped_file_get_contents(mf), g_mapped_file_get_length(mf)); } g_mapped_file_unref(mf); return ret; }
int main (int argc, char **argv) { GMappedFile *f; gchar *xml_data; gsize xml_len; f = g_mapped_file_new (ISO_639_XML_PATH, FALSE, NULL); if (f != NULL) { xml_data = (gchar *) g_mapped_file_get_contents (f); xml_len = g_mapped_file_get_length (f); } else { GError *err = NULL; if (!g_file_get_contents (ISO_639_XML_PATH, &xml_data, &xml_len, &err)) g_error ("Could not read %s: %s", ISO_639_XML_PATH, err->message); } languages = g_array_new (FALSE, TRUE, sizeof (IsoLang)); parse_iso_639_xml (xml_data, xml_len); g_array_sort (languages, (GCompareFunc) languages_sort_func); dump_languages (); g_array_free (languages, TRUE); if (f != NULL) g_mapped_file_unref (f); else g_free (xml_data); return 0; }
static int test_run_one( const MMSConfig* config, const TestDesc* desc) { Test test; if (test_init(&test, config, desc)) { GError* error = NULL; GBytes* push = g_bytes_new_static( g_mapped_file_get_contents(test.notification_ind), g_mapped_file_get_length(test.notification_ind)); if (mms_dispatcher_handle_push(test.disp, "TestConnection", push, &error)) { if (mms_dispatcher_start(test.disp)) { test.ret = RET_OK; g_main_loop_run(test.loop); } else { MMS_INFO("%s FAILED", desc->name); } } else { MMS_ERR("%s", MMS_ERRMSG(error)); MMS_INFO("%s FAILED", desc->name); g_error_free(error); } g_bytes_unref(push); test_finalize(&test); return test.ret; } else { return RET_ERR; } }
static void iso_codes_parse (const GMarkupParser *parser, const gchar *basename, GHashTable *hash_table) { GMappedFile *mapped_file; gchar *filename; GError *error = NULL; filename = g_build_filename (ISO_CODES_PREFIX, "share", "xml", "iso-codes", basename, NULL); mapped_file = g_mapped_file_new (filename, FALSE, &error); g_free (filename); if (mapped_file != NULL) { GMarkupParseContext *context; const gchar *contents; gsize length; context = g_markup_parse_context_new (parser, 0, hash_table, NULL); contents = g_mapped_file_get_contents (mapped_file); length = g_mapped_file_get_length (mapped_file); g_markup_parse_context_parse (context, contents, length, &error); g_markup_parse_context_free (context); g_mapped_file_unref (mapped_file); } if (error != NULL) { g_warning ("%s: %s", basename, error->message); g_error_free (error); } }
/** * gimp_scanner_new_file: * @filename: * @error: * * Return value: * * Since: GIMP 2.4 **/ GScanner * gimp_scanner_new_file (const gchar *filename, GError **error) { GScanner *scanner; GMappedFile *file; g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); file = g_mapped_file_new (filename, FALSE, error); if (! file) { if (error) { (*error)->domain = GIMP_CONFIG_ERROR; (*error)->code = ((*error)->code == G_FILE_ERROR_NOENT ? GIMP_CONFIG_ERROR_OPEN_ENOENT : GIMP_CONFIG_ERROR_OPEN); } return NULL; } /* gimp_scanner_new() takes a "name" for the scanner, not a filename */ scanner = gimp_scanner_new (gimp_filename_to_utf8 (filename), file, error); g_scanner_input_text (scanner, g_mapped_file_get_contents (file), g_mapped_file_get_length (file)); return scanner; }
static int child_main (int argc, char *argv[]) { GMappedFile *map; GMainLoop *loop; parent_pid = atoi (argv[2]); map = map_or_die (filename, FALSE); #ifndef G_OS_WIN32 signal (SIGUSR1, handle_usr1); #endif loop = g_main_loop_new (NULL, FALSE); g_idle_add (check_stop, loop); g_idle_add (signal_parent, NULL); g_main_loop_run (loop); g_message ("test_child_private: received parent signal"); write_or_die (childname, g_mapped_file_get_contents (map), g_mapped_file_get_length (map)); signal_parent (NULL); return 0; }
static void server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *client, gpointer user_data) { RemoteDisplayHost *host = user_data; RemoteDisplayHostPrivate *priv = GET_PRIVATE (host); RemoteDisplayHostFile *file; if (!client_allowed (host, client)) { g_debug ("Client %s not allowed", soup_client_context_get_host (client)); soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN); return; } if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_HEAD) { g_debug ("Method is not GET or HEAD"); soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED); return; } if (path == NULL || *path != '/') { g_debug ("Invalid path '%s'requested", path); soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND); return; } file = g_hash_table_lookup (priv->files, path + 1); if (!file) { soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND); return; } if (!file->mapped_file) { file->mapped_file = g_mapped_file_new (file->path, FALSE, NULL); if (!file->mapped_file) { soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND); return; } } if (msg->method == SOUP_METHOD_GET) { soup_message_set_response (msg, file->mime_type, SOUP_MEMORY_STATIC, g_mapped_file_get_contents (file->mapped_file), g_mapped_file_get_length (file->mapped_file)); } else { soup_message_headers_set_content_type (msg->response_headers, file->mime_type, NULL); soup_message_headers_set_content_length (msg->response_headers, g_mapped_file_get_length (file->mapped_file)); } soup_message_set_status(msg, SOUP_STATUS_OK); }
GimpColorProfile gimp_lcms_profile_open_from_file (const gchar *filename, GError **error) { GimpColorProfile profile; GMappedFile *file; const guint8 *data; gsize length; g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); file = g_mapped_file_new (filename, FALSE, error); if (! file) return NULL; data = (const guint8 *) g_mapped_file_get_contents (file); length = g_mapped_file_get_length (file); profile = cmsOpenProfileFromMem (data, length); if (! profile) g_set_error (error, gimp_lcms_error_quark (), 0, _("'%s' does not appear to be an ICC color profile"), gimp_filename_to_utf8 (filename)); g_mapped_file_unref (file); return profile; }
static void test_private (void) { GError *error = NULL; GMappedFile *map; gchar *buffer; gsize len; write_or_die (filename, "ABC", -1); map = map_or_die (filename, TRUE); buffer = (gchar *)g_mapped_file_get_contents (map); buffer[0] = '1'; buffer[1] = '2'; buffer[2] = '3'; g_mapped_file_free (map); if (!g_file_get_contents (filename, &buffer, &len, &error)) { g_print ("failed to read '%s': %s\n", displayname, error->message); exit (1); } g_assert (len == 3); g_assert (strcmp (buffer, "ABC") == 0); g_free (buffer); g_message ("test_private: ok"); }
static void test_child_private (gchar *argv0) { GError *error = NULL; GMappedFile *map; gchar *buffer; gsize len; gchar *child_argv[3]; GPid child_pid; #ifdef G_OS_WIN32 g_remove ("STOP"); g_assert (!g_file_test ("STOP", G_FILE_TEST_EXISTS)); #endif write_or_die (filename, "ABC", -1); map = map_or_die (filename, TRUE); child_argv[0] = argv0; child_argv[1] = "mapchild"; child_argv[2] = NULL; if (!g_spawn_async (dir, child_argv, NULL, 0, NULL, NULL, &child_pid, &error)) { g_print ("failed to spawn child: %s\n", error->message); exit (1); } /* give the child some time to set up its mapping */ g_usleep (2000000); buffer = (gchar *)g_mapped_file_get_contents (map); buffer[0] = '1'; buffer[1] = '2'; buffer[2] = '3'; g_mapped_file_free (map); #ifndef G_OS_WIN32 kill (child_pid, SIGUSR1); #else g_file_set_contents ("STOP", "Hey there\n", -1, NULL); #endif /* give the child some time to write the file */ g_usleep (2000000); if (!g_file_get_contents (childname, &buffer, &len, &error)) { gchar *name; name = g_filename_display_name (childname); g_print ("failed to read '%s': %s\n", name, error->message); exit (1); } g_assert (len == 3); g_assert (strcmp (buffer, "ABC") == 0); g_free (buffer); }
static GList * log_store_empathy_search_new (EmpathyLogStore *self, const gchar *text) { GList *files, *l; GList *hits = NULL; gchar *text_casefold; g_return_val_if_fail (EMPATHY_IS_LOG_STORE (self), NULL); g_return_val_if_fail (!EMP_STR_EMPTY (text), NULL); text_casefold = g_utf8_casefold (text, -1); files = log_store_empathy_get_all_files (self, NULL); DEBUG ("Found %d log files in total", g_list_length (files)); for (l = files; l; l = g_list_next (l)) { gchar *filename; GMappedFile *file; gsize length; gchar *contents; gchar *contents_casefold; filename = l->data; file = g_mapped_file_new (filename, FALSE, NULL); if (!file) continue; length = g_mapped_file_get_length (file); contents = g_mapped_file_get_contents (file); contents_casefold = g_utf8_casefold (contents, length); g_mapped_file_unref (file); if (strstr (contents_casefold, text_casefold)) { EmpathyLogSearchHit *hit; hit = log_store_empathy_search_hit_new (self, filename); if (hit) { hits = g_list_prepend (hits, hit); DEBUG ("Found text:'%s' in file:'%s' on date:'%s'", text, hit->filename, hit->date); } } g_free (contents_casefold); g_free (filename); } g_list_free (files); g_free (text_casefold); return hits; }
static gboolean DisplayServerCert(const gchar *serverCertPemFile) // IN { gboolean ret = FALSE; gchar *cert = NULL; FILE *file = NULL; GMappedFile *fmap = NULL; if (!ValidateEnvironment(FALSE)) { goto exit; } cert = g_build_filename(guestProxyServerDir, "cert.pem", NULL); if (!g_file_test(cert, G_FILE_TEST_IS_REGULAR)) { Error("Couldn't find the server certificate file: %s.\n", cert); goto exit; } if (serverCertPemFile && strlen(serverCertPemFile)) { printf("Copying the server certificate to %s.\n", serverCertPemFile); if (!CertUtil_CopyFile(cert, serverCertPemFile)) { Error("Failed to copy the certificate file to the file.\n"); goto exit; } printf("Successfully copied the server certificate.\n"); } else { fmap = g_mapped_file_new(cert, FALSE, NULL); if (fmap) { const gchar *content = g_mapped_file_get_contents(fmap); gsize length = g_mapped_file_get_length(fmap); if (fwrite(content, 1, length, stdout) < length) { Error("Failed to display %s: %s.\n", cert, strerror(errno)); goto exit; } } else { Error("Couldn't open the server certificate file.\n"); goto exit; } } ret = TRUE; exit: g_free(cert); if (file) { fclose(file); } if (fmap) { g_mapped_file_unref(fmap); } return ret; }
static void prv_soup_server_cb(SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *client, gpointer user_data) { rsu_host_file_t *hf; rsu_host_server_t *hs = user_data; const gchar *file_name; SoupMessageHeaders *hdrs; if (msg->method != SOUP_METHOD_GET) { soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED); goto on_error; } hf = prv_host_server_find_file(hs, path, &file_name); if (!hf) { soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND); goto on_error; } if (hf->mapped_file) { g_mapped_file_ref(hf->mapped_file); ++hf->mapped_count; } else { hf->mapped_file = g_mapped_file_new(file_name, FALSE, NULL); if (!hf->mapped_file) { soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND); goto on_error; } hf->mapped_count = 1; } g_signal_connect(msg, "finished", G_CALLBACK(prv_soup_message_finished_cb), hf); g_object_get(msg, "response-headers", &hdrs, NULL); /* TODO: Need to add the relevant DLNA headers */ /* soup_message_headers_append(hdrs, "contentFeatures.dlna.org", "DLNA.ORG_PN=PNG_LRG;DLNA.ORG_OP=01;"DLNA.ORG_FLAGS=00f00000000000000000000000000000"); soup_message_headers_append(hdrs, "Connection", "close"); */ soup_message_set_status(msg, SOUP_STATUS_OK); soup_message_set_response(msg, hf->mime_type, SOUP_MEMORY_STATIC, g_mapped_file_get_contents(hf->mapped_file), g_mapped_file_get_length(hf->mapped_file)); on_error: return; }
/** * flickr_proxy_new_upload_for_file: * @proxy: a valid #FlickrProxy * @filename: the file to upload * @error: #GError to set on error * Create a new #RestProxyCall that can be used for uploading. @filename will * be set as the "photo" parameter for you, avoiding you from having to open the * file and determine the MIME type. * * Note that this function can in theory block. * * See http://www.flickr.com/services/api/upload.api.html for details on * uploading to Flickr. */ RestProxyCall * flickr_proxy_new_upload_for_file (FlickrProxy *proxy, const char *filename, GError **error) { GMappedFile *map; GError *err = NULL; char *basename = NULL, *content_type = NULL; RestParam *param; RestProxyCall *call = NULL; g_return_val_if_fail (FLICKR_IS_PROXY (proxy), NULL); g_return_val_if_fail (filename, NULL); /* Open the file */ map = g_mapped_file_new (filename, FALSE, &err); if (err) { g_propagate_error (error, err); return NULL; } /* Get the file information */ basename = g_path_get_basename (filename); content_type = g_content_type_guess (filename, (const guchar*) g_mapped_file_get_contents (map), g_mapped_file_get_length (map), NULL); /* Make the call */ call = flickr_proxy_new_upload (proxy); param = rest_param_new_with_owner ("photo", g_mapped_file_get_contents (map), g_mapped_file_get_length (map), content_type, basename, map, (GDestroyNotify)g_mapped_file_unref); rest_proxy_call_add_param_full (call, param); g_free (basename); g_free (content_type); return call; }
struct kml * kml_parse(const gchar *file, GError **er) { GMarkupParseContext *ctx; GMarkupParser parse; GMappedFile *f; int rc; struct kmlparse data; struct kml *kml; if (NULL != er) *er = NULL; memset(&parse, 0, sizeof(GMarkupParser)); memset(&data, 0, sizeof(struct kmlparse)); data.elem = KML_INIT; parse.start_element = kml_elem_start; parse.end_element = kml_elem_end; parse.text = kml_text; parse.error = kml_error; if (NULL == (f = g_mapped_file_new(file, FALSE, er))) return(NULL); ctx = g_markup_parse_context_new (&parse, 0, &data, NULL); g_assert(NULL != ctx); rc = g_markup_parse_context_parse (ctx, g_mapped_file_get_contents(f), g_mapped_file_get_length(f), er); g_markup_parse_context_free(ctx); g_free(data.buf); g_free(data.altbuf); g_free(data.ign); kmlparse_free(data.cur); if (0 == rc) { g_list_free_full(data.places, kmlparse_free); g_mapped_file_unref(f); return(NULL); } else if (NULL == data.places) { g_mapped_file_unref(f); return(NULL); } g_assert(NULL != data.places); kml = g_malloc0(sizeof(struct kml)); kml->file = f; kml->kmls = data.places; return(kml); }
static gboolean dispatch_bspatch (OstreeRepo *repo, StaticDeltaExecutionState *state, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; guint64 offset, length; g_autoptr(GInputStream) in_stream = NULL; g_autoptr(GMappedFile) input_mfile = NULL; g_autofree guchar *buf = NULL; struct bspatch_stream stream; struct bzpatch_opaque_s opaque; gsize bytes_written; if (!read_varuint64 (state, &offset, error)) goto out; if (!read_varuint64 (state, &length, error)) goto out; if (!state->have_obj) { input_mfile = g_mapped_file_new_from_fd (state->read_source_fd, FALSE, error); if (!input_mfile) goto out; buf = g_malloc0 (state->content_size); opaque.state = state; opaque.offset = offset; opaque.length = length; stream.read = bspatch_read; stream.opaque = &opaque; if (bspatch ((const guint8*)g_mapped_file_get_contents (input_mfile), g_mapped_file_get_length (input_mfile), buf, state->content_size, &stream) < 0) goto out; if (!g_output_stream_write_all (state->content_out, buf, state->content_size, &bytes_written, cancellable, error)) goto out; g_assert (bytes_written == state->content_size); } ret = TRUE; out: return ret; }
dt_gpx_t *dt_gpx_new(const gchar *filename) { dt_gpx_t *gpx = NULL; GMarkupParseContext *ctx = NULL; GError *err = NULL; GMappedFile *gpxmf = NULL; gchar *gpxmf_content = NULL; gint gpxmf_size = 0; /* map gpx file to parse into memory */ gpxmf = g_mapped_file_new(filename, FALSE, &err); if (err) goto error; gpxmf_content = g_mapped_file_get_contents(gpxmf); gpxmf_size = g_mapped_file_get_length(gpxmf); if (!gpxmf_content || gpxmf_size < 10) goto error; /* allocate new dt_gpx_t context */ gpx = g_malloc(sizeof(dt_gpx_t)); memset(gpx, 0, sizeof(dt_gpx_t)); /* initialize the parser and start parse gpx xml data */ ctx = g_markup_parse_context_new(&_gpx_parser, 0, gpx, NULL); g_markup_parse_context_parse(ctx, gpxmf_content, gpxmf_size, &err); if (err) goto error; /* clenup and return gpx context */ g_markup_parse_context_free(ctx); return gpx; error: if (err) { fprintf(stderr, "dt_gpx_new: %s\n", err->message); g_error_free(err); } if (ctx) g_markup_parse_context_free(ctx); if (gpx) g_free(gpx); return NULL; }
static gboolean start_decoder (App * app) { GstCaps *caps; app->file = g_mapped_file_new (app->file_name, FALSE, NULL); if (!app->file) return FALSE; app->file_size = g_mapped_file_get_length (app->file); app->file_data = (guint8 *) g_mapped_file_get_contents (app->file); if (!app->file_data) return FALSE; caps = caps_from_codec (app->codec); switch (app->codec) { case GST_VAAPI_CODEC_H264: app->decoder = gst_vaapi_decoder_h264_new (app->display, caps); break; #if USE_JPEG_DECODER case GST_VAAPI_CODEC_JPEG: app->decoder = gst_vaapi_decoder_jpeg_new (app->display, caps); break; #endif case GST_VAAPI_CODEC_MPEG2: app->decoder = gst_vaapi_decoder_mpeg2_new (app->display, caps); break; case GST_VAAPI_CODEC_MPEG4: app->decoder = gst_vaapi_decoder_mpeg4_new (app->display, caps); break; case GST_VAAPI_CODEC_VC1: app->decoder = gst_vaapi_decoder_vc1_new (app->display, caps); break; default: app->decoder = NULL; break; } if (!app->decoder) return FALSE; gst_vaapi_decoder_set_codec_state_changed_func (app->decoder, handle_decoder_state_changes, app); g_timer_start (app->timer); app->decoder_thread = g_thread_try_new ("Decoder Thread", decoder_thread, app, NULL); if (!app->decoder_thread) return FALSE; return TRUE; }
gboolean xr_server_simple(const char* cert, const char* privkey, int threads, const char* bind, xr_servlet_def** servlets, GError** err) { GError *local_err= NULL; GMappedFile *cert_file = g_mapped_file_new(cert, FALSE, &local_err); if (local_err) { g_propagate_prefixed_error(err, local_err, "Certificate load failed: "); g_mapped_file_unref(cert_file); return FALSE; } gchar *cert_pem = g_mapped_file_get_contents(cert_file); gchar *privkey_pem = NULL; GMappedFile *privkey_file = NULL; if (privkey) { privkey_file = g_mapped_file_new(privkey, FALSE, &local_err); if (local_err) { g_free(cert_pem); g_propagate_prefixed_error(err, local_err, "Certificate load failed: "); g_mapped_file_unref(privkey_file); g_mapped_file_unref(cert_file); return FALSE; } privkey_pem = g_mapped_file_get_contents(privkey_file); } gboolean retval = xr_server_simple_pem(cert_pem, privkey_pem, threads, bind, servlets, err); g_mapped_file_unref(cert_file); g_mapped_file_unref(privkey_file); return retval; }
static int compare_files(const gchar *f1, const gchar *f2) { GError *error = NULL; GMappedFile *file1 = NULL, *file2 = NULL; int err; file1 = g_mapped_file_new (f1, FALSE, &error); if (error != NULL) { file1 = NULL; err = -1; goto out_err; } file2 = g_mapped_file_new (f2, FALSE, &error); if (error != NULL) { file2 = NULL; err = -1; goto out_err; } /* Then update */ err = compare_data(g_mapped_file_get_contents (file1), g_mapped_file_get_length (file1), g_mapped_file_get_contents (file2), g_mapped_file_get_length (file2)); goto out; out_err: g_warning ("error opening file: %s",error->message); g_error_free (error); out: if (file1) g_mapped_file_free (file1); if (file2) g_mapped_file_free (file2); return err; }
DBParseContext * db_parse_context_new_from_file (const char *filename, Itdb_DB *db) { DBParseContext *ctx; Itdb_Device *device; GError* error; GMappedFile* mapped_file; struct stat stat_buf; ctx = NULL; error = NULL; mapped_file = NULL; device = db_get_device (db); g_return_val_if_fail (device, NULL); if (g_stat (filename, &stat_buf) != 0) { return NULL; }; if (stat_buf.st_size > 64 * 1024 * 1024) { g_warning ("%s is too big to be mmapped (%llu bytes)\n", filename, (unsigned long long)stat_buf.st_size); return NULL; } mapped_file = g_mapped_file_new(filename, FALSE, &error); if (mapped_file == NULL) { g_print ("Error while mapping %s: %s\n", filename, error->message); g_error_free(error); return NULL; } if (device->byte_order == 0) itdb_device_autodetect_endianess (device); ctx = db_parse_context_new ((guchar *)g_mapped_file_get_contents(mapped_file), g_mapped_file_get_length(mapped_file), device->byte_order); if (ctx == NULL) { g_mapped_file_unref(mapped_file); return NULL; } ctx->db = db; ctx->mapped_file = mapped_file; return ctx; }
static void set_indenter (EditorApplicationWindow *window, const gchar *filename) { GMappedFile *mapped_file; smie_symbol_pool_t *pool; smie_prec2_grammar_t *prec2; smie_grammar_t *grammar; const gchar *contents; GError *error; error = NULL; mapped_file = g_mapped_file_new (filename, FALSE, &error); if (!mapped_file) { g_warning ("Error while loading the file: %s", error->message); g_error_free (error); return; } pool = smie_symbol_pool_alloc (); error = NULL; contents = (const gchar *) g_mapped_file_get_contents (mapped_file); prec2 = smie_prec2_grammar_load (contents, &error); g_mapped_file_unref (mapped_file); if (!prec2) { g_warning ("Error while loading the grammar: %s", error->message); g_error_free (error); smie_symbol_pool_unref (pool); return; } error = NULL; grammar = smie_prec2_to_grammar (prec2, &error); smie_prec2_grammar_free (prec2); if (!grammar) { g_warning ("Error while converting prec2 to grammar: %s", error->message); g_error_free (error); smie_symbol_pool_unref (pool); smie_grammar_free (grammar); return; } window->indenter = smie_indenter_new (grammar, &smie_gtk_source_buffer_cursor_functions, &editor_rules); }