Esempio n. 1
0
static void
pidgin_smiley_themes_remove_non_existing(void)
{
	static struct smiley_theme *theme = NULL;
	GSList *iter = NULL;

	if (!smiley_themes) return ;

	for (iter = smiley_themes ; iter ; iter = iter->next) {
		theme = ((struct smiley_theme *)(iter->data));
		if (!g_file_test(theme->path, G_FILE_TEST_EXISTS)) {
			if (theme == current_smiley_theme)
				current_smiley_theme = ((struct smiley_theme *)(NULL == iter->next ? NULL : iter->next->data));
			pidgin_themes_destroy_smiley_theme(theme);
			iter->data = NULL;
		}
	}
	/* Remove all elements whose data is NULL */
	smiley_themes = g_slist_remove_all(smiley_themes, NULL);

	if (!current_smiley_theme && smiley_themes) {
		struct smiley_theme *smile = g_slist_last(smiley_themes)->data;
		pidgin_themes_load_smiley_theme(smile->path, TRUE);
	}
}
Esempio n. 2
0
/**
 * Drop a client from the ::pre_client_list.
 */
gboolean remove_socket_from_pre_client_list(int socket)
{
    GSList *client_runner = NULL;
    g_static_mutex_lock(&pre_client_list_mutex);
    for (client_runner = pre_client_list; client_runner;
            client_runner = client_runner->next) {
        /* if entry older than delay then close socket */
        if (client_runner->data) {
            if (((struct pre_client_elt *) (client_runner->
                                            data))->socket ==
                    socket) {
                g_free(client_runner->data);
                client_runner->data = NULL;
                pre_client_list =
                    g_slist_remove_all(pre_client_list,
                                       NULL);
                g_static_mutex_unlock
                (&pre_client_list_mutex);
                return TRUE;
            }
        }
    }
    g_static_mutex_unlock(&pre_client_list_mutex);
    return FALSE;
}
Esempio n. 3
0
static void 
plugins_remove_all(GList *gl) 
{
    if (ALLOWED(gl) != NULL) 
    {
        ALLOWED(gl) = g_slist_remove_all(ALLOWED(gl), ALLOWED(gl)->data);
        ALLOWED(gl) = NULL;
    }
    View *v = VIEW(gl);
    v->plugins->created = 0;
}
void removeDuplicates(void) {

  GSList* list = NULL;
  list = g_slist_append(list, "first");
  list = g_slist_append(list, "second");
  list = g_slist_append(list, "second");
  list = g_slist_append(list, "third");
  list = g_slist_append(list, "third");
  g_printf("The list is now %d items long\n", g_slist_length(list));
  list = g_slist_remove(list, "second");
  list = g_slist_remove_all(list, "third");
  g_printf("The list is now %d items long\n", g_slist_length(list));
  g_slist_free(list);

}
Esempio n. 5
0
/**
 * Check pre client list to disconnect connections
 * that have been open for too long
 */
