} END_TEST START_TEST(test_datastructures_sorted_list) { girara_list_t* list = girara_sorted_list_new2((girara_compare_function_t) g_strcmp0, (girara_free_function_t) g_free); fail_unless((list != NULL), NULL); girara_list_t* unsorted_list = girara_list_new2((girara_free_function_t) g_free); fail_unless((unsorted_list != NULL), NULL); static const char* test_strings[] = { "A", "C", "Baa", "Za", "Bba", "Bab", NULL }; static const char* test_strings_sorted[] = { "A", "Baa", "Bab", "Bba", "C", "Za", NULL }; // append for (const char** p = test_strings; *p != NULL; ++p) { girara_list_append(list, (void*)g_strdup(*p)); girara_list_append(unsorted_list, (void*)g_strdup(*p)); } fail_unless((girara_list_size(list) == sizeof(test_strings) / sizeof(char*) - 1), NULL); fail_unless((girara_list_size(unsorted_list) == sizeof(test_strings) / sizeof(char*) - 1), NULL); // check sorting const char** p = test_strings_sorted; GIRARA_LIST_FOREACH(list, const char*, iter, value) fail_unless((g_strcmp0(value, *p) == 0), NULL); ++p; GIRARA_LIST_FOREACH_END(list, const char*, iter, value); girara_list_sort(unsorted_list, (girara_compare_function_t) g_strcmp0); p = test_strings_sorted; GIRARA_LIST_FOREACH(unsorted_list, const char*, iter, value) fail_unless((g_strcmp0(value, *p) == 0), NULL); ++p; GIRARA_LIST_FOREACH_END(unsorted_list, const char*, iter, value); girara_list_free(list); girara_list_free(unsorted_list); } END_TEST
girara_list_t* pdf_document_attachments_get(zathura_document_t* document, void* data, zathura_error_t* error) { if (document == NULL || data == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_INVALID_ARGUMENTS; } return NULL; } PopplerDocument* poppler_document = data; if (poppler_document_has_attachments(poppler_document) == FALSE) { girara_warning("PDF file has no attachments"); if (error != NULL) { *error = ZATHURA_ERROR_UNKNOWN; } return NULL; } girara_list_t* res = girara_sorted_list_new2((girara_compare_function_t) g_strcmp0, g_free); if (res == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_OUT_OF_MEMORY; } return NULL; } GList* attachment_list = poppler_document_get_attachments(poppler_document); for (GList* attachments = attachment_list; attachments != NULL; attachments = g_list_next(attachments)) { PopplerAttachment* attachment = (PopplerAttachment*) attachments->data; girara_list_append(res, g_strdup(attachment->name)); } return res; }
static bool register_plugin(zathura_plugin_manager_t* plugin_manager, zathura_plugin_t* plugin) { if (plugin == NULL || plugin->content_types == NULL || plugin->register_function == NULL || plugin_manager == NULL || plugin_manager->plugins == NULL) { girara_error("plugin: could not register\n"); return false; } bool at_least_one = false; GIRARA_LIST_FOREACH(plugin->content_types, gchar*, iter, type) if (plugin_mapping_new(plugin_manager, type, plugin) == false) { girara_error("plugin: already registered for filetype %s\n", type); } else { at_least_one = true; } GIRARA_LIST_FOREACH_END(plugin->content_types, gchar*, iter, type); if (at_least_one == true) { girara_list_append(plugin_manager->plugins, plugin); } return at_least_one; }
static bool plugin_mapping_new(zathura_plugin_manager_t* plugin_manager, const gchar* type, zathura_plugin_t* plugin) { g_return_val_if_fail(plugin_manager != NULL, false); g_return_val_if_fail(type != NULL, false); g_return_val_if_fail(plugin != NULL, false); GIRARA_LIST_FOREACH(plugin_manager->type_plugin_mapping, zathura_type_plugin_mapping_t*, iter, mapping) if (g_content_type_equals(type, mapping->type)) { girara_list_iterator_free(iter); return false; } GIRARA_LIST_FOREACH_END(plugin_manager->type_plugin_mapping, zathura_type_plugin_mapping_t*, iter, mapping); zathura_type_plugin_mapping_t* mapping = g_try_malloc0(sizeof(zathura_type_plugin_mapping_t)); if (mapping == NULL) { return false; } mapping->type = g_strdup(type); mapping->plugin = plugin; girara_list_append(plugin_manager->type_plugin_mapping, mapping); return true; }
bool girara_setting_add(girara_session_t* session, const char* name, void* value, girara_setting_type_t type, bool init_only, const char* description, girara_setting_callback_t callback, void* data) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(name != NULL, false); g_return_val_if_fail(type != UNKNOWN, false); if (type != STRING && value == NULL) { return false; } /* search for existing setting */ if (girara_setting_find(session, name) != NULL) { return false; } /* add new setting */ girara_setting_t* setting = g_slice_new0(girara_setting_t); setting->name = g_strdup(name); setting->type = type; setting->init_only = init_only; setting->description = description ? g_strdup(description) : NULL; setting->callback = callback; setting->data = data; girara_setting_set_value(NULL, setting, value); girara_list_append(session->private_data->settings, setting); return true; }
girara_list_t* jumanji_db_history_find(jumanji_database_t* database, const char* input) { if (database == NULL || database->session == NULL || input == NULL) { return NULL; } /* prepare statement */ static const char SQL_HISTORY_FIND[] = "SELECT * FROM history WHERE " "url LIKE (SELECT '%' || ? || '%') OR " "title LIKE (SELECT '%' || ? || '%');"; sqlite3_stmt* statement = jumanji_db_prepare_statement(database->session, SQL_HISTORY_FIND); if (statement == NULL) { return NULL; } /* bind values */ if (sqlite3_bind_text(statement, 1, input, -1, NULL) != SQLITE_OK || sqlite3_bind_text(statement, 2, input, -1, NULL) != SQLITE_OK ) { girara_error("Could not bind query parameters"); sqlite3_finalize(statement); return NULL; } girara_list_t* results = girara_list_new(); if (results == NULL) { sqlite3_finalize(statement); return NULL; } girara_list_set_free_function(results, jumanji_db_free_result_link); while(sqlite3_step(statement) == SQLITE_ROW) { jumanji_db_result_link_t* link = malloc(sizeof(jumanji_db_result_link_t)); if (link == NULL) { sqlite3_finalize(statement); return NULL; } char* url = (char*) sqlite3_column_text(statement, 0); char* title = (char*) sqlite3_column_text(statement, 1); link->url = g_strdup(url); link->title = g_strdup(title); link->visited = sqlite3_column_int(statement, 2); girara_list_append(results, link); } sqlite3_finalize(statement); return results; }
void zathura_plugin_add_mimetype(zathura_plugin_t* plugin, const char* mime_type) { if (plugin == NULL || mime_type == NULL) { return; } girara_list_append(plugin->content_types, g_content_type_from_mime_type(mime_type)); }
void zathura_plugin_manager_add_dir(zathura_plugin_manager_t* plugin_manager, const char* dir) { if (plugin_manager == NULL || plugin_manager->path == NULL) { return; } girara_list_append(plugin_manager->path, g_strdup(dir)); }
} END_TEST START_TEST(test_datastructures_list_free_free_function) { // free function girara_list_t* list = girara_list_new(); list_free_called = 0; fail_unless((list != NULL), NULL); girara_list_set_free_function(list, list_free); girara_list_append(list, (void*) 0xDEAD); girara_list_free(list); fail_unless((list_free_called == 1), NULL); } END_TEST
} END_TEST START_TEST(test_datastructures_list_free_already_cleared) { // free cleared list girara_list_t* list = girara_list_new(); fail_unless((list != NULL), NULL); girara_list_append(list, (void*) 0xDEAD); fail_unless((girara_list_size(list) == 1), NULL); girara_list_clear(list); fail_unless((girara_list_size(list) == 0), NULL); girara_list_free(list); } END_TEST
} END_TEST START_TEST(test_datastructures_list_free_free_function_remove) { // remove with free function list_free_called = 0; girara_list_t* list = girara_list_new2(list_free); fail_unless((list != NULL), NULL); girara_list_append(list, (void*)0xDEAD); girara_list_remove(list, (void*)0xDEAD); fail_unless((girara_list_size(list) == 0), NULL); girara_list_free(list); fail_unless((list_free_called == 1), NULL); } END_TEST
} END_TEST START_TEST(test_datastructures_list_merge) { girara_list_t* list1 = girara_list_new(); girara_list_t* list2 = girara_list_new(); fail_unless((list1 != NULL), NULL); fail_unless((list2 != NULL), NULL); fail_unless((girara_list_merge(NULL, NULL) == NULL), NULL); fail_unless((girara_list_merge(list1, NULL) == list1), NULL); fail_unless((girara_list_merge(NULL, list2) == NULL), NULL); girara_list_append(list1, (void*)0); girara_list_append(list2, (void*)1); girara_list_t* list3 = girara_list_merge(list1, list2); fail_unless((list3 == list1), NULL); fail_unless((girara_list_nth(list3, 0) == (void*)0), NULL); fail_unless((girara_list_nth(list3, 1) == (void*)1), NULL); girara_list_free(list1); girara_list_free(list2); } END_TEST
bool cmd_search_engine(girara_session_t* session, girara_list_t* argument_list) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); jumanji_t* jumanji = (jumanji_t*) session->global.data; if (jumanji->global.search_engines == NULL) { return false; } if (girara_list_size(argument_list) < 2) { return false; } char* identifier = (char*) girara_list_nth(argument_list, 0); char* url = (char*) girara_list_nth(argument_list, 1); /* search for existing search engine */ if (girara_list_size(jumanji->global.search_engines) > 0) { girara_list_iterator_t* iter = girara_list_iterator(jumanji->global.search_engines); do { jumanji_search_engine_t* search_engine = (jumanji_search_engine_t*) girara_list_iterator_data(iter); if (search_engine == NULL) { continue; } if (!g_strcmp0(search_engine->identifier, identifier)) { g_free(search_engine->url); search_engine->url = g_strdup(url); return true; } } while (girara_list_iterator_next(iter)); girara_list_iterator_free(iter); } /* create new entry */ jumanji_search_engine_t* search_engine = malloc(sizeof(jumanji_search_engine_t)); if (search_engine == NULL) { return false; } search_engine->url = g_strdup(url); search_engine->identifier = g_strdup(identifier); girara_list_append(jumanji->global.search_engines, search_engine); return true; }
zathura_bookmark_t* zathura_bookmark_add(zathura_t* zathura, const gchar* id, unsigned int page) { g_return_val_if_fail(zathura && zathura->document && zathura->bookmarks.bookmarks, NULL); g_return_val_if_fail(id, NULL); double position_x = zathura_document_get_position_x(zathura->document); double position_y = zathura_document_get_position_y(zathura->document); zathura_bookmark_t* old = zathura_bookmark_get(zathura, id); if (old != NULL) { old->page = page; old->x = position_x; old->y = position_y; if (zathura->database != NULL) { const char* path = zathura_document_get_path(zathura->document); if (zathura_db_remove_bookmark(zathura->database, path, old->id) == false) { girara_warning("Failed to remove old bookmark from database."); } if (zathura_db_add_bookmark(zathura->database, path, old) == false) { girara_warning("Failed to add new bookmark to database."); } } return old; } zathura_bookmark_t* bookmark = g_try_malloc0(sizeof(zathura_bookmark_t)); if (bookmark == NULL) { return NULL; } bookmark->id = g_strdup(id); bookmark->page = page; bookmark->x = position_x; bookmark->y = position_y; girara_list_append(zathura->bookmarks.bookmarks, bookmark); if (zathura->database != NULL) { const char* path = zathura_document_get_path(zathura->document); if (zathura_db_add_bookmark(zathura->database, path, bookmark) == false) { girara_warning("Failed to add bookmark to database."); } } return bookmark; }
girara_list_t* girara_split_path_array(const char* patharray) { if (patharray == NULL || !g_strcmp0(patharray, "")) { return NULL; } girara_list_t* res = girara_list_new2(g_free); char** paths = g_strsplit(patharray, ":", 0); for (size_t i = 0; paths[i] != NULL; ++i) { girara_list_append(res, g_strdup(paths[i])); } g_strfreev(paths); return res; }
bool synctex_view(zathura_t* zathura, const char* input_file, unsigned int line, unsigned int column) { if (zathura == NULL || input_file == NULL) { return false; } const unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); unsigned int page = 0; girara_list_t* secondary_rects = NULL; girara_list_t* rectangles = synctex_rectangles_from_position( zathura_document_get_path(zathura->document), input_file, line, column, &page, &secondary_rects); if (rectangles == NULL) { return false; } girara_list_t** all_rectangles = g_try_malloc0(number_of_pages * sizeof(girara_list_t*)); if (all_rectangles == NULL) { girara_list_free(rectangles); return false; } for (unsigned int p = 0; p != number_of_pages; ++p) { if (p == page) { all_rectangles[p] = rectangles; } else { all_rectangles[p] = girara_list_new2(g_free); } } if (secondary_rects != NULL) { GIRARA_LIST_FOREACH(secondary_rects, synctex_page_rect_t*, iter, rect) zathura_rectangle_t* newrect = g_try_malloc0(sizeof(zathura_rectangle_t)); if (newrect != NULL) { *newrect = rect->rect; girara_list_append(all_rectangles[rect->page], newrect); } GIRARA_LIST_FOREACH_END(secondary_rects, synctex_page_rect_t*, iter, rect); }
static girara_list_t* read_pwd_info(void) { girara_list_t* list = girara_list_new(); girara_list_set_free_function(list, &free_pwd_info); struct passwd* pw; errno = 0; while ((pw = getpwent()) != NULL) { pwd_info_t* pwdinfo = g_malloc0(sizeof(pwd_info_t)); pwdinfo->name = g_strdup(pw->pw_name); pwdinfo->dir = g_strdup(pw->pw_dir); girara_list_append(list, pwdinfo); errno = 0; } fail_unless(errno == 0, "Non-zero errno :%d", errno, NULL); endpwent(); return list; }
void mark_add(zathura_t* zathura, int key) { if (zathura == NULL || zathura->document == NULL || zathura->global.marks == NULL) { return; } GtkScrolledWindow *window = GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view); GtkAdjustment* v_adjustment = gtk_scrolled_window_get_vadjustment(window); GtkAdjustment* h_adjustment = gtk_scrolled_window_get_hadjustment(window); if (v_adjustment == NULL || h_adjustment == NULL) { return; } double position_x = gtk_adjustment_get_value(h_adjustment); double position_y = gtk_adjustment_get_value(v_adjustment); float scale = zathura_document_get_scale(zathura->document); /* search for existing mark */ GIRARA_LIST_FOREACH(zathura->global.marks, zathura_mark_t*, iter, mark) if (mark->key == key) { mark->position_x = position_x; mark->position_y = position_y; mark->scale = scale; return; } GIRARA_LIST_FOREACH_END(zathura->global.marks, zathura_mark_t*, iter, mark); /* add new mark */ zathura_mark_t* mark = g_malloc0(sizeof(zathura_mark_t)); mark->key = key; mark->position_x = position_x; mark->position_y = position_y; mark->scale = scale; girara_list_append(zathura->global.marks, mark); }
girara_list_t* synctex_rectangles_from_position(const char* filename, const char* input_file, int line, int column, unsigned int* page, girara_list_t** secondary_rects) { if (filename == NULL || input_file == NULL || page == NULL) { return NULL; } synctex_scanner_t scanner = synctex_scanner_new_with_output_file(filename, NULL, 1); if (scanner == NULL) { girara_debug("Failed to create synctex scanner."); return NULL; } synctex_scanner_t temp = synctex_scanner_parse(scanner); if (temp == NULL) { girara_debug("Failed to parse synctex file."); synctex_scanner_free(scanner); return NULL; } girara_list_t* hitlist = girara_list_new2(g_free); girara_list_t* other_rects = girara_list_new2(g_free); if (synctex_display_query(scanner, input_file, line, column) > 0) { synctex_node_t node = NULL; bool got_page = false; while ((node = synctex_next_result (scanner)) != NULL) { const unsigned int current_page = synctex_node_page(node) - 1; if (got_page == false) { got_page = true; *page = current_page; } zathura_rectangle_t rect = { 0, 0, 0, 0 }; rect.x1 = synctex_node_box_visible_h(node); rect.y1 = synctex_node_box_visible_v(node) - synctex_node_box_visible_height(node); rect.x2 = rect.x1 + synctex_node_box_visible_width(node); rect.y2 = synctex_node_box_visible_depth(node) + synctex_node_box_visible_height (node) + rect.y1; if (*page == current_page) { zathura_rectangle_t* real_rect = g_try_malloc(sizeof(zathura_rectangle_t)); if (real_rect == NULL) { continue; } *real_rect = rect; girara_list_append(hitlist, real_rect); } else { synctex_page_rect_t* page_rect = g_try_malloc(sizeof(synctex_page_rect_t)); if (page_rect == NULL) { continue; } page_rect->page = current_page; page_rect->rect = rect; girara_list_append(other_rects, page_rect); } } } synctex_scanner_free(scanner); if (secondary_rects != NULL) { *secondary_rects = other_rects; } else { girara_list_free(other_rects); } return hitlist; }
girara_list_t* pdf_page_images_get(zathura_page_t* page, void* data, zathura_error_t* error) { mupdf_page_t* mupdf_page = data; if (page == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_INVALID_ARGUMENTS; } goto error_ret; } girara_list_t* list = NULL; zathura_document_t* document = zathura_page_get_document(page); if (document == NULL) { goto error_ret; } mupdf_document_t* mupdf_document = zathura_document_get_data(document); /* Setup image list */ list = girara_list_new(); if (list == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_OUT_OF_MEMORY; } goto error_free; } girara_list_set_free_function(list, (girara_free_function_t) pdf_zathura_image_free); /* Extract images */ mupdf_page_extract_text(mupdf_document, mupdf_page); fz_stext_block* block; for (block = mupdf_page->text->first_block; block; block = block->next) { if (block->type == FZ_STEXT_BLOCK_IMAGE) { zathura_image_t* zathura_image = g_malloc(sizeof(zathura_image_t)); zathura_image->position.x1 = block->bbox.x0; zathura_image->position.y1 = block->bbox.y0; zathura_image->position.x2 = block->bbox.x1; zathura_image->position.y2 = block->bbox.y1; zathura_image->data = block->u.i.image; girara_list_append(list, zathura_image); } } return list; error_free: if (error != NULL && *error == ZATHURA_ERROR_OK) { *error = ZATHURA_ERROR_UNKNOWN; } if (list != NULL) { girara_list_free(list); } error_ret: return NULL; }
static girara_list_t* list_files(zathura_t* zathura, const char* current_path, const char* current_file, unsigned int current_file_length, bool is_dir, bool check_file_ext) { if (zathura == NULL || zathura->ui.session == NULL || current_path == NULL) { return NULL; } /* read directory */ GDir* dir = g_dir_open(current_path, 0, NULL); if (dir == NULL) { return NULL; } girara_list_t* res = girara_sorted_list_new2((girara_compare_function_t)compare_case_insensitive, (girara_free_function_t)g_free); bool show_hidden = false; girara_setting_get(zathura->ui.session, "show-hidden", &show_hidden); bool show_directories = true; girara_setting_get(zathura->ui.session, "show-directories", &show_directories); /* read files */ char* name = NULL; while ((name = (char*) g_dir_read_name(dir)) != NULL) { char* e_name = g_filename_display_name(name); if (e_name == NULL) { goto error_free; } size_t e_length = strlen(e_name); if (show_hidden == false && e_name[0] == '.') { g_free(e_name); continue; } if ((current_file_length > e_length) || strncmp(current_file, e_name, current_file_length)) { g_free(e_name); continue; } char* tmp = "/"; if (is_dir == true || g_strcmp0(current_path, "/") == 0) { tmp = ""; }; char* full_path = g_strdup_printf("%s%s%s", current_path, tmp, e_name); if (g_file_test(full_path, G_FILE_TEST_IS_DIR) == true) { if (show_directories == false) { g_free(e_name); g_free(full_path); continue; } girara_list_append(res, full_path); } else if (check_file_ext == false || file_valid_extension(zathura, full_path) == true) { girara_list_append(res, full_path); } else { g_free(full_path); } g_free(e_name); } g_dir_close(dir); if (girara_list_size(res) == 1) { char* path = girara_list_nth(res, 0); if (g_file_test(path, G_FILE_TEST_IS_DIR) == true) { char* newpath = g_strdup_printf("%s/", path); girara_list_clear(res); girara_list_append(res, newpath); } } return res; error_free: girara_list_free(res); return NULL; }
girara_list_t* djvu_page_links_get(zathura_page_t* page, void* UNUSED(data), zathura_error_t* error) { if (page == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_INVALID_ARGUMENTS; } goto error_ret; } zathura_document_t* document = zathura_page_get_document(page); if (document == NULL) { goto error_ret; } girara_list_t* list = girara_list_new2((girara_free_function_t) zathura_link_free); if (list == NULL) { if (error != NULL) { *error = ZATHURA_ERROR_OUT_OF_MEMORY; } goto error_ret; } djvu_document_t* djvu_document = zathura_document_get_data(document); miniexp_t annotations = miniexp_nil; while ((annotations = ddjvu_document_get_pageanno(djvu_document->document, zathura_page_get_index(page))) == miniexp_dummy) { handle_messages(djvu_document, true); } if (annotations == miniexp_nil) { goto error_free; } miniexp_t* hyperlinks = ddjvu_anno_get_hyperlinks(annotations); for (miniexp_t* iter = hyperlinks; *iter != NULL; iter++) { if (miniexp_car(*iter) != miniexp_symbol("maparea")) { continue; } miniexp_t inner = miniexp_cdr(*iter); /* extract url information */ const char* target_string = NULL; if (miniexp_caar(inner) == miniexp_symbol("url")) { if (exp_to_str(miniexp_caddr(miniexp_car(inner)), &target_string) == false) { continue; } } else { if (exp_to_str(miniexp_car(inner), &target_string) == false) { continue; } } /* skip comment */ inner = miniexp_cdr(inner); /* extract link area */ inner = miniexp_cdr(inner); zathura_rectangle_t rect = { 0, 0, 0, 0 }; if (exp_to_rect(miniexp_car(inner), &rect) == false) { continue; } /* update rect */ unsigned int page_height = zathura_page_get_height(page) / ZATHURA_DJVU_SCALE; rect.x1 = rect.x1 * ZATHURA_DJVU_SCALE; rect.x2 = rect.x2 * ZATHURA_DJVU_SCALE; double tmp = rect.y1; rect.y1 = (page_height - rect.y2) * ZATHURA_DJVU_SCALE; rect.y2 = (page_height - tmp) * ZATHURA_DJVU_SCALE; /* create zathura link */ zathura_link_type_t type = ZATHURA_LINK_INVALID; zathura_link_target_t target = { ZATHURA_LINK_DESTINATION_UNKNOWN, NULL, 0, -1, -1, -1, -1, 0 };; /* goto page */ if (target_string[0] == '#' && target_string[1] == 'p') { type = ZATHURA_LINK_GOTO_DEST; target.page_number = atoi(target_string + 2) - 1; /* url or other? */ } else if (strstr(target_string, "//") != NULL) { type = ZATHURA_LINK_URI; target.value = (char*) target_string; /* TODO: Parse all different links */ } else { continue; } zathura_link_t* link = zathura_link_new(type, rect, target); if (link != NULL) { girara_list_append(list, link); } } return list; error_free: if (list != NULL) { girara_list_free(list); } error_ret: return NULL; }
bool cmd_proxy(girara_session_t* session, girara_list_t* argument_list) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); jumanji_t* jumanji = (jumanji_t*) session->global.data; if (jumanji->global.proxies == NULL) { return false; } unsigned int number_of_arguments = girara_list_size(argument_list); if (number_of_arguments < 1) { return false; } char* url = (char*) girara_list_nth(argument_list, 0); char* description = (number_of_arguments > 1) ? (char*) girara_list_nth(argument_list, 1) : NULL; if (url == NULL) { return false; } url = (strstr(url, "://") != NULL) ? g_strdup(url) : g_strconcat("http://", url, NULL); /* search for existing proxy */ if (girara_list_size(jumanji->global.proxies) > 0) { girara_list_iterator_t* iter = girara_list_iterator(jumanji->global.proxies); do { jumanji_proxy_t* proxy = (jumanji_proxy_t*) girara_list_iterator_data(iter); if (proxy == NULL) { continue; } if (!g_strcmp0(proxy->url, url)) { g_free(proxy->url); g_free(proxy->description); proxy->url = g_strdup(url); proxy->description = description ? g_strdup(description) : NULL; g_free(url); girara_list_iterator_free(iter); return true; } } while (girara_list_iterator_next(iter)); girara_list_iterator_free(iter); } /* create new entry */ jumanji_proxy_t* proxy = malloc(sizeof(jumanji_proxy_t)); if (proxy == NULL) { g_free(url); return false; } proxy->url = url; proxy->description = description != NULL ? g_strdup(description) : NULL; girara_list_append(jumanji->global.proxies, proxy); return true; }