void ghb_set_pref_audio_settings(gint titleindex, GValue *settings) { gint track; gchar *source_lang; hb_audio_config_t *aconfig; GHashTable *track_indices; gint mux; const GValue *pref_audio; const GValue *audio, *drc, *gain, *enable_qual; gint acodec, bitrate, mix; gdouble rate, quality; gint count, ii, list_count; g_debug("set_pref_audio"); mux = ghb_settings_combo_int(settings, "FileFormat"); track_indices = g_hash_table_new_full(g_int_hash, g_int_equal, free_audio_hash_key_value, free_audio_hash_key_value); // Clear the audio list ghb_clear_audio_list_settings(settings); // Find "best" audio based on audio preferences if (!ghb_settings_get_boolean(settings, "AudioDUB")) { source_lang = g_strdup(ghb_get_source_audio_lang(titleindex, 0)); } else { source_lang = ghb_settings_get_string(settings, "PreferredLanguage"); } pref_audio = ghb_settings_get_value(settings, "AudioList"); list_count = 0; count = ghb_array_len(pref_audio); for (ii = 0; ii < count; ii++) { gint select_acodec; gint fallback; audio = ghb_array_get_nth(pref_audio, ii); acodec = ghb_settings_combo_int(audio, "AudioEncoder"); fallback = ghb_select_fallback(settings, mux, acodec); gint copy_mask = ghb_get_copy_mask(settings); select_acodec = ghb_select_audio_codec(mux, NULL, acodec, fallback, copy_mask); bitrate = ghb_settings_combo_int(audio, "AudioBitrate"); rate = ghb_settings_combo_double(audio, "AudioSamplerate"); mix = ghb_settings_combo_int(audio, "AudioMixdown"); drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider"); gain = ghb_settings_get_value(audio, "AudioTrackGain"); enable_qual = ghb_settings_get_value(audio, "AudioTrackQualityEnable"); quality = ghb_settings_get_double(audio, "AudioTrackQuality"); // If there are multiple audios using the same codec, then // select sequential tracks for each. The hash keeps track // of the tracks used for each codec. track = ghb_find_audio_track(titleindex, source_lang, select_acodec, fallback, track_indices); // Check to see if: // 1. pref codec is passthru // 2. source codec is not passthru // 3. next pref is enabled aconfig = ghb_get_scan_audio_info(titleindex, track); if (aconfig && ghb_audio_is_passthru (acodec)) { // HB_ACODEC_* are bit fields. Treat acodec as mask if (!(aconfig->in.codec & select_acodec & HB_ACODEC_PASS_MASK)) { if (acodec != HB_ACODEC_AUTO_PASS) acodec = fallback; // If we can't substitute the passthru with a suitable // encoder and // If there's more audio to process, or we've already // placed one in the list, then we can skip this one if (!(select_acodec & fallback) && ((ii + 1 < count) || (list_count != 0))) { // Skip this audio acodec = 0; } } else { select_acodec &= aconfig->in.codec | HB_ACODEC_PASS_FLAG; } } if (titleindex >= 0 && track < 0) acodec = 0; if (acodec != 0) { GValue *asettings = ghb_dict_value_new(); ghb_settings_set_int(asettings, "AudioTrack", track); ghb_settings_set_string(asettings, "AudioEncoder", ghb_lookup_combo_string("AudioEncoder", ghb_int_value(acodec))); ghb_settings_set_value(asettings, "AudioEncoderActual", ghb_lookup_acodec_value(select_acodec)); ghb_settings_set_value(asettings, "AudioTrackQualityEnable", enable_qual); ghb_settings_set_double(asettings, "AudioTrackQuality", quality); // This gets set autimatically if the codec is passthru ghb_settings_set_string(asettings, "AudioBitrate", ghb_lookup_combo_string("AudioBitrate", ghb_int_value(bitrate))); ghb_settings_set_string(asettings, "AudioSamplerate", ghb_lookup_combo_string("AudioSamplerate", ghb_int_value(rate))); mix = ghb_get_best_mix( aconfig, select_acodec, mix); ghb_settings_set_string(asettings, "AudioMixdown", ghb_lookup_combo_string("AudioMixdown", ghb_int_value(mix))); ghb_settings_set_value(asettings, "AudioTrackDRCSlider", drc); ghb_settings_set_value(asettings, "AudioTrackGain", gain); ghb_sanitize_audio(settings, asettings); ghb_add_audio_to_settings(settings, asettings); } } g_free(source_lang); g_hash_table_destroy(track_indices); }
static void fcitx_wizard_im_dialog_init(FcitxWizardImDialog* self) { gtk_window_set_title(GTK_WINDOW(self), _("Add input method")); gtk_window_set_modal(GTK_WINDOW(self), TRUE); gtk_dialog_add_buttons(GTK_DIALOG(self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL ); gtk_dialog_set_alternative_button_order (GTK_DIALOG (self), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect(self, "response", G_CALLBACK(_fcitx_wizard_im_dialog_response_cb), NULL); self->langset = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); self->builder = gtk_builder_new(); gtk_builder_add_from_resource(self->builder, "/org/fcitx/fcitx-config-gtk3/im_dialog.ui", NULL); const gchar* lang = _get_current_lang(); gchar* language = NULL, *territory = NULL; gdm_parse_language_name(lang, &language, &territory, NULL, NULL); if (!language || language[0] == '\0') { self->language = g_strdup("C"); } else { gboolean tisempty = (!territory || territory[0] == '\0'); self->language = g_strdup_printf("%s%s%s", language, tisempty ? "" : "_", tisempty ? "" : territory); } g_free(language); g_free(territory); #define _GET_OBJECT(NAME) \ self->NAME = (typeof(self->NAME)) gtk_builder_get_object(self->builder, #NAME); _GET_OBJECT(availimstore) _GET_OBJECT(availimview) _GET_OBJECT(filterentry) _GET_OBJECT(filtermodel) _GET_OBJECT(onlycurlangcheckbox) _GET_OBJECT(sortmodel) gtk_entry_set_placeholder_text(GTK_ENTRY(self->filterentry), _("Search Input Method")); gtk_widget_set_size_request(GTK_WIDGET(self), 400, 300); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel), (GtkTreeModelFilterVisibleFunc) _fcitx_wizard_im_dialog_filter_func, self , NULL); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(self->sortmodel), IM_LIST_IM, _fcitx_wizard_im_dialog_sort_func, self, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(self->sortmodel), IM_LIST_IM, GTK_SORT_ASCENDING); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->availimview), FALSE); GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->availimview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_fcitx_wizard_im_dialog_im_selection_changed), self); g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_wizard_im_dialog_filtertext_changed), self); g_signal_connect(G_OBJECT(self->onlycurlangcheckbox), "toggled", G_CALLBACK(_fcitx_wizard_im_dialog_onlycurlangcheckbox_toggled), self); g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL); }
cr_Package * cr_package_from_header(Header hdr, int changelog_limit, cr_HeaderReadingFlags hdrrflags, G_GNUC_UNUSED GError **err) { cr_Package *pkg; assert(hdr); assert(!err || *err == NULL); // Create new package structure pkg = cr_package_new(); pkg->loadingflags |= CR_PACKAGE_FROM_HEADER; pkg->loadingflags |= CR_PACKAGE_LOADED_PRI; pkg->loadingflags |= CR_PACKAGE_LOADED_FIL; pkg->loadingflags |= CR_PACKAGE_LOADED_OTH; // Create rpm tag data container rpmtd td = rpmtdNew(); headerGetFlags flags = HEADERGET_MINMEM | HEADERGET_EXT; // Fill package structure pkg->name = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_NAME)); gint64 is_src = headerGetNumber(hdr, RPMTAG_SOURCEPACKAGE); if (is_src) { pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, "src"); } else { pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_ARCH)); } pkg->version = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VERSION)); #define MAX_STR_INT_LEN 24 char tmp_epoch[MAX_STR_INT_LEN]; if (snprintf(tmp_epoch, MAX_STR_INT_LEN, "%llu", (long long unsigned int) headerGetNumber(hdr, RPMTAG_EPOCH)) <= 0) { tmp_epoch[0] = '\0'; } pkg->epoch = g_string_chunk_insert_len(pkg->chunk, tmp_epoch, MAX_STR_INT_LEN); pkg->release = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_RELEASE)); pkg->summary = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SUMMARY)); pkg->description = cr_safe_string_chunk_insert_null(pkg->chunk, headerGetString(hdr, RPMTAG_DESCRIPTION)); pkg->url = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_URL)); if (headerGet(hdr, RPMTAG_BUILDTIME, td, flags)) { pkg->time_build = rpmtdGetNumber(td); } pkg->rpm_license = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_LICENSE)); pkg->rpm_vendor = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VENDOR)); pkg->rpm_group = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_GROUP)); pkg->rpm_buildhost = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_BUILDHOST)); pkg->rpm_sourcerpm = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SOURCERPM)); pkg->rpm_packager = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_PACKAGER)); // RPMTAG_LONGSIZE is allways present (is emulated for small packages because HEADERGET_EXT flag was used) if (headerGet(hdr, RPMTAG_LONGSIZE, td, flags)) { pkg->size_installed = rpmtdGetNumber(td); } rpmtdFreeData(td); // RPMTAG_LONGARCHIVESIZE is allways present (is emulated for small packages because HEADERGET_EXT flag was used) if (headerGet(hdr, RPMTAG_LONGARCHIVESIZE, td, flags)) { pkg->size_archive = rpmtdGetNumber(td); } rpmtdFreeData(td); rpmtdFree(td); // // Fill files // rpmtd full_filenames = rpmtdNew(); // Only for filenames_hashtable rpmtd indexes = rpmtdNew(); rpmtd filenames = rpmtdNew(); rpmtd fileflags = rpmtdNew(); rpmtd filemodes = rpmtdNew(); GHashTable *filenames_hashtable = g_hash_table_new(g_str_hash, g_str_equal); rpmtd dirnames = rpmtdNew(); // Create list of pointer to directory names int dir_count; char **dir_list = NULL; if (headerGet(hdr, RPMTAG_DIRNAMES, dirnames, flags) && (dir_count = rpmtdCount(dirnames))) { int x = 0; dir_list = malloc(sizeof(char *) * dir_count); while (rpmtdNext(dirnames) != -1) { dir_list[x] = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(dirnames)); x++; } assert(x == dir_count); } if (headerGet(hdr, RPMTAG_FILENAMES, full_filenames, flags) && headerGet(hdr, RPMTAG_DIRINDEXES, indexes, flags) && headerGet(hdr, RPMTAG_BASENAMES, filenames, flags) && headerGet(hdr, RPMTAG_FILEFLAGS, fileflags, flags) && headerGet(hdr, RPMTAG_FILEMODES, filemodes, flags)) { rpmtdInit(full_filenames); rpmtdInit(indexes); rpmtdInit(filenames); rpmtdInit(fileflags); rpmtdInit(filemodes); while ((rpmtdNext(full_filenames) != -1) && (rpmtdNext(indexes) != -1) && (rpmtdNext(filenames) != -1) && (rpmtdNext(fileflags) != -1) && (rpmtdNext(filemodes) != -1)) { cr_PackageFile *packagefile = cr_package_file_new(); packagefile->name = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(filenames)); packagefile->path = (dir_list) ? dir_list[(int) rpmtdGetNumber(indexes)] : ""; if (S_ISDIR(rpmtdGetNumber(filemodes))) { // Directory packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "dir"); } else if (rpmtdGetNumber(fileflags) & RPMFILE_GHOST) { // Ghost packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "ghost"); } else { // Regular file packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, ""); } g_hash_table_replace(filenames_hashtable, (gpointer) rpmtdGetString(full_filenames), (gpointer) rpmtdGetString(full_filenames)); pkg->files = g_slist_prepend(pkg->files, packagefile); } pkg->files = g_slist_reverse (pkg->files); rpmtdFreeData(dirnames); rpmtdFreeData(indexes); rpmtdFreeData(filenames); rpmtdFreeData(fileflags); rpmtdFreeData(filemodes); } rpmtdFree(dirnames); rpmtdFree(indexes); rpmtdFree(filemodes); if (dir_list) { free((void *) dir_list); } // // PCOR (provides, conflicts, obsoletes, requires) // rpmtd fileversions = rpmtdNew(); // Struct used as value in ap_hashtable struct ap_value_struct { const char *flags; const char *version; int pre; }; // Hastable with filenames from provided GHashTable *provided_hashtable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); // Hashtable with already processed files from requires GHashTable *ap_hashtable = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, free); for (int deptype=0; dep_items[deptype].type != DEP_SENTINEL; deptype++) { if (headerGet(hdr, dep_items[deptype].nametag, filenames, flags) && headerGet(hdr, dep_items[deptype].flagstag, fileflags, flags) && headerGet(hdr, dep_items[deptype].versiontag, fileversions, flags)) { // Because we have to select only libc.so with highest version // e.g. libc.so.6(GLIBC_2.4) cr_Dependency *libc_require_highest = NULL; rpmtdInit(filenames); rpmtdInit(fileflags); rpmtdInit(fileversions); while ((rpmtdNext(filenames) != -1) && (rpmtdNext(fileflags) != -1) && (rpmtdNext(fileversions) != -1)) { int pre = 0; const char *filename = rpmtdGetString(filenames); guint64 num_flags = rpmtdGetNumber(fileflags); const char *flags = cr_flag_to_str(num_flags); const char *full_version = rpmtdGetString(fileversions); _cleanup_free_ char *depnfv = NULL; // Dep NameFlagsVersion depnfv = g_strconcat(filename, flags ? flags : "", full_version ? full_version : "", NULL); // Requires specific stuff if (deptype == DEP_REQUIRES) { // Skip requires which start with "rpmlib(" if (!strncmp("rpmlib(", filename, 7)) { continue; } // Skip package primary files if (*filename == '/' && g_hash_table_lookup_extended(filenames_hashtable, filename, NULL, NULL)) { if (cr_is_primary(filename)) { continue; } } // Skip files which are provided if (g_hash_table_lookup_extended(provided_hashtable, depnfv, NULL, NULL)) { continue; } // Calculate pre value if (num_flags & (RPMSENSE_PREREQ | RPMSENSE_SCRIPT_PRE | RPMSENSE_SCRIPT_POST)) { pre = 1; } // Skip duplicate files gpointer value; if (g_hash_table_lookup_extended(ap_hashtable, filename, NULL, &value)) { struct ap_value_struct *ap_value = value; if (!g_strcmp0(ap_value->flags, flags) && !strcmp(ap_value->version, full_version) && (ap_value->pre == pre)) { continue; } } } // Parse dep string cr_EVR *evr = cr_str_to_evr(full_version, pkg->chunk); if ((full_version && *full_version) && !evr->epoch) { // NULL in epoch mean that the epoch was bad (non-numerical) _cleanup_free_ gchar *pkg_nevra = cr_package_nevra(pkg); g_warning("Bad epoch in version string \"%s\" for dependency \"%s\" in package \"%s\"", full_version, filename, pkg_nevra); g_warning("Skipping this dependency"); g_free(evr); continue; } // Create dynamic dependency object cr_Dependency *dependency = cr_dependency_new(); dependency->name = cr_safe_string_chunk_insert(pkg->chunk, filename); dependency->flags = cr_safe_string_chunk_insert(pkg->chunk, flags); dependency->epoch = evr->epoch; dependency->version = evr->version; dependency->release = evr->release; g_free(evr); switch (deptype) { case DEP_PROVIDES: { char *depnfv_dup = g_strdup(depnfv); g_hash_table_replace(provided_hashtable, depnfv_dup, NULL); pkg->provides = g_slist_prepend(pkg->provides, dependency); break; } case DEP_CONFLICTS: pkg->conflicts = g_slist_prepend(pkg->conflicts, dependency); break; case DEP_OBSOLETES: pkg->obsoletes = g_slist_prepend(pkg->obsoletes, dependency); break; case DEP_REQUIRES: #ifdef ENABLE_LEGACY_WEAKDEPS if ( num_flags & RPMSENSE_MISSINGOK ) { pkg->recommends = g_slist_prepend(pkg->recommends, dependency); break; } #endif dependency->pre = pre; // XXX: libc.so filtering //////////////////////////// if (g_str_has_prefix(dependency->name, "libc.so.6")) { if (!libc_require_highest) libc_require_highest = dependency; else { if (cr_compare_dependency(libc_require_highest->name, dependency->name) == 2) { g_free(libc_require_highest); libc_require_highest = dependency; } else g_free(dependency); } break; } // XXX: libc.so filtering - END /////////////////////// pkg->requires = g_slist_prepend(pkg->requires, dependency); // Add file into ap_hashtable struct ap_value_struct *value = malloc(sizeof(struct ap_value_struct)); value->flags = flags; value->version = full_version; value->pre = dependency->pre; g_hash_table_replace(ap_hashtable, dependency->name, value); break; //case REQUIRES end case DEP_SUGGESTS: pkg->suggests = g_slist_prepend(pkg->suggests, dependency); break; case DEP_ENHANCES: pkg->enhances = g_slist_prepend(pkg->enhances, dependency); break; case DEP_RECOMMENDS: pkg->recommends = g_slist_prepend(pkg->recommends, dependency); break; case DEP_SUPPLEMENTS: pkg->supplements = g_slist_prepend(pkg->supplements, dependency); break; #ifdef ENABLE_LEGACY_WEAKDEPS case DEP_OLDSUGGESTS: if ( num_flags & RPMSENSE_STRONG ) { pkg->recommends = g_slist_prepend(pkg->recommends, dependency); } else { pkg->suggests = g_slist_prepend(pkg->suggests, dependency); } break; case DEP_OLDENHANCES: if ( num_flags & RPMSENSE_STRONG ) { pkg->supplements = g_slist_prepend(pkg->supplements, dependency); } else { pkg->enhances = g_slist_prepend(pkg->enhances, dependency); } break; #endif } // Switch end } // While end // XXX: libc.so filtering //////////////////////////////// if (deptype == DEP_REQUIRES && libc_require_highest) pkg->requires = g_slist_prepend(pkg->requires, libc_require_highest); // XXX: libc.so filtering - END //////////////////////////////// } rpmtdFreeData(filenames); rpmtdFreeData(fileflags); rpmtdFreeData(fileversions); } pkg->provides = g_slist_reverse (pkg->provides); pkg->conflicts = g_slist_reverse (pkg->conflicts); pkg->obsoletes = g_slist_reverse (pkg->obsoletes); pkg->requires = g_slist_reverse (pkg->requires); pkg->suggests = g_slist_reverse (pkg->suggests); pkg->enhances = g_slist_reverse (pkg->enhances); pkg->recommends = g_slist_reverse (pkg->recommends); pkg->supplements = g_slist_reverse (pkg->supplements); g_hash_table_remove_all(filenames_hashtable); g_hash_table_remove_all(provided_hashtable); g_hash_table_remove_all(ap_hashtable); g_hash_table_unref(filenames_hashtable); g_hash_table_unref(provided_hashtable); g_hash_table_unref(ap_hashtable); rpmtdFree(filenames); rpmtdFree(fileflags); rpmtdFree(fileversions); rpmtdFreeData(full_filenames); rpmtdFree(full_filenames); // // Changelogs // rpmtd changelogtimes = rpmtdNew(); rpmtd changelognames = rpmtdNew(); rpmtd changelogtexts = rpmtdNew(); if (headerGet(hdr, RPMTAG_CHANGELOGTIME, changelogtimes, flags) && headerGet(hdr, RPMTAG_CHANGELOGNAME, changelognames, flags) && headerGet(hdr, RPMTAG_CHANGELOGTEXT, changelogtexts, flags)) { gint64 last_time = G_GINT64_CONSTANT(0); rpmtdInit(changelogtimes); rpmtdInit(changelognames); rpmtdInit(changelogtexts); while ((rpmtdNext(changelogtimes) != -1) && (rpmtdNext(changelognames) != -1) && (rpmtdNext(changelogtexts) != -1) && (changelog_limit > 0 || changelog_limit == -1)) { gint64 time = rpmtdGetNumber(changelogtimes); cr_ChangelogEntry *changelog = cr_changelog_entry_new(); changelog->author = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(changelognames)); changelog->date = time; changelog->changelog = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(changelogtexts)); // Remove space from end of author name if (changelog->author) { size_t len, x; len = strlen(changelog->author); for (x=(len-1); x > 0; x--) { if (changelog->author[x] == ' ') { changelog->author[x] = '\0'; } else { break; } } } pkg->changelogs = g_slist_prepend(pkg->changelogs, changelog); if (changelog_limit != -1) changelog_limit--; // If a previous entry has the same time, increment time of the previous // entry by one. Ugly but works! if (last_time == time) { int tmp_time = time; GSList *previous = pkg->changelogs; while ((previous = g_slist_next(previous)) != NULL && ((cr_ChangelogEntry *) (previous->data))->date == tmp_time) { ((cr_ChangelogEntry *) (previous->data))->date++; tmp_time++; } } else { last_time = time; } } //pkg->changelogs = g_slist_reverse (pkg->changelogs); } rpmtdFreeData(changelogtimes); rpmtdFreeData(changelognames); rpmtdFreeData(changelogtexts); rpmtdFree(changelogtimes); rpmtdFree(changelognames); rpmtdFree(changelogtexts); // // Keys and hdrid (data used for caching when the --cachedir is specified) // if (hdrrflags & CR_HDRR_LOADHDRID) pkg->hdrid = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_HDRID)); if (hdrrflags & CR_HDRR_LOADSIGNATURES) { rpmtd gpgtd = rpmtdNew(); rpmtd pgptd = rpmtdNew(); if (headerGet(hdr, RPMTAG_SIGGPG, gpgtd, hdrrflags) && gpgtd->count > 0) { pkg->siggpg = cr_binary_data_new(); pkg->siggpg->size = gpgtd->count; pkg->siggpg->data = g_string_chunk_insert_len(pkg->chunk, gpgtd->data, gpgtd->count); } if (headerGet(hdr, RPMTAG_SIGPGP, pgptd, hdrrflags) && pgptd->count > 0) { pkg->sigpgp = cr_binary_data_new(); pkg->sigpgp->size = pgptd->count; pkg->sigpgp->data = g_string_chunk_insert_len(pkg->chunk, pgptd->data, pgptd->count); } rpmtdFree(gpgtd); rpmtdFree(pgptd); } return pkg; }
static void ggp_roster_reply_list(PurpleConnection *gc, uint32_t version, const char *data) { ggp_roster_session_data *rdata = ggp_roster_get_rdata(gc); PurpleXmlNode *xml, *xml_it; PurpleAccount *account; GSList *local_buddies; GHashTable *remove_buddies; GList *update_buddies = NULL, *local_groups, *it, *table_values; ggp_roster_content *content; g_return_if_fail(gc != NULL); g_return_if_fail(data != NULL); account = purple_connection_get_account(gc); purple_debug_info("gg", "ggp_roster_reply_list: got list, version=%u\n", version); xml = purple_xmlnode_from_str(data, -1); if (xml == NULL) { purple_debug_warning("gg", "ggp_roster_reply_list: " "invalid xml\n"); return; } ggp_roster_content_free(rdata->content); rdata->content = NULL; rdata->is_updating = TRUE; content = g_new0(ggp_roster_content, 1); content->version = version; content->xml = xml; content->contact_nodes = g_hash_table_new(NULL, NULL); content->group_nodes = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, NULL); content->group_ids = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free); content->group_names = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free); #if GGP_ROSTER_DEBUG ggp_roster_dump(content); #endif /* reading groups */ content->groups_node = purple_xmlnode_get_child(xml, "Groups"); if (content->groups_node == NULL) { ggp_roster_content_free(content); g_return_if_reached(); } xml_it = purple_xmlnode_get_child(content->groups_node, "Group"); while (xml_it != NULL) { if (!ggp_roster_reply_list_read_group(xml_it, content)) { ggp_roster_content_free(content); g_return_if_reached(); } xml_it = purple_xmlnode_get_next_twin(xml_it); } /* dumping current group list */ local_groups = ggp_purplew_account_get_groups(account, TRUE); /* dumping current buddy list * we will: * - remove synchronized ones, if not found in list at server * - upload not synchronized ones */ local_buddies = purple_blist_find_buddies(account, NULL); remove_buddies = g_hash_table_new(g_direct_hash, g_direct_equal); while (local_buddies) { PurpleBuddy *buddy = local_buddies->data; uin_t uin = ggp_str_to_uin(purple_buddy_get_name(buddy)); local_buddies = g_slist_delete_link(local_buddies, local_buddies); if (!uin) continue; if (ggp_roster_is_synchronized(buddy)) g_hash_table_insert(remove_buddies, GINT_TO_POINTER(uin), buddy); else update_buddies = g_list_append(update_buddies, buddy); } /* reading buddies */ content->contacts_node = purple_xmlnode_get_child(xml, "Contacts"); if (content->contacts_node == NULL) { g_hash_table_destroy(remove_buddies); g_list_free(update_buddies); ggp_roster_content_free(content); g_return_if_reached(); } xml_it = purple_xmlnode_get_child(content->contacts_node, "Contact"); while (xml_it != NULL) { if (!ggp_roster_reply_list_read_buddy(gc, xml_it, content, remove_buddies)) { g_hash_table_destroy(remove_buddies); g_list_free(update_buddies); ggp_roster_content_free(content); g_return_if_reached(); } xml_it = purple_xmlnode_get_next_twin(xml_it); } /* removing buddies, which are not present in roster */ table_values = g_hash_table_get_values(remove_buddies); it = g_list_first(table_values); while (it) { PurpleBuddy *buddy = it->data; it = g_list_next(it); if (!ggp_roster_is_synchronized(buddy)) continue; purple_debug_info("gg", "ggp_roster_reply_list: " "removing %s from buddy list\n", purple_buddy_get_name(buddy)); purple_blist_remove_buddy(buddy); } g_list_free(table_values); g_hash_table_destroy(remove_buddies); /* remove groups, which are empty, but had contacts before * synchronization */ it = g_list_first(local_groups); while (it) { PurpleGroup *group = it->data; it = g_list_next(it); if (purple_counting_node_get_total_size(PURPLE_COUNTING_NODE(group)) != 0) continue; purple_debug_info("gg", "ggp_roster_reply_list: " "removing group %s\n", purple_group_get_name(group)); purple_blist_remove_group(group); } g_list_free(local_groups); /* adding not synchronized buddies */ it = g_list_first(update_buddies); while (it) { PurpleBuddy *buddy = it->data; uin_t uin = ggp_str_to_uin(purple_buddy_get_name(buddy)); ggp_roster_change *change; it = g_list_next(it); g_assert(uin > 0); purple_debug_misc("gg", "ggp_roster_reply_list: " "adding change of %u for roster\n", uin); change = g_new0(ggp_roster_change, 1); change->type = GGP_ROSTER_CHANGE_CONTACT_UPDATE; change->data.uin = uin; rdata->pending_updates = g_list_append(rdata->pending_updates, change); } g_list_free(update_buddies); rdata->content = content; rdata->is_updating = FALSE; purple_debug_info("gg", "ggp_roster_reply_list: " "import done, version=%u\n", version); }
static void gkm_ssh_module_init (GkmSshModule *self) { self->keys_by_path = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); }
static gboolean tracker_controller_start (TrackerController *controller, GError **error) { TrackerControllerPrivate *priv; GList *modules; priv = controller->priv; priv->modules = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL); modules = tracker_writeback_modules_list (); while (modules) { TrackerWritebackModule *module; const gchar *path; path = modules->data; module = tracker_writeback_module_get (path); if (module) { g_hash_table_insert (priv->modules, g_strdup (path), module); } modules = modules->next; } #if GLIB_CHECK_VERSION (2,31,0) { GThread *thread; thread = g_thread_try_new ("controller", tracker_controller_thread_func, controller, error); if (!thread) return FALSE; /* We don't want to join it, so just unref the GThread */ g_thread_unref (thread); } #else if (!g_thread_create (tracker_controller_thread_func, controller, FALSE, error)) { return FALSE; } #endif #ifdef THREAD_ENABLE_TRACE g_debug ("Thread:%p (Controller) --- Waiting for controller thread to initialize...", g_thread_self ()); #endif /* THREAD_ENABLE_TRACE */ /* Wait for the controller thread to notify initialization */ #if GLIB_CHECK_VERSION (2,31,0) g_mutex_lock (&priv->initialization_mutex); while (!priv->initialized) g_cond_wait (&priv->initialization_cond, &priv->initialization_mutex); g_mutex_unlock (&priv->initialization_mutex); #else g_mutex_lock (priv->initialization_mutex); while (!priv->initialized) g_cond_wait (priv->initialization_cond, priv->initialization_mutex); g_mutex_unlock (priv->initialization_mutex); #endif /* If there was any error resulting from initialization, propagate it */ if (priv->initialization_error != NULL) { g_propagate_error (error, priv->initialization_error); return FALSE; } #ifdef THREAD_ENABLE_TRACE g_debug ("Thread:%p (Controller) --- Initialized", g_thread_self ()); #endif /* THREAD_ENABLE_TRACE */ return TRUE; }
#include "tomboy-struct.h" #include "tomboy-init.h" CD_APPLET_DEFINITION (N_("Note-Taking"), 1, 5, 4, CAIRO_DOCK_CATEGORY_APPLET_ACCESSORY, N_("Control your Gnote or TomBoy's notes directly in the dock !\n" "Click on a note to open it, Escape to close it.\n" "Middle-click to instantly create a new note.\n" "You can search inside notes and display their content on the icons."), "Necropotame (Adrien Pilleboue)") CD_APPLET_INIT_BEGIN myData.hNoteTable = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, // l'URI est partage avec l'icone. (GDestroyNotify) NULL); // on detruit les icones nous-memes. cd_notes_start (); //Enregistrement des notifications gldi_object_register_notification (&myContainerObjectMgr, NOTIFICATION_CLICK_ICON, (GldiNotificationFunc) CD_APPLET_ON_CLICK_FUNC, GLDI_RUN_FIRST, myApplet); // ici on s'enregistre explicitement avant le dock, pour pas qu'il essaye de lancer nos notes. CD_APPLET_REGISTER_FOR_MIDDLE_CLICK_EVENT; CD_APPLET_REGISTER_FOR_BUILD_MENU_EVENT; CD_APPLET_INIT_END CD_APPLET_STOP_BEGIN
GkmDataResult gkm_secret_binary_read (GkmSecretCollection *collection, GkmSecretData *sdata, gconstpointer data, gsize n_data) { gsize offset; guchar major, minor, crypto, hash; guint32 flags; guint32 lock_timeout; time_t mtime, ctime; char *display_name; guint32 tmp; guint32 num_items; guint32 crypto_size; guint32 hash_iterations; guchar salt[8]; ItemInfo *items; GkmSecret* master; GkmSecretObject *obj; EggBuffer to_decrypt = EGG_BUFFER_EMPTY; GkmDataResult res = GKM_DATA_FAILURE; GHashTable *checks = NULL; GkmSecretItem *item; EggBuffer buffer; GList *l, *iteml; int i; display_name = NULL; items = 0; obj = GKM_SECRET_OBJECT (collection); /* The buffer we read from */ egg_buffer_init_static (&buffer, data, n_data); if (buffer.len < KEYRING_FILE_HEADER_LEN || memcmp (buffer.buf, KEYRING_FILE_HEADER, KEYRING_FILE_HEADER_LEN) != 0) { egg_buffer_uninit (&buffer); return GKM_DATA_UNRECOGNIZED; } offset = KEYRING_FILE_HEADER_LEN; major = buffer.buf[offset++]; minor = buffer.buf[offset++]; crypto = buffer.buf[offset++]; hash = buffer.buf[offset++]; if (major != 0 || minor != 0 || crypto != 0 || hash != 0) { egg_buffer_uninit (&buffer); return GKM_DATA_UNRECOGNIZED; } if (!buffer_get_utf8_string (&buffer, offset, &offset, &display_name) || !buffer_get_time (&buffer, offset, &offset, &ctime) || !buffer_get_time (&buffer, offset, &offset, &mtime) || !egg_buffer_get_uint32 (&buffer, offset, &offset, &flags) || !egg_buffer_get_uint32 (&buffer, offset, &offset, &lock_timeout) || !egg_buffer_get_uint32 (&buffer, offset, &offset, &hash_iterations) || !buffer_get_bytes (&buffer, offset, &offset, salt, 8)) goto bail; for (i = 0; i < 4; i++) { if (!egg_buffer_get_uint32 (&buffer, offset, &offset, &tmp)) goto bail; } if (!egg_buffer_get_uint32 (&buffer, offset, &offset, &num_items)) goto bail; items = g_new0 (ItemInfo, num_items + 1); /* Hashed data, without secrets */ if (!read_hashed_item_info (&buffer, &offset, items, num_items)) goto bail; if (!egg_buffer_get_uint32 (&buffer, offset, &offset, &crypto_size)) goto bail; /* Make the crypted part is the right size */ if (crypto_size % 16 != 0) goto bail; /* Ensure the file is large enough to hold all the data (in case it got truncated) */ if (buffer.len < offset + crypto_size) goto bail; /* Copy the data into to_decrypt into non-pageable memory */ egg_buffer_set_allocator (&to_decrypt, egg_secure_realloc); egg_buffer_reserve (&to_decrypt, crypto_size); memcpy (to_decrypt.buf, buffer.buf + offset, crypto_size); to_decrypt.len = crypto_size; if (sdata != NULL) { master = gkm_secret_data_get_master (sdata); if (!decrypt_buffer (&to_decrypt, master, salt, hash_iterations)) goto bail; if (!verify_decrypted_buffer (&to_decrypt)) { res = GKM_DATA_LOCKED; goto bail; } else { offset = 16; /* Skip hash */ if (!read_full_item_info (&to_decrypt, &offset, items, num_items)) goto bail; } } /* Correctly read all data, possibly including the decrypted data. * Now update the keyring and items: */ gkm_secret_object_set_label (obj, display_name); gkm_secret_object_set_modified (obj, mtime); gkm_secret_object_set_created (obj, ctime); if (flags & LOCK_ON_IDLE_FLAG) gkm_secret_collection_set_lock_idle (collection, lock_timeout); else if (flags & LOCK_AFTER_FLAG) gkm_secret_collection_set_lock_after (collection, lock_timeout); /* Build a Hash table where we can track ids we haven't yet seen */ checks = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); iteml = gkm_secret_collection_get_items (collection); for (l = iteml; l; l = g_list_next (l)) g_hash_table_insert (checks, g_strdup (gkm_secret_object_get_identifier (l->data)), "unused"); g_list_free (iteml); for (i = 0; i < num_items; i++) { /* We've seen this id */ g_hash_table_remove (checks, items[i].identifier); item = gkm_secret_collection_get_item (collection, items[i].identifier); if (item == NULL) item = gkm_secret_collection_new_item (collection, items[i].identifier); setup_item_from_info (item, sdata, &items[i]); } g_hash_table_foreach (checks, remove_unavailable_item, collection); res = GKM_DATA_SUCCESS; bail: egg_buffer_uninit (&to_decrypt); if (checks) g_hash_table_destroy (checks); g_free (display_name); for (i = 0; items && i < num_items; i++) free_item_info (&items[i]); g_free (items); return res; }
static void jabber_login(account_t *acc) { struct im_connection *ic = imcb_new(acc); struct jabber_data *jd = g_new0(struct jabber_data, 1); char *s; /* For now this is needed in the _connected() handlers if using GLib event handling, to make sure we're not handling events on dead connections. */ jabber_connections = g_slist_prepend(jabber_connections, ic); jd->ic = ic; ic->proto_data = jd; jabber_set_me(ic, acc->user); jd->fd = jd->r_inpa = jd->w_inpa = -1; if (strcmp(acc->prpl->name, "hipchat") == 0) { jd->flags |= JFLAG_HIPCHAT; } if (jd->server == NULL) { imcb_error(ic, "Incomplete account name (format it like <*****@*****.**>)"); imc_logout(ic, FALSE); return; } if ((s = strchr(jd->server, '/'))) { *s = 0; set_setstr(&acc->set, "resource", s + 1); /* Also remove the /resource from the original variable so we won't have to do this again every time. */ s = strchr(acc->user, '/'); *s = 0; } jd->node_cache = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, jabber_cache_entry_free); jd->buddies = g_hash_table_new(g_str_hash, g_str_equal); if (set_getbool(&acc->set, "oauth")) { GSList *p_in = NULL; const char *tok; jd->fd = jd->r_inpa = jd->w_inpa = -1; if (strstr(jd->server, ".facebook.com")) { jd->oauth2_service = &oauth2_service_facebook; } else { jd->oauth2_service = &oauth2_service_google; } oauth_params_parse(&p_in, ic->acc->pass); /* First see if we have a refresh token, in which case any access token we *might* have has probably expired already anyway. */ if ((tok = oauth_params_get(&p_in, "refresh_token"))) { sasl_oauth2_refresh(ic, tok); } /* If we don't have a refresh token, let's hope the access token is still usable. */ else if ((tok = oauth_params_get(&p_in, "access_token"))) { jd->oauth2_access_token = g_strdup(tok); jabber_connect(ic); } /* If we don't have any, start the OAuth process now. Don't even open an XMPP connection yet. */ else { sasl_oauth2_init(ic); ic->flags |= OPT_SLOW_LOGIN; } oauth_params_free(&p_in); } else { jabber_connect(ic); } }
static void git_status_pane_init (GitStatusPane *self) { gchar *objects[] = {"status_pane", "status_model", NULL}; GError *error = NULL; GtkTreeView *status_view; GtkTreeViewColumn *status_column; GtkCellRenderer *selected_renderer; GtkCellRenderer *status_icon_renderer; GtkCellRenderer *status_name_renderer; GtkCellRenderer *path_renderer; GtkWidget *refresh_button; GtkWidget *select_all_button; GtkWidget *clear_button; self->priv = g_new0 (GitStatusPanePriv, 1); self->priv->builder = gtk_builder_new (); self->priv->selected_commit_items = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->priv->selected_not_updated_items = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); if (!gtk_builder_add_objects_from_file (self->priv->builder, BUILDER_FILE, objects, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free (error); } status_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder, "status_view")); status_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder, "status_column")); selected_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder, "selected_renderer")); status_icon_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder, "status_icon_renderer")); status_name_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder, "status_name_renderer")); path_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder, "path_renderer")); refresh_button = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "refresh_button")); select_all_button = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "select_all_button")); clear_button = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "clear_button")); gtk_tree_view_column_set_cell_data_func (status_column, selected_renderer, (GtkTreeCellDataFunc) selected_renderer_data_func, NULL, NULL); gtk_tree_view_column_set_cell_data_func (status_column, status_icon_renderer, (GtkTreeCellDataFunc) status_icon_renderer_data_func, NULL, NULL); gtk_tree_view_column_set_cell_data_func (status_column, status_name_renderer, (GtkTreeCellDataFunc) status_name_renderer_data_func, NULL, NULL); gtk_tree_view_column_set_cell_data_func (status_column, path_renderer, (GtkTreeCellDataFunc) path_renderer_data_func, NULL, NULL); g_signal_connect (G_OBJECT (selected_renderer), "toggled", G_CALLBACK (on_selected_renderer_toggled), self); g_signal_connect_swapped (G_OBJECT (refresh_button), "clicked", G_CALLBACK (anjuta_dock_pane_refresh), self); g_signal_connect (G_OBJECT (select_all_button), "clicked", G_CALLBACK (on_select_all_button_clicked), self); g_signal_connect (G_OBJECT (clear_button), "clicked", G_CALLBACK (on_clear_button_clicked), self); /* DND */ gtk_drag_dest_set (GTK_WIDGET (status_view), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT, drag_target_targets, G_N_ELEMENTS (drag_target_targets), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (status_view), "drag-drop", G_CALLBACK (on_status_view_drag_drop), self); g_signal_connect (G_OBJECT (status_view), "drag-data-received", G_CALLBACK (on_status_view_drag_data_received), self); /* Popup menus */ g_signal_connect (G_OBJECT (status_view), "button-press-event", G_CALLBACK (on_status_view_button_press_event), self); }
int gnoclCanvasCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { CanvasParams *para; int ret; if( gnoclParseOptions( interp, objc, objv, canvasOptions ) != TCL_OK ) { gnoclClearOptions( canvasOptions ); return TCL_ERROR; } para = g_new( CanvasParams, 1 ); /* what is that for? Found in canvas demos. */ gtk_widget_push_colormap( gdk_rgb_get_cmap() ); /* antialiased is default */ if( canvasOptions[antialiasedIdx].status == GNOCL_STATUS_CHANGED && canvasOptions[antialiasedIdx].val.b == 0 ) { para->canvas = GNOME_CANVAS( gnome_canvas_new( ) ); } else para->canvas = GNOME_CANVAS( gnome_canvas_new_aa( ) ); gtk_widget_show( GTK_WIDGET( para->canvas ) ); /* TODO: what is that for? Found in canvas demos. gtk_widget_pop_colormap(); */ gnome_canvas_set_center_scroll_region( para->canvas, 0 ); ret = gnoclSetOptions( interp, canvasOptions, G_OBJECT( para->canvas ), -1 ); if( ret == TCL_OK ) ret = configure( interp, para, canvasOptions ); gnoclClearOptions( canvasOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( para->canvas ) ); g_free( para ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->canvas ) ); /* TODO: g_hash_table_new_full */ para->tagToItems = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, ptrArrayFree ); para->interp = interp; g_signal_connect_after( G_OBJECT( para->canvas ), "destroy", G_CALLBACK( destroyFunc ), para ); Tcl_CreateObjCommand( interp, para->name, canvasFunc, para, NULL ); Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) ); return TCL_OK; }
/** * gst_rtsp_session_pool_filter: * @pool: a #GstRTSPSessionPool * @func: (scope call) (allow-none): a callback * @user_data: (closure): user data passed to @func * * Call @func for each session in @pool. The result value of @func determines * what happens to the session. @func will be called with the session pool * locked so no further actions on @pool can be performed from @func. * * If @func returns #GST_RTSP_FILTER_REMOVE, the session will be set to the * expired state with gst_rtsp_session_set_expired() and removed from * @pool. * * If @func returns #GST_RTSP_FILTER_KEEP, the session will remain in @pool. * * If @func returns #GST_RTSP_FILTER_REF, the session will remain in @pool but * will also be added with an additional ref to the result GList of this * function.. * * When @func is %NULL, #GST_RTSP_FILTER_REF will be assumed for all sessions. * * Returns: (element-type GstRTSPSession) (transfer full): a GList with all * sessions for which @func returned #GST_RTSP_FILTER_REF. After usage, each * element in the GList should be unreffed before the list is freed. */ GList * gst_rtsp_session_pool_filter (GstRTSPSessionPool * pool, GstRTSPSessionPoolFilterFunc func, gpointer user_data) { GstRTSPSessionPoolPrivate *priv; GHashTableIter iter; gpointer key, value; GList *result; GHashTable *visited; guint cookie; g_return_val_if_fail (GST_IS_RTSP_SESSION_POOL (pool), NULL); priv = pool->priv; result = NULL; if (func) visited = g_hash_table_new_full (NULL, NULL, g_object_unref, NULL); g_mutex_lock (&priv->lock); restart: g_hash_table_iter_init (&iter, priv->sessions); cookie = priv->sessions_cookie; while (g_hash_table_iter_next (&iter, &key, &value)) { GstRTSPSession *session = value; GstRTSPFilterResult res; gboolean changed; if (func) { /* only visit each session once */ if (g_hash_table_contains (visited, session)) continue; g_hash_table_add (visited, g_object_ref (session)); g_mutex_unlock (&priv->lock); res = func (pool, session, user_data); g_mutex_lock (&priv->lock); } else res = GST_RTSP_FILTER_REF; changed = (cookie != priv->sessions_cookie); switch (res) { case GST_RTSP_FILTER_REMOVE: { gboolean removed = TRUE; if (changed) /* something changed, check if we still have the session */ removed = g_hash_table_remove (priv->sessions, key); else g_hash_table_iter_remove (&iter); if (removed) { /* if we managed to remove the session, update the cookie and * signal */ cookie = ++priv->sessions_cookie; g_mutex_unlock (&priv->lock); g_signal_emit (pool, gst_rtsp_session_pool_signals[SIGNAL_SESSION_REMOVED], 0, session); g_mutex_lock (&priv->lock); /* cookie could have changed again, make sure we restart */ changed |= (cookie != priv->sessions_cookie); } break; } case GST_RTSP_FILTER_REF: /* keep ref */ result = g_list_prepend (result, g_object_ref (session)); break; case GST_RTSP_FILTER_KEEP: default: break; } if (changed) goto restart; } g_mutex_unlock (&priv->lock); if (func) g_hash_table_unref (visited); return result; }
/** * asb_utils_explode: * @filename: package filename * @dir: directory to decompress into * @glob: (element-type utf8): filename globs, or %NULL * @error: A #GError or %NULL * * Decompresses the package into a given directory. * * Returns: %TRUE for success, %FALSE otherwise * * Since: 0.1.0 **/ gboolean asb_utils_explode (const gchar *filename, const gchar *dir, GPtrArray *glob, GError **error) { const gchar *tmp; gboolean ret = TRUE; gboolean valid; int r; struct archive *arch = NULL; struct archive *arch_preview = NULL; struct archive_entry *entry; g_autoptr(GHashTable) matches = NULL; /* populate a hash with all the files, symlinks and hardlinks that * actually need decompressing */ arch_preview = archive_read_new (); archive_read_support_format_all (arch_preview); archive_read_support_filter_all (arch_preview); r = archive_read_open_filename (arch_preview, filename, 1024 * 32); if (r) { ret = FALSE; g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Cannot open: %s", archive_error_string (arch_preview)); goto out; } matches = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); for (;;) { g_autofree gchar *path = NULL; r = archive_read_next_header (arch_preview, &entry); if (r == ARCHIVE_EOF) break; if (r != ARCHIVE_OK) { ret = FALSE; g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Cannot read header: %s", archive_error_string (arch_preview)); goto out; } /* get the destination filename */ tmp = archive_entry_pathname (entry); if (tmp == NULL) continue; path = asb_utils_sanitise_path (tmp); if (glob != NULL) { if (asb_glob_value_search (glob, path) == NULL) continue; } g_hash_table_insert (matches, g_strdup (path), GINT_TO_POINTER (1)); /* add hardlink */ tmp = archive_entry_hardlink (entry); if (tmp != NULL) { g_hash_table_insert (matches, asb_utils_sanitise_path (tmp), GINT_TO_POINTER (1)); } /* add symlink */ tmp = archive_entry_symlink (entry); if (tmp != NULL) { if (g_path_is_absolute (tmp)) { g_hash_table_insert (matches, asb_utils_sanitise_path (tmp), GINT_TO_POINTER (1)); } else { g_autofree gchar *parent_dir = g_path_get_dirname (path); g_hash_table_insert (matches, asb_utils_resolve_relative_symlink (parent_dir, tmp), GINT_TO_POINTER (1)); } } } /* decompress anything matching either glob */ arch = archive_read_new (); archive_read_support_format_all (arch); archive_read_support_filter_all (arch); r = archive_read_open_filename (arch, filename, 1024 * 32); if (r) { ret = FALSE; g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Cannot open: %s", archive_error_string (arch)); goto out; } for (;;) { g_autofree gchar *path = NULL; r = archive_read_next_header (arch, &entry); if (r == ARCHIVE_EOF) break; if (r != ARCHIVE_OK) { ret = FALSE; g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Cannot read header: %s", archive_error_string (arch)); goto out; } /* only extract if valid */ tmp = archive_entry_pathname (entry); path = asb_utils_sanitise_path (tmp); if (g_hash_table_lookup (matches, path) == NULL) continue; valid = asb_utils_explode_file (entry, dir); if (!valid) continue; if (g_file_test (archive_entry_pathname (entry), G_FILE_TEST_EXISTS)) { g_debug ("skipping as %s already exists", archive_entry_pathname (entry)); continue; } if (archive_entry_symlink (entry) == NULL) { archive_entry_set_mode (entry, S_IRGRP | S_IWGRP | S_IRUSR | S_IWUSR); } r = archive_read_extract (arch, entry, 0); if (r != ARCHIVE_OK) { ret = FALSE; g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Cannot extract %s: %s", archive_entry_pathname (entry), archive_error_string (arch)); goto out; } } out: if (arch_preview != NULL) { archive_read_close (arch_preview); archive_read_free (arch_preview); } if (arch != NULL) { archive_read_close (arch); archive_read_free (arch); } return ret; }
/** * as_merge_components: * * Merge selected data from two components. */ static void as_merge_components (AsComponent *dest_cpt, AsComponent *src_cpt) { guint i; AsMergeKind merge_kind; merge_kind = as_component_get_merge_kind (src_cpt); g_return_if_fail (merge_kind != AS_MERGE_KIND_NONE); /* FIXME: We need to merge more attributes */ /* merge stuff in append mode */ if (merge_kind == AS_MERGE_KIND_APPEND) { GPtrArray *suggestions; GPtrArray *cats; /* merge categories */ cats = as_component_get_categories (src_cpt); if (cats->len > 0) { g_autoptr(GHashTable) cat_table = NULL; GPtrArray *dest_categories; cat_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); for (i = 0; i < cats->len; i++) { const gchar *cat = (const gchar*) g_ptr_array_index (cats, i); g_hash_table_add (cat_table, g_strdup (cat)); } dest_categories = as_component_get_categories (dest_cpt); if (dest_categories->len > 0) { for (i = 0; i < dest_categories->len; i++) { const gchar *cat = (const gchar*) g_ptr_array_index (dest_categories, i); g_hash_table_add (cat_table, g_strdup (cat)); } } g_ptr_array_set_size (dest_categories, 0); as_hash_table_string_keys_to_array (cat_table, dest_categories); } /* merge suggestions */ suggestions = as_component_get_suggested (src_cpt); if (suggestions != NULL) { for (i = 0; i < suggestions->len; i++) { as_component_add_suggested (dest_cpt, AS_SUGGESTED (g_ptr_array_index (suggestions, i))); } } } /* merge stuff in replace mode */ if (merge_kind == AS_MERGE_KIND_REPLACE) { gchar **pkgnames; /* merge names */ if (as_component_get_name (src_cpt) != NULL) as_component_set_name (dest_cpt, as_component_get_name (src_cpt), as_component_get_active_locale (src_cpt)); /* merge package names */ pkgnames = as_component_get_pkgnames (src_cpt); if ((pkgnames != NULL) && (pkgnames[0] != '\0')) as_component_set_pkgnames (dest_cpt, as_component_get_pkgnames (src_cpt)); /* merge bundles */ if (as_component_has_bundle (src_cpt)) as_component_set_bundles_array (dest_cpt, as_component_get_bundles (src_cpt)); } g_debug ("Merged data for '%s'", as_component_get_data_id (dest_cpt)); }
amar_file_t * amar_new_file( amar_t *archive, char *filename_buf, gsize filename_len, off_t *header_offset, GError **error) { amar_file_t *file = NULL; g_assert(archive->mode == O_WRONLY); g_assert(filename_buf != NULL); /* set filename_len if it wasn't specified */ if (!filename_len) filename_len = strlen(filename_buf); g_assert(filename_len != 0); if (filename_len > MAX_RECORD_DATA_SIZE) { g_set_error(error, amar_error_quark(), ENOSPC, "filename is too long for an amanda archive"); return NULL; } /* pick a new, unused filenum */ if (g_hash_table_size(archive->files) == 65535) { g_set_error(error, amar_error_quark(), ENOSPC, "No more file numbers available"); return NULL; } do { gint filenum; archive->maxfilenum++; /* MAGIC_FILENUM can't be used because it matches the header record text */ if (archive->maxfilenum == MAGIC_FILENUM) { continue; } /* see if this fileid is already in use */ filenum = archive->maxfilenum; if (g_hash_table_lookup(archive->files, &filenum)) continue; } while (0); file = g_new0(amar_file_t, 1); if (!file) { g_set_error(error, amar_error_quark(), ENOSPC, "No more memory"); return NULL; } file->archive = archive; file->filenum = archive->maxfilenum; file->attributes = g_hash_table_new_full(g_int_hash, g_int_equal, NULL, g_free); g_hash_table_insert(archive->files, &file->filenum, file); /* record the current position and write a header there, if desired */ if (header_offset) { *header_offset = archive->position; if (!write_header(archive, error)) goto error_exit; } /* add a filename record */ if (!write_record(archive, file->filenum, AMAR_ATTR_FILENAME, 1, filename_buf, filename_len, error)) goto error_exit; return file; error_exit: if (file) { g_hash_table_remove(archive->files, &file->filenum); g_hash_table_destroy(file->attributes); g_free(file); } return NULL; }
/* Register the given PDs for this session. * Accepts a string of the form: "spi:sck=3:sdata=4,spi:sck=3:sdata=5" * That will instantiate two SPI decoders on the clock but different data * lines. */ static int register_pds(struct sr_dev *dev, const char *pdstring) { GHashTable *pd_opthash; struct srd_decoder_inst *di; int ret; char **pdtokens, **pdtok, *pd_name; /* Avoid compiler warnings. */ (void)dev; ret = 0; pd_ann_visible = g_hash_table_new_full(g_str_hash, g_int_equal, g_free, NULL); pd_name = NULL; pd_opthash = NULL; pdtokens = g_strsplit(pdstring, ",", 0); for (pdtok = pdtokens; *pdtok; pdtok++) { if (!(pd_opthash = parse_generic_arg(*pdtok))) { g_critical("Invalid protocol decoder option '%s'.", *pdtok); goto err_out; } pd_name = g_strdup(g_hash_table_lookup(pd_opthash, "sigrok_key")); g_hash_table_remove(pd_opthash, "sigrok_key"); if (srd_decoder_load(pd_name) != SRD_OK) { g_critical("Failed to load protocol decoder %s.", pd_name); ret = 1; goto err_out; } if (!(di = srd_inst_new(pd_name, pd_opthash))) { g_critical("Failed to instantiate protocol decoder %s.", pd_name); ret = 1; goto err_out; } /* If no annotation list was specified, add them all in now. * This will be pared down later to leave only the last PD * in the stack. */ if (!opt_pd_annotations) g_hash_table_insert(pd_ann_visible, g_strdup(di->inst_id), NULL); /* Any keys left in the options hash are probes, where the key * is the probe name as specified in the decoder class, and the * value is the probe number i.e. the order in which the PD's * incoming samples are arranged. */ if (srd_inst_probe_set_all(di, pd_opthash) != SRD_OK) { ret = 1; goto err_out; } g_hash_table_destroy(pd_opthash); pd_opthash = NULL; } err_out: g_strfreev(pdtokens); if (pd_opthash) g_hash_table_destroy(pd_opthash); if (pd_name) g_free(pd_name); return ret; }
static void instance_init(LassoIdWsf2Sb2CredentialsContext *node) { node->attributes = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, g_free); }
int open_port_configuration(PortConfiguration *port_configuration, const gchar *port_configuration_file) { /* Declarations */ xmlDocPtr doc; xmlNodePtr node_root; xmlXPathObjectPtr result; /* Parse the XML document */ if((doc = xmlParseFile(port_configuration_file)) == NULL) { g_printerr("Error with parsing the port configuration XML file!\n"); xmlCleanupParser(); return FALSE; } /* Check if the document has a root */ node_root = xmlDocGetRootElement(doc); if(node_root == NULL) { g_printerr("The port configuration XML file is empty!\n"); xmlFreeDoc(doc); xmlCleanupParser(); return FALSE; } /* Query the global config properties */ result = executeXPathQuery(doc, "/portConfiguration/globalConfig"); if(result) { unsigned int i; xmlNodeSetPtr nodeset = result->nodesetval; for(i = 0; i < nodeset->nodeNr; i++) port_configuration->global_config = parse_target_config(nodeset->nodeTab[i]); } else port_configuration->global_config = NULL; /* Query the target config properties */ result = executeXPathQuery(doc, "/portConfiguration/targetConfigs"); port_configuration->target_configs = g_hash_table_new_full(g_str_hash, g_str_equal, delete_target_key, delete_config_value); if(result) { unsigned int i; xmlNodeSetPtr nodeset = result->nodesetval; for(i = 0; i < nodeset->nodeNr; i++) { xmlNodePtr target_node_children = nodeset->nodeTab[i]->children; while(target_node_children != NULL) { if(xmlStrcmp(target_node_children->name, (xmlChar *) "text") != 0) { TargetConfig *target_config = parse_target_config(target_node_children); gchar *target = g_strdup((gchar*)target_node_children->name); g_hash_table_insert(port_configuration->target_configs, target, target_config); } target_node_children = target_node_children->next; } } } /* Cleanup */ xmlFreeDoc(doc); xmlCleanupParser(); return TRUE; }
static void ide_keybindings_reload (IdeKeybindings *self) { GdkScreen *screen; PeasEngine *engine; const GList *list; IDE_ENTRY; g_assert (IDE_IS_KEYBINDINGS (self)); { g_autofree gchar *path = NULL; g_autoptr(GBytes) bytes = NULL; g_autoptr(GError) error = NULL; if (self->mode == NULL) self->mode = g_strdup ("default"); IDE_TRACE_MSG ("Loading %s keybindings", self->mode); path = g_strdup_printf ("/org/gnome/builder/keybindings/%s.css", self->mode); bytes = g_resources_lookup_data (path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error); if (error == NULL) { /* * We use -1 for the length so that the CSS provider knows that the * string is \0 terminated. This is guaranteed to us by GResources so * that interned data can be used as C strings. */ gtk_css_provider_load_from_data (self->css_provider, g_bytes_get_data (bytes, NULL), -1, &error); } if (error) g_warning ("%s", error->message); } engine = peas_engine_get_default (); screen = gdk_screen_get_default (); if (self->plugin_providers != NULL) { GHashTableIter iter; GtkStyleProvider *provider; g_hash_table_iter_init (&iter, self->plugin_providers); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&provider)) gtk_style_context_remove_provider_for_screen (screen, provider); g_clear_pointer (&self->plugin_providers, g_hash_table_unref); } self->plugin_providers = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); list = peas_engine_get_plugin_list (engine); for (; list != NULL; list = list->next) { PeasPluginInfo *plugin_info = list->data; if (!peas_plugin_info_is_loaded (plugin_info)) continue; ide_keybindings_load_plugin (self, plugin_info, engine); } IDE_EXIT; }
void init_port_configuration(PortConfiguration *port_configuration) { port_configuration->global_config = NULL; port_configuration->target_configs = g_hash_table_new_full(g_str_hash, g_str_equal, delete_target_key, delete_config_value); }
GtkWidget* linphone_gtk_init_chatroom(LinphoneChatRoom *cr, const LinphoneAddress *with){ GtkWidget *chat_view=linphone_gtk_create_widget("chatroom_frame"); GtkWidget *main_window=linphone_gtk_get_main_window(); GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch"); GtkWidget *text=linphone_gtk_get_widget(chat_view,"textview"); GdkColor color_grey = {0, 32512, 32512, 32512}; GdkColor color_light_grey = {0, 56832, 60928, 61952}; GdkColor color_black = {0}; int idx; GtkWidget *button; GtkWidget *entry = linphone_gtk_get_widget(chat_view,"text_entry"); MSList *messages; GHashTable *table; GtkTextTag *tmp_tag; GtkWidget *link_ctx_menu = gtk_menu_new(); GtkWidget *link_ctx_menu_copy_item = gtk_menu_item_new_with_label(_("Copy")); gtk_notebook_append_page(notebook,chat_view,create_tab_chat_header(cr,with)); idx = gtk_notebook_page_num(notebook, chat_view); gtk_notebook_set_current_page(notebook, idx); gtk_widget_show(chat_view); table=g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL); g_object_set_data(G_OBJECT(chat_view),"cr",cr); g_object_set_data(G_OBJECT(chat_view),"from_message",NULL); g_object_set_data_full(G_OBJECT(chat_view),"table",table,(GDestroyNotify)g_hash_table_destroy); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "me", "foreground_gdk", &color_black, "paragraph-background-gdk", &color_light_grey, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "from", "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "body", "indent", 10, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "status", "size-points", 9.0, "foreground_gdk", &color_grey, "style", PANGO_STYLE_ITALIC, "justification", GTK_JUSTIFY_RIGHT, NULL); tmp_tag = gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "link", "underline", PANGO_UNDERLINE_SINGLE, "foreground_gdk", _linphone_gtk_chatroom_get_link_color(chat_view), NULL); g_signal_connect(G_OBJECT(tmp_tag), "event", G_CALLBACK(link_event_handler), chat_view); g_signal_connect(G_OBJECT(text), "event", G_CALLBACK(chatroom_event), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(link_ctx_menu), link_ctx_menu_copy_item); g_signal_connect(G_OBJECT(link_ctx_menu_copy_item), "activate", G_CALLBACK(copy_uri_into_clipboard_handler), NULL); gtk_widget_show_all(link_ctx_menu); g_object_set_data_full(G_OBJECT(text), "link_ctx_menu", link_ctx_menu, g_object_unref); g_object_ref_sink(G_OBJECT(link_ctx_menu)); messages = linphone_chat_room_get_history(cr,NB_MSG_HIST); display_history_message(chat_view,messages,with); button = linphone_gtk_get_widget(chat_view,"send"); g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)linphone_gtk_send_text,NULL); g_signal_connect_swapped(G_OBJECT(entry),"activate",(GCallback)linphone_gtk_send_text,NULL); g_signal_connect_swapped(G_OBJECT(entry),"changed",(GCallback)linphone_gtk_compose_text,NULL); g_signal_connect(G_OBJECT(notebook),"switch_page",(GCallback)linphone_gtk_notebook_tab_select,NULL); return chat_view; }
NautilusIconInfo * nautilus_icon_info_lookup (GIcon *icon, int size) { NautilusIconInfo *icon_info; GdkPixbuf *pixbuf; if (G_IS_LOADABLE_ICON (icon)) { LoadableIconKey lookup_key; LoadableIconKey *key; GInputStream *stream; if (loadable_icon_cache == NULL) { loadable_icon_cache = g_hash_table_new_full ((GHashFunc)loadable_icon_key_hash, (GEqualFunc)loadable_icon_key_equal, (GDestroyNotify) loadable_icon_key_free, (GDestroyNotify) g_object_unref); } lookup_key.icon = icon; lookup_key.size = size; icon_info = g_hash_table_lookup (loadable_icon_cache, &lookup_key); if (icon_info) { return g_object_ref (icon_info); } pixbuf = NULL; stream = g_loadable_icon_load (G_LOADABLE_ICON (icon), size, NULL, NULL, NULL); if (stream) { pixbuf = eel_gdk_pixbuf_load_from_stream_at_size (stream, size); g_object_unref (stream); } icon_info = nautilus_icon_info_new_for_pixbuf (pixbuf); key = loadable_icon_key_new (icon, size); g_hash_table_insert (loadable_icon_cache, key, icon_info); return g_object_ref (icon_info); } else if (G_IS_THEMED_ICON (icon)) { const char * const *names; ThemedIconKey lookup_key; ThemedIconKey *key; GtkIconTheme *icon_theme; GtkIconInfo *gtkicon_info; const char *filename; if (themed_icon_cache == NULL) { themed_icon_cache = g_hash_table_new_full ((GHashFunc)themed_icon_key_hash, (GEqualFunc)themed_icon_key_equal, (GDestroyNotify) themed_icon_key_free, (GDestroyNotify) g_object_unref); } names = g_themed_icon_get_names (G_THEMED_ICON (icon)); icon_theme = gtk_icon_theme_get_default (); gtkicon_info = gtk_icon_theme_choose_icon (icon_theme, (const char **)names, size, 0); if (gtkicon_info == NULL) { return nautilus_icon_info_new_for_pixbuf (NULL); } filename = gtk_icon_info_get_filename (gtkicon_info); lookup_key.filename = (char *)filename; lookup_key.size = size; icon_info = g_hash_table_lookup (themed_icon_cache, &lookup_key); if (icon_info) { gtk_icon_info_free (gtkicon_info); return g_object_ref (icon_info); } icon_info = nautilus_icon_info_new_for_icon_info (gtkicon_info); key = themed_icon_key_new (filename, size); g_hash_table_insert (themed_icon_cache, key, icon_info); gtk_icon_info_free (gtkicon_info); return g_object_ref (icon_info); } else { GdkPixbuf *pixbuf; GtkIconInfo *gtk_icon_info; gtk_icon_info = gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (), icon, size, GTK_ICON_LOOKUP_GENERIC_FALLBACK); if (gtk_icon_info != NULL) { pixbuf = gtk_icon_info_load_icon (gtk_icon_info, NULL); gtk_icon_info_free (gtk_icon_info); } else { pixbuf = NULL; } return nautilus_icon_info_new_for_pixbuf (pixbuf); } }
int main (int argc, char **argv) { CockpitTransport *transport; gboolean terminated = FALSE; gboolean interupted = FALSE; gboolean closed = FALSE; GError *error = NULL; guint sig_term; guint sig_int; int ret = 0; int outfd; const gchar *ssh_auth_sock = BUILDDIR "/test-agent.sock"; int agent = 0; gchar *agent_output = NULL; gchar *agent_error = NULL; gchar *pid_line = NULL; gint status = 0; const gchar *agent_argv[] = { "/usr/bin/ssh-agent", "-a", ssh_auth_sock, NULL }; signal (SIGPIPE, SIG_IGN); g_setenv ("GSETTINGS_BACKEND", "memory", TRUE); g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE); g_setenv ("GIO_USE_VFS", "local", TRUE); outfd = dup (1); if (outfd < 0 || dup2 (2, 1) < 1) { g_warning ("bridge couldn't redirect stdout to stderr"); outfd = 1; } g_setenv ("SSH_AUTH_SOCK", ssh_auth_sock, TRUE); if (!g_spawn_sync (BUILDDIR, (gchar **)agent_argv, NULL, G_SPAWN_DEFAULT, NULL, NULL, &agent_output, &agent_error, &status, &error)) { g_warning ("bridge couldn't spawn agent %s\n", error->message); ret = 1; goto out; } if (!g_spawn_check_exit_status (status, &error)) { g_warning ("bridge couldn't spawn agent %s: %s\n", error->message, agent_error); ret = 1; goto out; } pid_line = strstr(agent_output, "SSH_AGENT_PID="); if (pid_line) { if (sscanf (pid_line, "SSH_AGENT_PID=%d;", &agent) != 1) g_warning ("couldn't find pid in %s", pid_line); } if (agent < 1) { g_warning ("couldn't get agent pid: %s", agent_output); ret = 1; goto out; } if (argc > 1) { const gchar *agent_add_argv[] = { "/usr/bin/ssh-add", argv[1], NULL }; gchar **agent_add_env = g_get_environ (); agent_add_env = g_environ_setenv (agent_add_env, "SSH_AUTH_SOCK", g_strdup (ssh_auth_sock), TRUE); g_spawn_sync (BUILDDIR, (gchar **)agent_add_argv, agent_add_env, G_SPAWN_DEFAULT, NULL, NULL, NULL, NULL, NULL, &error); g_strfreev (agent_add_env); if (error) { g_warning ("couldn't add key %s\n", error->message); ret = 1; goto out; } } sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated); sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted); g_type_init (); transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd); g_signal_connect (transport, "control", G_CALLBACK (on_transport_control), NULL); g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed); /* Owns the channels */ channels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); send_init_command (transport); while (!terminated && !closed && !interupted) g_main_context_iteration (NULL, TRUE); g_object_unref (transport); g_hash_table_destroy (channels); g_source_remove (sig_term); g_source_remove (sig_int); out: g_free (agent_output); g_free (agent_error); if (error) g_error_free (error); if (agent) kill (agent, SIGTERM); /* So the caller gets the right signal */ if (terminated) raise (SIGTERM); return ret; }
gboolean _g_dbus_address_parse_entry (const gchar *address_entry, gchar **out_transport_name, GHashTable **out_key_value_pairs, GError **error) { gboolean ret; GHashTable *key_value_pairs; gchar *transport_name; gchar **kv_pairs; const gchar *s; guint n; ret = FALSE; kv_pairs = NULL; transport_name = NULL; key_value_pairs = NULL; s = strchr (address_entry, ':'); if (s == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, _("Address element `%s', does not contain a colon (:)"), address_entry); goto out; } transport_name = g_strndup (address_entry, s - address_entry); key_value_pairs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); kv_pairs = g_strsplit (s + 1, ",", 0); for (n = 0; kv_pairs != NULL && kv_pairs[n] != NULL; n++) { const gchar *kv_pair = kv_pairs[n]; gchar *key; gchar *value; s = strchr (kv_pair, '='); if (s == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, _("Key/Value pair %d, `%s', in address element `%s', does not contain an equal sign"), n, kv_pair, address_entry); goto out; } /* TODO: actually validate that no illegal characters are present before and after then '=' sign */ key = g_uri_unescape_segment (kv_pair, s, NULL); value = g_uri_unescape_segment (s + 1, kv_pair + strlen (kv_pair), NULL); g_hash_table_insert (key_value_pairs, key, value); } ret = TRUE; out: g_strfreev (kv_pairs); if (ret) { if (out_transport_name != NULL) *out_transport_name = transport_name; else g_free (transport_name); if (out_key_value_pairs != NULL) *out_key_value_pairs = key_value_pairs; else if (key_value_pairs != NULL) g_hash_table_unref (key_value_pairs); } else { g_free (transport_name); if (key_value_pairs != NULL) g_hash_table_unref (key_value_pairs); } return ret; }
/** * g_hash_table_new: * @hash_func: a function to create a hash value from a key. * Hash values are used to determine where keys are stored within the * #GHashTable data structure. The g_direct_hash(), g_int_hash() and * g_str_hash() functions are provided for some common types of keys. * If hash_func is %NULL, g_direct_hash() is used. * @key_equal_func: a function to check two keys for equality. This is * used when looking up keys in the #GHashTable. The g_direct_equal(), * g_int_equal() and g_str_equal() functions are provided for the most * common types of keys. If @key_equal_func is %NULL, keys are compared * directly in a similar fashion to g_direct_equal(), but without the * overhead of a function call. * * Creates a new #GHashTable with a reference count of 1. * * Return value: a new #GHashTable. **/ GHashTable* g_hash_table_new (GHashFunc hash_func, GEqualFunc key_equal_func) { return g_hash_table_new_full (hash_func, key_equal_func, NULL, NULL); }
/** * @param filename the file to load from or NULL for default * @param create_lazy if FALSE creates default objects for * every known type. Otherwise default objects * are created on demand * * Create all the default objects. */ gboolean dia_object_defaults_load (const gchar *filename, gboolean create_lazy) { xmlDocPtr doc; xmlNsPtr name_space; ObjectNode obj_node, layer_node; object_default_create_lazy = create_lazy; if (!defaults_hash) { defaults_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _obj_destroy); if (!create_lazy) object_registry_foreach (_obj_create, defaults_hash); } /* overload properties from file */ if (!filename) { gchar *default_filename = dia_config_filename("defaults.dia"); if (g_file_test(default_filename, G_FILE_TEST_EXISTS)) doc = xmlDiaParseFile(default_filename); else doc = NULL; g_free (default_filename); } else doc = xmlDiaParseFile(filename); if (!doc) return FALSE; name_space = xmlSearchNs(doc, doc->xmlRootNode, (const xmlChar *)"dia"); if (xmlStrcmp (doc->xmlRootNode->name, (const xmlChar *)"diagram") || (name_space == NULL)) { message_error(_("Error loading defaults '%s'.\n" "Not a Dia diagram file."), dia_message_filename(filename)); xmlFreeDoc (doc); return FALSE; } layer_node = doc->xmlRootNode->xmlChildrenNode; while (layer_node) { if ( !xmlIsBlankNode(layer_node) && 0 == xmlStrcmp(layer_node->name, (const xmlChar *)"layer")) { obj_node = layer_node->xmlChildrenNode; while (obj_node) { if (!xmlIsBlankNode(obj_node) && 0 == xmlStrcmp(obj_node->name, (const xmlChar *)"object")) { char *typestr = (char *) xmlGetProp(obj_node, (const xmlChar *)"type"); char *version = (char *) xmlGetProp(obj_node, (const xmlChar *)"version"); if (typestr) { DiaObject *obj = g_hash_table_lookup (defaults_hash, typestr); if (!obj) { if (!create_lazy) g_warning ("Unknown object '%s' while reading '%s'", typestr, filename); else { DiaObjectType *type = object_get_type (typestr); if (type) obj = type->ops->load ( obj_node, 0, filename); if (obj) g_hash_table_insert (defaults_hash, obj->type->name, obj); } } else { #if 0 /* lots of complaining about missing attributes */ object_load_props(obj, obj_node); /* leaks ?? */ #else DiaObject *def_obj; def_obj = obj->type->ops->load ( obj_node, /*version ? atoi(version) : 0,*/0, filename); if (def_obj->ops->set_props) { object_copy_props (obj, def_obj, TRUE); def_obj->ops->destroy (def_obj); } else { /* can't copy props */ g_hash_table_replace (defaults_hash, def_obj->type->name, def_obj); } #endif } if (version) xmlFree (version); xmlFree (typestr); } } obj_node = obj_node->next; } } layer_node = layer_node->next; } xmlFreeDoc(doc); return TRUE; }
static GHashTable * parse_resource_file (const gchar *filename, gboolean collect_data) { GMarkupParser parser = { start_element, end_element, text }; ParseState state = { 0, }; GMarkupParseContext *context; GError *error = NULL; gchar *contents; GHashTable *table = NULL; gsize size; if (!g_file_get_contents (filename, &contents, &size, &error)) { g_printerr ("%s\n", error->message); g_clear_error (&error); return NULL; } state.table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)file_data_free); state.collect_data = collect_data; context = g_markup_parse_context_new (&parser, G_MARKUP_TREAT_CDATA_AS_TEXT | G_MARKUP_PREFIX_ERROR_POSITION, &state, NULL); if (!g_markup_parse_context_parse (context, contents, size, &error) || !g_markup_parse_context_end_parse (context, &error)) { g_printerr ("%s: %s.\n", filename, error->message); g_clear_error (&error); } else if (collect_data) { GHashTableIter iter; const char *key; char *mykey; gsize key_len; FileData *data; GVariant *v_data; GVariantBuilder builder; GvdbItem *item; table = gvdb_hash_table_new (NULL, NULL); g_hash_table_iter_init (&iter, state.table); while (g_hash_table_iter_next (&iter, (gpointer *)&key, (gpointer *)&data)) { key_len = strlen (key); mykey = g_strdup (key); item = gvdb_hash_table_insert (table, key); gvdb_item_set_parent (item, get_parent (table, mykey, key_len)); g_free (mykey); g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuay)")); g_variant_builder_add (&builder, "u", data->size); /* Size */ g_variant_builder_add (&builder, "u", data->flags); /* Flags */ v_data = g_variant_new_from_data (G_VARIANT_TYPE("ay"), data->content, data->content_size, TRUE, g_free, data->content); g_variant_builder_add_value (&builder, v_data); data->content = NULL; /* Take ownership */ gvdb_item_set_value (item, g_variant_builder_end (&builder)); } } else { table = g_hash_table_ref (state.table); } g_hash_table_unref (state.table); g_markup_parse_context_free (context); g_free (contents); return table; }
request_cgi_env_t * request_init_cgi_env(void) { request_cgi_env_t *env; const gchar *e; env = g_malloc0(sizeof(request_cgi_env_t)); if (env == NULL) { DEBUG_PRINT("Out of memory (env)"); return NULL; } /* get hostname and port */ e = g_getenv("HTTP_HOST"); if (e == NULL) { DEBUG_PRINT("No hostname given"); request_free_cgi_env(env); return NULL; } env->hostname = g_strdup(e); if (env->hostname == NULL) { DEBUG_PRINT("Out of memory for HTTP_HOST"); request_free_cgi_env(env); return NULL; } e = g_getenv("SERVER_PORT"); if (e == NULL) { env->port=80; } else { env->port = (unsigned int)strtoul(e, NULL, 10); /* XXX fix up... port 0 is mostly reserved */ if (env->port==0) env->port=80; } /* get resow root path */ e = g_getenv("SCRIPT_NAME"); if (e == NULL) { DEBUG_PRINT("SCRIPT_NAME (base path) not set"); request_free_cgi_env(env); return NULL; } env->resow_root = g_strdup(e); if (env->resow_root == NULL) { DEBUG_PRINT("Out of memory for SCRIPT_NAME"); request_free_cgi_env(env); return NULL; } /* determine request method */ e = g_getenv("REQUEST_METHOD"); if (e == NULL) { DEBUG_PRINT("No request method"); request_free_cgi_env(env); return NULL; } env->method = 0; if (!g_ascii_strcasecmp(e, "GET")) env->method = HTTP_METHOD_GET; else if (!g_ascii_strcasecmp(e, "POST")) env->method = HTTP_METHOD_POST; else if (!g_ascii_strcasecmp(e, "PUT")) env->method = HTTP_METHOD_PUT; else if (!g_ascii_strcasecmp(e, "DELETE")) env->method = HTTP_METHOD_DELETE; else { DEBUG_PRINT("Unknown HTTP method"); request_free_cgi_env(env); return NULL; } /* store full request */ e = g_getenv("REQUEST_URI"); if (e == NULL) { DEBUG_PRINT("Unknown REQUEST_URI not set"); request_free_cgi_env(env); return NULL; } env->uri = g_strdup(e); if (env->uri == NULL) { DEBUG_PRINT("Out of memory for REQUEST_URI"); request_free_cgi_env(env); return NULL; } /* store path part */ e = g_getenv("PATH_INFO"); if (e == NULL) e=""; env->path_part = g_strdup(e); if (env->path_part == NULL) { DEBUG_PRINT("Out of memory for PATH_INFO"); request_free_cgi_env(env); return NULL; } /* calc uri path */ if (http_request_get_uri_path(env)!=0) { DEBUG_PRINT("Out of memory for uri path"); request_free_cgi_env(env); return NULL; } /* store parameters into a hash structure */ e = g_getenv("QUERY_STRING"); if (e == NULL) e=""; env->query_parameters = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); if (env->query_parameters == NULL) { DEBUG_PRINT("Out of memory for QUERY_STRING"); request_free_cgi_env(env); return NULL; } if (request_parse_query(e, env->query_parameters)!=0) { DEBUG_PRINT("Out of memory for QUERY_STRING in parser"); request_free_cgi_env(env); return NULL; } /* parse HTTP_ACCEPT header */ e = g_getenv("HTTP_ACCEPT"); if (e == NULL) e=""; env->accept_datatype = request_parse_accepts_properties(e, "*/*"); if (env->accept_datatype == NULL) { DEBUG_PRINT("request_parse_accepts_properties on HTTP_ACCEPT returned NULL"); request_free_cgi_env(env); return NULL; } /* parse HTTP_ACCEPT_LANGUAGE header */ e = g_getenv("HTTP_ACCEPT_LANGUAGE"); if (e == NULL) e=""; env->accept_language = request_parse_accepts_properties(e, "en"); if (env->accept_language == NULL) { DEBUG_PRINT("request_parse_accepts_properties on HTTP_ACCEPT_LANGUAGE returned NULL"); request_free_cgi_env(env); return NULL; } /* parse HTTP_ACCEPT_ENCODING header */ e = g_getenv("HTTP_ACCEPT_ENCODING"); if (e == NULL) e=""; env->accept_encoding = request_parse_accepts_properties(e, NULL); /* content length */ e = g_getenv("CONTENT_LENGTH"); if (e!=NULL) { env->content_length=strtoul(e, NULL, 10); } else env->content_length=0; /* fprintf(stderr, "CL: %li\n", env->content_length); fprintf(stderr, "R: (%u) %s\n", env->method, env->uri); system("env > /tmp/env"); */ e = g_getenv("CONTENT_TYPE"); if (e != NULL) { env->content_type=g_strdup(e); if (strcmp(e,"application/x-www-form-urlencoded")==0) { /* parse form data */ gchar *formdata; formdata=request_get_form_data(env->content_length); if (formdata == NULL) { DEBUG_PRINT("Out of memory for form data"); request_free_cgi_env(env); return NULL; } env->form_parameters = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); if (env->form_parameters == NULL) { DEBUG_PRINT("Out of memory for form"); g_free(formdata); request_free_cgi_env(env); return NULL; } if (request_parse_query(formdata, env->form_parameters)!=0) { DEBUG_PRINT("Out of memory for parsing form"); g_free(formdata); request_free_cgi_env(env); return NULL; } env->content_length=0; /* clear; nothing more to read */ g_free(formdata); } else env->form_parameters=NULL; } else { env->content_type=NULL; env->form_parameters=NULL; } if ((e = g_getenv("HTTP_IF_NONE_MATCH"))!=NULL) { env->if_none_match=g_strdup(e); } if ((e = g_getenv("HTTP_IF_MATCH"))!=NULL) { env->if_match=g_strdup(e); } return env; }
static GtkCellEditable * cg_cell_renderer_flags_start_editing (GtkCellRenderer *cell, G_GNUC_UNUSED GdkEvent *event, G_GNUC_UNUSED GtkWidget *widget, const gchar *path, G_GNUC_UNUSED const GdkRectangle *background_area, G_GNUC_UNUSED const GdkRectangle *cell_area, G_GNUC_UNUSED GtkCellRendererState flags) { CgCellRendererFlags *cell_flags; CgCellRendererFlagsPrivate *priv; GtkCellRendererText *cell_text; gboolean editable; gchar *text; const gchar *prev; const gchar *pos; GtkWidget *combo; GtkCellRenderer *cell_combo_set; GtkCellRenderer *cell_combo_text; cell_flags = CG_CELL_RENDERER_FLAGS (cell); priv = CG_CELL_RENDERER_FLAGS_PRIVATE (cell_flags); cell_text = GTK_CELL_RENDERER_TEXT (cell); g_object_get (cell_text, "editable", &editable, "text", &text, NULL); if (editable == FALSE) return NULL; if (priv->model == NULL || priv->text_column < 0 || priv->abbr_column < 0) return NULL; cell_combo_set = gtk_cell_renderer_toggle_new (); cell_combo_text = gtk_cell_renderer_text_new (); combo = cg_combo_flags_new_with_model (priv->model); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell_combo_set, FALSE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell_combo_text, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), cell_combo_text, "text", priv->text_column); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell_combo_set, cg_cell_renderer_flags_set_data_func, cell_flags, NULL); g_object_set (G_OBJECT (cell_combo_set), "activatable", FALSE, NULL); /* Create hash table with current status. We could also operate * directly on a string here, but a hash table is probably more * efficient. */ g_assert (priv->edit_status == NULL); priv->edit_status = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL); pos = text; prev = text; while (prev != NULL && *prev != '\0') { while (*pos != '|' && *pos != '\0') ++ pos; g_hash_table_insert (priv->edit_status, g_strndup(prev, pos - prev), GINT_TO_POINTER(1)); if(*pos != '\0') ++ pos; prev = pos; } g_free (text); g_object_set_data_full (G_OBJECT (combo), CG_CELL_RENDERER_FLAGS_PATH, g_strdup (path), g_free); gtk_widget_show (combo); g_signal_connect (G_OBJECT (combo), "editing-done", G_CALLBACK (cg_cell_renderer_flags_editing_done), cell_flags); g_signal_connect (G_OBJECT (combo), "selected", G_CALLBACK (cg_cell_renderer_flags_selected), cell_flags); priv->focus_out_id = g_signal_connect (G_OBJECT (combo), "focus_out_event", G_CALLBACK (cg_cell_renderer_flags_focus_out_event), cell_flags); return GTK_CELL_EDITABLE (combo); }
static void gs_plugin_key_colors_set_for_pixbuf (GsApp *app, GdkPixbuf *pb, guint number) { GList *l; gint rowstride, n_channels; gint x, y; guchar *pixels, *p; guint bin_size = 200; guint i; guint number_of_bins; g_autoptr(AsImage) im = NULL; /* go through each pixel */ n_channels = gdk_pixbuf_get_n_channels (pb); rowstride = gdk_pixbuf_get_rowstride (pb); pixels = gdk_pixbuf_get_pixels (pb); for (bin_size = 250; bin_size > 0; bin_size -= 2) { g_autoptr(GHashTable) hash = NULL; hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); for (y = 0; y < gdk_pixbuf_get_height (pb); y++) { for (x = 0; x < gdk_pixbuf_get_width (pb); x++) { CdColorRGB8 tmp; GsColorBin *s; gpointer key; /* disregard any with alpha */ p = pixels + y * rowstride + x * n_channels; if (p[3] != 255) continue; /* find in cache */ tmp.R = (guint8) (p[0] / bin_size); tmp.G = (guint8) (p[1] / bin_size); tmp.B = (guint8) (p[2] / bin_size); key = GUINT_TO_POINTER (cd_color_rgb8_to_uint32 (&tmp)); s = g_hash_table_lookup (hash, key); if (s != NULL) { s->color.red += _convert_from_rgb8 (p[0]); s->color.green += _convert_from_rgb8 (p[1]); s->color.blue += _convert_from_rgb8 (p[2]); s->cnt++; continue; } /* add to hash table */ s = g_new0 (GsColorBin, 1); s->color.red = _convert_from_rgb8 (p[0]); s->color.green = _convert_from_rgb8 (p[1]); s->color.blue = _convert_from_rgb8 (p[2]); s->color.alpha = 1.0; s->cnt = 1; g_hash_table_insert (hash, key, s); } } number_of_bins = g_hash_table_size (hash); // g_debug ("number of colors: %i", number_of_bins); if (number_of_bins >= number) { g_autoptr(GList) values = NULL; /* order by most popular */ values = g_hash_table_get_values (hash); values = g_list_sort (values, gs_color_bin_sort_cb); for (l = values; l != NULL; l = l->next) { GsColorBin *s = l->data; g_autofree GdkRGBA *color = g_new0 (GdkRGBA, 1); color->red = s->color.red / s->cnt; color->green = s->color.green / s->cnt; color->blue = s->color.blue / s->cnt; gs_app_add_key_color (app, color); } return; } } /* the algorithm failed, so just return a monochrome ramp */ for (i = 0; i < 3; i++) { g_autofree GdkRGBA *color = g_new0 (GdkRGBA, 1); color->red = (gdouble) i / 3.f; color->green = color->red; color->blue = color->red; color->alpha = 1.0f; gs_app_add_key_color (app, color); } }