int CassandraFS::unlink(const char* path) {
    struct stat stat;
    struct cfs_attrs cfs_attrs;
    int attr_err = getattr(path, &stat, &cfs_attrs);

    if (attr_err) {
        return attr_err;
    }
    
    CassandraFutureSpool *spool = new CassandraFutureSpool(4);

    spool->append(remove_entry(path));
    spool->append(remove_sub_entry(path));
    spool->append(remove_sub_entries(path));
    
    if (!S_ISDIR(stat.st_mode)) {
        remove_physical_file(&stat, &cfs_attrs, spool);
    }

    spool->wait_all();
    int errors = spool->get_errors();
    delete spool;
    
    if (errors > 0) {
        return -EIO;
    }
    
    return 0;
}

static void
remove_entry(IsStore *self,
	     IsStoreEntry *entry)
{
	IsStorePrivate *priv;
	GtkTreeIter iter;
	GtkTreePath *path;
	GSequenceIter *parent_iter;

	priv = self->priv;

	parent_iter = entry->parent;
	iter.stamp = priv->stamp;
	iter.user_data = entry->iter;
	path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &iter);
	g_sequence_remove(entry->iter);
	gtk_tree_model_row_deleted(GTK_TREE_MODEL(self), path);
	gtk_tree_path_free(path);

	/* remove parent if it has no children now */
	if (parent_iter) {
		IsStoreEntry *parent = g_sequence_get(parent_iter);
		if (g_sequence_get_length(parent->entries) == 0) {
			remove_entry(self, parent);
		}
	}
}

void econ_change_items(dbref d, int id, int brand, int num)
{
	char *t, *u;
	int base = 0, i1, i2, i3;

	if(!Good_obj(d))
		return;
	if(brand)
		if(get_parts_short_name(id, brand) == get_parts_short_name(id, 0))
			brand = 0;
	t = silly_atr_get(d, A_ECONPARTS);
	if((u = find_entry(t, id, brand))) {
		if(sscanf(u, "[%d,%d,%d]", &i1, &i2, &i3) == 3)
			base += i3;
		remove_entry(t, u);
	}
	base += num;
	if(base <= 0) {
		if(u)
			silly_atr_set(d, A_ECONPARTS, t);
		return;
	}
	if(!(IsActuator(id)))
		add_entry(t, tprintf("%d,%d,%d", id, brand, base));
	silly_atr_set(d, A_ECONPARTS, t);
	if(IsActuator(id))
		econ_change_items(d, Cargo(S_ACTUATOR), brand, base);
	/* Successfully changed */
}

int main(void) {
    struct entry e1, e2, e3, e4;
    struct entry first_entry;
    struct entry *list = &first_entry;

    first_entry.next = &e1;
    e1.value = 1;
    e1.next = &e2;
    e2.value = 2;
    e2.next = &e3;
    e3.value = 3;
    e3.next = &e4;
    e4.value = 4;
    e4.next = (struct entry *)0;

    remove_entry(&e3);

    list = list->next;
    while (list != (struct entry *)0) {
        printf("%i\n", list->value);
        list = list->next;
    }

    return 0;
}

void core_options::add_entries(const options_entry *entrylist, bool override_existing)
{
	// loop over entries until we hit a NULL name
	for ( ; entrylist->name != NULL || (entrylist->flags & OPTION_HEADER) != 0; entrylist++)
	{
		// allocate a new entry
		entry *newentry = new entry(*entrylist);
		if (newentry->name() != NULL)
		{
			// see if we match an existing entry
			entry *existing = m_entrymap.find(newentry->name());
			if (existing != NULL)
			{
				// if we're overriding existing entries, then remove the old one
				if (override_existing)
				{
					core_options::entry *e = m_entrylist;
					remove_entry(*existing);
					delete e;
				}

				// otherwise, just override the default and current values and throw out the new entry
				else
				{
					existing->set_default_value(newentry->value());
					delete newentry;
					continue;
				}
			}
		}

		// add us to the list and maps
		append_entry(*newentry);
	}
}