void* pre_client_check(GMutex *mutex)
{
    GSList *client_runner = NULL;
    time_t current_timestamp;

    while (g_mutex_trylock(mutex)) {
        g_mutex_unlock(mutex);

        current_timestamp = time(NULL);

        /* lock client list */
        g_static_mutex_lock(&pre_client_list_mutex);
        /* iter on pre_client_list */
        for (client_runner = pre_client_list; client_runner;
                client_runner = client_runner->next) {
            /* if entry older than delay then close socket */
            if (client_runner->data) {
                if (((struct pre_client_elt
                        *) (client_runner->data))->validity <
                        current_timestamp) {
                    log_message(INFO, DEBUG_AREA_USER,
                                "closing socket %d due to timeout",
                                ((struct pre_client_elt
                                  *) (client_runner->
                                      data))->socket);
                    shutdown(((struct pre_client_elt
                               *) (client_runner->
                                   data))->socket,
                             SHUT_RDWR);
                    close(((struct pre_client_elt
                            *) (client_runner->data))->
                          socket);
                    g_free(client_runner->data);
                    client_runner->data = NULL;
                }
            }
        }
        pre_client_list =
            g_slist_remove_all(pre_client_list, NULL);
        /* unlock client list */
        g_static_mutex_unlock(&pre_client_list_mutex);
        /* sleep */
        sleep(1);
    }
    return NULL;
}
Esempio n. 6
0
static void
property_index_modify_string (HalDeviceStore *store, HalDevice *device,
			      const char *key, gboolean added)
{
	GHashTable *index;
	const char *value;
	GSList *devices;

	value = hal_device_property_get_string (device, key);
	index = g_hash_table_lookup (store->property_index, key);

	if (!index) return;

	devices = g_hash_table_lookup (index, value);

	if (added) { /*add*/
		HAL_DEBUG (("adding %p to (%s,%s)", device, key, value));
		devices = g_slist_prepend (devices, device);
	} else { /*remove*/
		HAL_DEBUG (("removing %p from (%s,%s)", device, key, value));
		devices = g_slist_remove_all (devices, device);
	}
	g_hash_table_insert (index, (gpointer) value, devices);
}
Esempio n. 7
0
// Tests for slist
void tg_slist_tests()
{
	GSList *slist,*st,*rem;
	gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	gint chk_buf[20];
	gint i;
	gint g_slist_insert_data;
	gint g_slist_insert_before_data;
	gint ip1 = 10;
	gint ip2 = 15;
	gint ip3 = 5;
	gint ip4 = 12;
	gint g_slist_nth_data_op,g_slist_find_custom_op;
	
	//Trying to use the allocators so that even they get tested!
	GAllocator* alloc = g_allocator_new ("alloc_slist",5000);
	g_slist_push_allocator (alloc);
	
	
	slist = NULL;
	for (i = 0; i < 10; i++)
		slist = g_slist_append (slist, &nums[i]);
	
	//List looks like:
	// 0   1   2   3   4   5   6   7   8   9
	
	//Test for g_slist_insert....inserted 10 at pos 4
	g_slist_insert(slist,&ip1,4);
	st = g_slist_nth (slist,0);
	for(i = 0;i < 4;i++)
		st = st->next;
	g_slist_insert_data = *((gint*) st->data);
	g_assert(g_slist_insert_data == 10);
	
/*	for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      chk_buf[i] = *((gint*) st->data);
    }*/
    
	//List looks like:
	// 0   1   2   3   10   4   5   6   7   8   9
	
	//Test for g_slist_insert_before....inserted 15 at pos 7
	st = g_slist_nth (slist,7);
	g_slist_insert_before(slist,st,&ip2);
	st = g_slist_nth (slist,0);
	for(i = 0;i < 7;i++)
		st = st->next;
	g_slist_insert_before_data = *((gint*) st->data);
	g_assert(g_slist_insert_before_data == 15);
	
	//List looks like:
	// 0   1   2   3   10   4   5   15   6   7   8   9
	
	//Test for g_slist_index....finding 15 at pos 7
	st = g_slist_nth (slist,0);
	g_assert(g_slist_index(st,&ip2)==7);

	//Test for g_slist_nth_data....getting 6 at position 8
	g_slist_nth_data_op = *((gint*) g_slist_nth_data(slist,8));
	g_assert(g_slist_nth_data_op == 6)	;

	//Test for g_slist_position
	st = g_slist_nth (slist,7);
	g_assert(g_slist_position (slist,st) == 7);

	//Test for g_slist_find_custom
	st = g_slist_find_custom(slist,&ip3,compare_fun_gr);
	g_slist_find_custom_op = *((gint*) st->data);
	g_assert(g_slist_find_custom_op == 5);
	
	//Test for g_slist_sort_with_data
	st = g_slist_sort_with_data(slist,compare_fun_gr_data,&ip3);
	for (i = 0; i < 10; i++)
    {
      st = g_slist_nth (slist, i);
      g_assert (*((gint*) st->data) == i);
    }

	//List looks like:
	// 0   1   2   3   4   5   6   7   8   9   10   15
	
	//Test for g_slist_remove_link
	st = g_slist_nth (slist, 5);
	rem = g_slist_remove_link(slist , st);
	st = g_slist_nth (slist, 5);
    g_assert (*((gint*) st->data) == 6);

	//List looks like:
	// 0   1   2   3   4   6   7   8   9   10   15

	//Test for g_slist_remove_all
	g_slist_insert(slist,&ip4,4);
	g_slist_insert(slist,&ip4,6);
	g_slist_insert(slist,&ip4,8);
	//List looks like:
	// 0   1   2   3   4   12   6   7   12   8   12   9   10   15
	g_slist_remove_all(slist ,&ip4);
    
	g_slist_free (slist);
	g_slist_pop_allocator ();
}