int main(int argc, char **argv) 
{
	CLIENT client_struct, *c;
        FLICK_SERVER_LOCATION s;
	int sel, done;
	
	c = &client_struct;
	
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <host>\n", argv[0]);
		exit(1);
	}
	
	s.server_name = argv[1];
	s.prog_num = netphone;
	s.vers_num = firstphone;
	create_client(c, s);
	
	done = 0;
	while (!done) {
		read_integer(("\n(1) Add an entry (2) Remove an entry "
			      "(3) Find a phone number (4) Exit: "),
			     &sel);
		switch(sel) {
		case 1:  add_entry(c); break;
		case 2:  remove_entry(c); break;
		case 3:  find_entry(c); break;
		case 4:  done = 1; break;
		default: printf("Please enter 1, 2, 3, or 4.\n");
		}
	}
	return 0;
}

int ghostfs_rename(struct ghostfs *gfs, const char *path, const char *newpath)
{
	struct dir_iter it;
	struct dir_entry *entry;
	int ret;

	ret = dir_iter_lookup(gfs, &it, path, false);
	if (ret < 0)
		return ret;

	if (it.entry == &gfs->root_entry)
		return -EINVAL;

	remove_entry(gfs, newpath, false);

	ret = create_entry(gfs, newpath, false, &entry);
	if (ret < 0)
		return ret;

	// remove old entry
	it.entry->filename[0] = '\0';
	cluster_set_dirty(it.cluster, true);

	// fix new entry
	entry->size = it.entry->size;
	entry->cluster = it.entry->cluster;

	return 0;
}

static void elapse_func(AvahiTimeEvent *t, void *userdata) {
    AvahiCacheEntry *e = userdata;
/*     char *txt; */
    unsigned percent = 0;

    assert(t);
    assert(e);

/*     txt = avahi_record_to_string(e->record); */

    switch (e->state) {

        case AVAHI_CACHE_EXPIRY_FINAL:
        case AVAHI_CACHE_POOF_FINAL:
        case AVAHI_CACHE_GOODBYE_FINAL:
        case AVAHI_CACHE_REPLACE_FINAL:

            remove_entry(e->cache, e);

            e = NULL;
/*         avahi_log_debug("Removing entry from cache due to expiration (%s)", txt); */
            break;

        case AVAHI_CACHE_VALID:
        case AVAHI_CACHE_POOF:
            e->state = AVAHI_CACHE_EXPIRY1;
            percent = 85;
            break;

        case AVAHI_CACHE_EXPIRY1:
            e->state = AVAHI_CACHE_EXPIRY2;
            percent = 90;
            break;
        case AVAHI_CACHE_EXPIRY2:
            e->state = AVAHI_CACHE_EXPIRY3;
            percent = 95;
            break;

        case AVAHI_CACHE_EXPIRY3:
            e->state = AVAHI_CACHE_EXPIRY_FINAL;
            percent = 100;
            break;
    }

    if (e) {

        assert(percent > 0);

        /* Request a cache update if we are subscribed to this entry */
        if (avahi_querier_shall_refresh_cache(e->cache->interface, e->record->key))
            avahi_interface_post_query(e->cache->interface, e->record->key, 0, NULL);

        /* Check again later */
        next_expiry(e->cache, e, percent);

    }

/*     avahi_free(txt); */
}

void core_options::reset()
{
	// remove all entries from the list
	while (m_entrylist != NULL)
		remove_entry(*m_entrylist);

	// reset the map
	m_entrymap.reset();
}

/**
 * Tries to delete a person.
 */
void del(void)
{
    int i, num_del;
    if (num_list > 1)
    {
        // ask how many entry that user want to delete
        printf("How many entry do you want to delete? Choose 1~%i: ", num_list);
        scanf("%i", &num_del);
        for (i = 0; i < num_del - 1; i++)
        {
            remove_entry(); // delete (wanted number - 1) entries
        }
    }
    remove_entry(); // delete once more

    // print_list list
    print_list();
}

EXP_FUNC void STDCALL ax_free(void *y, const char* f, const int l)
{
    if(enable)  
        printf("free\t");
        
    remove_entry(y, f, l);
    print_buf_stats();
    free(y);
}

/*Test4 tests inserting a large number of keys, chekcing key_count, deleting a few, rechecking the
key_count, then clearing the entire table. We will then reinsert some keys.*/
static int test4(){
   int x = 1, y =2, z = 3, w =4, k = 5, a =6, b =7
   , c =8, d = 9, e = 10, f = 11, g = 12;
   Table *t;

   /*Creates table and adds 13 keys to it.*/
   create_table(&t, z, NULL);
   put(t, "Krabs", &a);
   put(t, "Larry", &b);
   put(t, "Herminator", &c);
   put(t, "Brian", &d);
   put(t, "Steve", &e);
   put(t, "Nelson", &f);
   put(t, "Corwin", &g);
   put(t, "Spongebob", &x);
   put(t, "Patrick", &y);
   put(t, "Squidward", &z);
   put(t, "Sandy", &w);
   put(t, "Art thou feeling it now,", NULL);
   put(t, "Mr. Krabs?", &k);
   printf("%d\n", get_key_count(t));
   display_table(t);
   /*Removes two keys from the table, then rechekcs key_count and
   displays the state of the table.*/
   remove_entry(t,"Mr. Krabs?");
   remove_entry(t,"Art thou feeling it now,");
   printf("%d\n", get_key_count(t));
   display_table(t);

   /*Clears the table, then rechecks the key_count.*/
   clear_table(t);
   printf("%d\n", get_key_count(t));
   /*Reinserts 7 keys, then checks the state of the table again.*/
   put(t, "A1", &a);
   put(t, "A2", &b);
   put(t, "A3", &c);
   put(t, "A4", &d);
   put(t, "A5", &e);
   put(t, "A6", &f);
   put(t, "A7", &g);
   display_table(t);
   destroy_table(t);
   return SUCCESS;
}

static bool create_two_story_trie(void)
{
	bool success = true;

	success &= add_entry("1.0.0.0", 32, "1::00", 120);
	success &= add_entry("2.0.0.0", 32, "1::10", 124);
	success &= add_entry("3.0.0.0", 32, "1::20", 124);

	success &= remove_entry(NULL, 0, "1::", 128, -ESRCH);
	success &= remove_entry(NULL, 0, "1::", 121, -ESRCH);
	success &= remove_entry(NULL, 0, "1::", 119, -ESRCH);
	success &= remove_entry(NULL, 0, "0::", 0, -ESRCH);

	success &= test("1.0.0.0", "1::00");
	success &= test("2.0.0.0", "1::10");
	success &= test("3.0.0.0", "1::20");

	return success;
}

core_options::~core_options()
{
	// delete all entries from the list
	while (m_entrylist != NULL)
	{
		core_options::entry *e = m_entrylist;
		remove_entry(*m_entrylist);
		delete e;
	}
}

    ReturnCode RamFileSystem::remove_entry(uint32_t entry_id)
    {
        if (entry_id == NULL_ID)
        {
            return NULL_PARAMETER;
        }

        // Cannot remove root
        if (entry_id == 1)
        {
            return WRONG_ENTRY_TYPE;
        }

        auto find = _entry_index.find(entry_id);
        if (find == _entry_index.end())
        {
            return ENTRY_NOT_FOUND;
        }

        auto type = find->second->metadata().type();

        if (type == FOLDER_ENTRY)
        {
            auto folder = dynamic_cast<Folder *>(find->second.get());
            if (folder != nullptr)
            {
                if (folder->size() > 0)
                {
                    return FOLDER_NOT_EMPTY;
                }
            }
        }

        auto parent_find = _entry_index.find(find->second->parent_folder_id());
        if (parent_find == _entry_index.end())
        {
            // Parent not found?
            return ENTRY_NOT_FOUND;
        }

        auto parent_folder = dynamic_cast<Folder *>(parent_find->second.get());
        if (parent_folder == nullptr)
        {
            // Parent wrong entry type?
            return WRONG_ENTRY_TYPE;
        }

        auto result = parent_folder->remove_entry(entry_id);
        if (result == SUCCESS)
        {
            _entry_index.erase(find);
        }

        return result;
    }

//-------------------------------------------------------------------------
// Delete a crate from the crate db
//-------------------------------------------------------------------------
int DelCrate()
{
	char	crateName[CRATE_NAME_SIZE + 1];
	int		index, numOfEntries;
	int		status = SUCCESS;

	static DESCRIPTOR( phy_name_p, "PHY_NAME" );
	static DYNAMIC_DESCRIPTOR( phy_name );

	// get user input
	str_free1_dx(&phy_name);				// per twf -- clear out field
	cli_get_value( &phy_name_p, &phy_name );
	str_upcase( &phy_name, &phy_name );
	// trim it...
	sprintf(crateName, "%.6s", phy_name.pointer);

	// check to see if db file memory mapped
	if( CRATEdbFileIsMapped == FALSE ) {			// is not, so try
		if( map_data_file(CRATE_DB) != SUCCESS ) {	// we're dead in the water
			status = FAILURE;		// MAP_ERROR;		[2001.07.12]
			goto DelCrate_Exit;
		}
	}

	// get number of current entries
	if( (numOfEntries = get_file_count(CRATE_DB)) == 0 ) {	// no entries in crate db file
		if( MSGLVL(IMPORTANT) )
			fprintf( stderr, "db file empty, no entries to remove\n" );

		status = FAILURE;		// DELCRATE_ERROR;		[2001.07.12]
		goto DelCrate_Exit;
	}

	// try to remove from crate.db
	if( (index = lookup_entry(CRATE_DB, crateName)) >= 0 ) {	// module does exist
		if( remove_entry(CRATE_DB, index) != SUCCESS ) {		// removal failed
			status = FAILURE;		// DELCRATE_ERROR;		[2001.07.12]
			goto DelCrate_Exit;
		}
	}
	else {		// no such module
		if( MSGLVL(IMPORTANT) )
			fprintf( stderr, "delcrate(): entry '%s' not found\n", crateName);

		status = FAILURE;		// DELCRATE_ERROR;		[2001.07.12]
		goto DelCrate_Exit;
	}

DelCrate_Exit:
	if( MSGLVL(DETAILS) ) {
		printf("DelCrate() status = %d\n", status);
	}

	return SUCCESS;
}

void CPjTimerEntry::DoCancel() 
{
    /* It's possible that _timer_id is -1, see schedule(). In this case,
     * the entry has not been added to the timer heap, so don't remove
     * it.
     */
    if (entry_ && entry_->_timer_id != -1)
	remove_entry(timer_heap_, this);
    
    rtimer_.Cancel();
}

int main(int argc, char **argv) {
	if (argc!=2) {
		fprintf(stderr,"usage : syr1_rm nom\n");
		return -1;
	}
	int res = remove_entry(argv[1]);
	if (res< 0) {
		fprintf(stderr,"Error %d during syr1_rm\n",res);
	}
	return 0;
}

    ReturnCode RamFileSystem::rename(uint32_t folder_id, const std::string &name, uint32_t new_parent_id, const std::string &new_name)
    {
        if (name.size() == 0u || new_parent_id == NULL_ID || new_name.size() == 0u)
        {
            return NULL_PARAMETER;
        }

        // We did it!
        if (folder_id == new_parent_id && name == new_name)
        {
            return SUCCESS;
        }

        auto find = _entry_index.find(folder_id);
        if (find == _entry_index.end())
        {
            return ENTRY_NOT_FOUND;
        }
        auto current_parent = find->second.get();
        if (current_parent->metadata().type() != FOLDER_ENTRY)
        {
            return WRONG_ENTRY_TYPE;
        }

        find = _entry_index.find(new_parent_id);
        if (find == _entry_index.end())
        {
            return ENTRY_NOT_FOUND;
        }
        auto new_parent = find->second.get();
        if (new_parent->metadata().type() != FOLDER_ENTRY)
        {
            return WRONG_ENTRY_TYPE;
        }

        auto current_parent_folder = dynamic_cast<Folder *>(current_parent);
        auto new_parent_folder = dynamic_cast<Folder *>(new_parent);

        Entry *to_move = nullptr;
        auto move_find = current_parent_folder->find_entry(name, &to_move);
        if (move_find != SUCCESS)
        {
            return move_find;
        }

        auto move_result = new_parent_folder->add_entry(new_name, to_move);
        if (move_result != SUCCESS)
        {
            return move_result;
        }
        current_parent_folder->remove_entry(name);

        return SUCCESS;
    }

void avahi_cache_free(AvahiCache *c) {
    assert(c);

    while (c->entries)
        remove_entry(c, c->entries);
    assert(c->n_entries == 0);

    avahi_hashmap_free(c->hashmap);

    avahi_free(c);
}