/* This file is autogenerated using tools/make-loadsave.pl, DO NOT EDIT! */
/* # cat src/structs.h | tools/make-loadsave.pl > src/loadsave-autogen.c */

static hashtype_t load_hashtype_t(const char *p);
static interfacemode_t load_interfacemode_t(const char *p);
static interfacetype_t load_interfacetype_t(const char *p);
static listtype_t load_listtype_t(const char *p);
static pformat_t load_pformat_t(const char *p);
static responsetype_t load_responsetype_t(const char *p);
static sorttype_t load_sorttype_t(const char *p);
static void add_field_hashtype_t(section_t *section, const char *name, hashtype_t p);
static void add_field_interfacemode_t(section_t *section, const char *name, interfacemode_t p);
static void add_field_interfacetype_t(section_t *section, const char *name, interfacetype_t p);
static void add_field_listtype_t(section_t *section, const char *name, listtype_t p);
static void add_field_pformat_t(section_t *section, const char *name, pformat_t p);
static void add_field_responsetype_t(section_t *section, const char *name, responsetype_t p);
static void add_field_sorttype_t(section_t *section, const char *name, sorttype_t p);
static void deinit_access_entry_t(section_t *section);
static void deinit_access_t(section_t *section);
static void deinit_channel_t(section_t *section);
static void deinit_global_t(section_t *section);
static void deinit_ignore_entry_t(section_t *section);
static void deinit_ignore_list_t(section_t *section);
static void deinit_interface_t(section_t *section);
static void deinit_netset_t(section_t *section);
static void deinit_network_t(section_t *section);
static void deinit_pack_t(section_t *section);
static void deinit_packlist_t(section_t *section);
static void deinit_pool_t(section_t *section);
static void deinit_queue_t(section_t *section);
static void deinit_send_t(section_t *section);
static void deinit_settings_t(section_t *section);
static void deinit_user_t(section_t *section);
static void init_access_entry_t(section_t *section);
static void init_access_t(section_t *section);
static void init_channel_t(section_t *section);
static void init_global_t(section_t *section);
static void init_ignore_entry_t(section_t *section);
static void init_ignore_list_t(section_t *section);
static void init_interface_t(section_t *section);
static void init_netset_t(section_t *section);
static void init_network_t(section_t *section);
static void init_pack_t(section_t *section);
static void init_packlist_t(section_t *section);
static void init_pool_t(section_t *section);
static void init_queue_t(section_t *section);
static void init_send_t(section_t *section);
static void init_settings_t(section_t *section);
static void init_user_t(section_t *section);
static void load_access_entry_t(section_t *section);
static void load_access_t(section_t *section);
static void load_channel_t(section_t *section);
static void load_global_t(section_t *section);
static void load_ignore_entry_t(section_t *section);
static void load_ignore_list_t(section_t *section);
static void load_interface_t(section_t *section);
static void load_netset_t(section_t *section);
static void load_network_t(section_t *section);
static void load_pack_t(section_t *section);
static void load_packlist_t(section_t *section);
static void load_pool_t(section_t *section);
static void load_queue_t(section_t *section);
static void load_send_t(section_t *section);
static void load_settings_t(section_t *section);
static void load_user_t(section_t *section);
static void ref_count_pack_t(section_t *section);
static void save_access_entry_t(config_t *config, access_entry_t *p);
static void save_access_t(config_t *config, access_t *p);
static void save_channel_t(config_t *config, channel_t *p);
static void save_global_t(config_t *config, global_t *p);
static void save_ignore_entry_t(config_t *config, ignore_entry_t *p);
static void save_ignore_list_t(config_t *config, ignore_list_t *p);
static void save_interface_t(config_t *config, interface_t *p);
static void save_netset_t(config_t *config, netset_t *p);
static void save_network_t(config_t *config, network_t *p);
static void save_pack_t(config_t *config, pack_t *p);
static void save_packlist_t(config_t *config, packlist_t *p);
static void save_pool_t(config_t *config, pool_t *p);
static void save_queue_t(config_t *config, queue_t *p);
static void save_send_t(config_t *config, send_t *p);
static void save_settings_t(config_t *config, settings_t *p);
static void save_user_t(config_t *config, user_t *p);



static hashtype_t load_hashtype_t(const char *p) {
	if(strcmp(p,"HASH_MD5") == 0) return HASH_MD5;
	if(strcmp(p,"HASH_CRC_AND_MD5") == 0) return HASH_CRC_AND_MD5;
	if(strcmp(p,"HASH_CRC") == 0) return HASH_CRC;
	if(strcmp(p,"HASH_NONE") == 0) return HASH_NONE;
	return 0;
}


static void add_field_hashtype_t(section_t *section, const char *name, hashtype_t p) {
	switch(p) {
		case HASH_MD5:
			add_field(section,name,"HASH_MD5");
			break;
		case HASH_CRC_AND_MD5:
			add_field(section,name,"HASH_CRC_AND_MD5");
			break;
		case HASH_CRC:
			add_field(section,name,"HASH_CRC");
			break;
		case HASH_NONE:
			add_field(section,name,"HASH_NONE");
			break;
		default:
			break;
	}
}


static responsetype_t load_responsetype_t(const char *p) {
	if(strcmp(p,"RESPONSE_PRIVMSG") == 0) return RESPONSE_PRIVMSG;
	if(strcmp(p,"RESPONSE_NOTICE") == 0) return RESPONSE_NOTICE;
	return 0;
}


static void add_field_responsetype_t(section_t *section, const char *name, responsetype_t p) {
	switch(p) {
		case RESPONSE_PRIVMSG:
			add_field(section,name,"RESPONSE_PRIVMSG");
			break;
		case RESPONSE_NOTICE:
			add_field(section,name,"RESPONSE_NOTICE");
			break;
		default:
			break;
	}
}


static sorttype_t load_sorttype_t(const char *p) {
	if(strcmp(p,"SORT_I_AZ") == 0) return SORT_I_AZ;
	if(strcmp(p,"SORT_ZA") == 0) return SORT_ZA;
	if(strcmp(p,"SORT_AZ") == 0) return SORT_AZ;
	if(strcmp(p,"SORT_NONE") == 0) return SORT_NONE;
	if(strcmp(p,"SORT_I_ZA") == 0) return SORT_I_ZA;
	return 0;
}


static void add_field_sorttype_t(section_t *section, const char *name, sorttype_t p) {
	switch(p) {
		case SORT_I_AZ:
			add_field(section,name,"SORT_I_AZ");
			break;
		case SORT_ZA:
			add_field(section,name,"SORT_ZA");
			break;
		case SORT_AZ:
			add_field(section,name,"SORT_AZ");
			break;
		case SORT_NONE:
			add_field(section,name,"SORT_NONE");
			break;
		case SORT_I_ZA:
			add_field(section,name,"SORT_I_ZA");
			break;
		default:
			break;
	}
}


static pformat_t load_pformat_t(const char *p) {
	if(strcmp(p,"PFORMAT_SUMMARY") == 0) return PFORMAT_SUMMARY;
	if(strcmp(p,"PFORMAT_FULL") == 0) return PFORMAT_FULL;
	if(strcmp(p,"PFORMAT_MINIMAL") == 0) return PFORMAT_MINIMAL;
	if(strcmp(p,"PFORMAT_TAGONLY") == 0) return PFORMAT_TAGONLY;
	return 0;
}


static void add_field_pformat_t(section_t *section, const char *name, pformat_t p) {
	switch(p) {
		case PFORMAT_SUMMARY:
			add_field(section,name,"PFORMAT_SUMMARY");
			break;
		case PFORMAT_FULL:
			add_field(section,name,"PFORMAT_FULL");
			break;
		case PFORMAT_MINIMAL:
			add_field(section,name,"PFORMAT_MINIMAL");
			break;
		case PFORMAT_TAGONLY:
			add_field(section,name,"PFORMAT_TAGONLY");
			break;
		default:
			break;
	}
}


static interfacetype_t load_interfacetype_t(const char *p) {
	if(strcmp(p,"INTERFACE_CHAT") == 0) return INTERFACE_CHAT;
	if(strcmp(p,"INTERFACE_SEND") == 0) return INTERFACE_SEND;
	if(strcmp(p,"INTERFACE_RECV") == 0) return INTERFACE_RECV;
	return 0;
}


static void add_field_interfacetype_t(section_t *section, const char *name, interfacetype_t p) {
	switch(p) {
		case INTERFACE_CHAT:
			add_field(section,name,"INTERFACE_CHAT");
			break;
		case INTERFACE_SEND:
			add_field(section,name,"INTERFACE_SEND");
			break;
		case INTERFACE_RECV:
			add_field(section,name,"INTERFACE_RECV");
			break;
		default:
			break;
	}
}


static interfacemode_t load_interfacemode_t(const char *p) {
	if(strcmp(p,"IMODE_NORMAL") == 0) return IMODE_NORMAL;
	if(strcmp(p,"IMODE_REVERSE") == 0) return IMODE_REVERSE;
	if(strcmp(p,"IMODE_DCCSERVER") == 0) return IMODE_DCCSERVER;
	return 0;
}


static void add_field_interfacemode_t(section_t *section, const char *name, interfacemode_t p) {
	switch(p) {
		case IMODE_NORMAL:
			add_field(section,name,"IMODE_NORMAL");
			break;
		case IMODE_REVERSE:
			add_field(section,name,"IMODE_REVERSE");
			break;
		case IMODE_DCCSERVER:
			add_field(section,name,"IMODE_DCCSERVER");
			break;
		default:
			break;
	}
}


static listtype_t load_listtype_t(const char *p) {
	if(strcmp(p,"LIST_TAGONLY") == 0) return LIST_TAGONLY;
	if(strcmp(p,"LIST_CHAT") == 0) return LIST_CHAT;
	if(strcmp(p,"LIST_NORMAL") == 0) return LIST_NORMAL;
	if(strcmp(p,"LIST_NOPACKS") == 0) return LIST_NOPACKS;
	return 0;
}


static void add_field_listtype_t(section_t *section, const char *name, listtype_t p) {
	switch(p) {
		case LIST_TAGONLY:
			add_field(section,name,"LIST_TAGONLY");
			break;
		case LIST_CHAT:
			add_field(section,name,"LIST_CHAT");
			break;
		case LIST_NORMAL:
			add_field(section,name,"LIST_NORMAL");
			break;
		case LIST_NOPACKS:
			add_field(section,name,"LIST_NOPACKS");
			break;
		default:
			break;
	}
}



static void init_ignore_entry_t(section_t *section) {
	section->ptr = alloc_ignore_entry();
}

static void deinit_ignore_entry_t(section_t *section) {
	if(section->ptr != NULL)
		free_ignore_entry((ignore_entry_t *)section->ptr);
}

static void load_ignore_entry_t(section_t *section) {
	ignore_entry_t *p = (ignore_entry_t *)section->ptr;
	char *lp;

	/* Load flags */
	lp = find_field(section,"flags");
	if(lp != NULL) {
		p->flags = load_int(lp);
	}
	
	/* Load expires */
	lp = find_field(section,"expires");
	if(lp != NULL) {
		p->expires = load_time_t(lp);
	}
	
	/* Load mask */
	lp = find_field(section,"mask");
	if(lp == NULL)
		fail_loading(section,"mask",NULL);
	else {
		p->mask = (char *)xstrdup(lp);
	}
	
}


static void save_ignore_entry_t(config_t *config, ignore_entry_t *p) {
	section_t *section = new_section("ignore_entry_t",p);

	/* Save flags */
	add_field_int(section,"flags",p->flags);
	
	/* Save expires */
	add_field_time_t(section,"expires",p->expires);
	
	/* Save mask */
	add_field_char(section,"mask",p->mask);
	
	add_section(config,section);
}


static void init_network_t(section_t *section) {
	section->ptr = alloc_network(NULL);
}

static void deinit_network_t(section_t *section) {
	if(section->ptr != NULL)
		free_network((network_t *)section->ptr);
}

static void load_network_t(section_t *section) {
	network_t *p = (network_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load channels */
	lpp = find_fields(section,"channels",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->channels),&(p->no_channels),vp);
		}
		xfree(lpp);
	}
	
	/* Load on_connects */
	lpp = find_fields(section,"on_connects",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->on_connects),&(p->no_on_connects),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load settings */
	lp = find_field(section,"settings");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->settings = (netset_t *)vp;
	}
	
	/* Load servers */
	lpp = find_fields(section,"servers",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->servers),&(p->no_servers),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
}


static void save_network_t(config_t *config, network_t *p) {
	section_t *section = new_section("network_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save channels */
	for(i = 0; i < p->no_channels; ++i) {
		save_channel_t(config,p->channels[i]);
		add_field_ptr(section,"channels","channel_t",p->channels[i]);
	}
	
	/* Save on_connects */
	for(i = 0; i < p->no_on_connects; ++i) {
		add_field_char(section,"on_connects",p->on_connects[i]);
	}
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save settings */
	save_netset_t(config,p->settings);
	add_field_ptr(section,"settings","netset_t",p->settings);
	
	/* Save servers */
	for(i = 0; i < p->no_servers; ++i) {
		add_field_char(section,"servers",p->servers[i]);
	}
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_global_t(section_t *section) {
	section->ptr = alloc_global();
}

static void deinit_global_t(section_t *section) {
	if(section->ptr != NULL)
		free_global((global_t *)section->ptr);
}

static void load_global_t(section_t *section) {
	global_t *p = (global_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load users */
	lpp = find_fields(section,"users",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->users),&(p->no_users),vp);
		}
		xfree(lpp);
	}
	
	/* Load interfaces */
	lpp = find_fields(section,"interfaces",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->interfaces),&(p->no_interfaces),vp);
		}
		xfree(lpp);
	}
	
	/* Load ignore_list */
	lp = find_field(section,"ignore_list");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		if(p->ignore_list != NULL && vp != NULL)
			free_ignore_list(p->ignore_list);
		if(vp != NULL)
			p->ignore_list = (ignore_list_t *)vp;
	}
	
	/* Load network_settings */
	lp = find_field(section,"network_settings");
	if(lp == NULL)
		fail_loading(section,"network_settings",NULL);
	else {
		vp = find_ptr(section,lp);
		if(p->network_settings != NULL && vp != NULL)
			free_netset(p->network_settings);
		if(vp != NULL)
			p->network_settings = (netset_t *)vp;
		if(p->network_settings == NULL)
			fail_loading(section,"network_settings",lp);
	}
	
	/* Load packlists */
	lpp = find_fields(section,"packlists",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->packlists),&(p->no_packlists),vp);
		}
		xfree(lpp);
	}
	
	/* Load networks */
	lpp = find_fields(section,"networks",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->networks),&(p->no_networks),vp);
		}
		xfree(lpp);
	}
	
	/* Load settings */
	lp = find_field(section,"settings");
	if(lp == NULL)
		fail_loading(section,"settings",NULL);
	else {
		vp = find_ptr(section,lp);
		if(p->settings != NULL && vp != NULL)
			free_settings(p->settings);
		if(vp != NULL)
			p->settings = (settings_t *)vp;
		if(p->settings == NULL)
			fail_loading(section,"settings",lp);
	}
	
	/* Load queues */
	lpp = find_fields(section,"queues",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->queues),&(p->no_queues),vp);
		}
		xfree(lpp);
	}
	
}


static void save_global_t(config_t *config, global_t *p) {
	section_t *section = new_section("global_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save users */
	for(i = 0; i < p->no_users; ++i) {
		save_user_t(config,p->users[i]);
		add_field_ptr(section,"users","user_t",p->users[i]);
	}
	
	/* Save interfaces */
	for(i = 0; i < p->no_interfaces; ++i) {
		save_interface_t(config,p->interfaces[i]);
		add_field_ptr(section,"interfaces","interface_t",p->interfaces[i]);
	}
	
	/* Save ignore_list */
	save_ignore_list_t(config,p->ignore_list);
	add_field_ptr(section,"ignore_list","ignore_list_t",p->ignore_list);
	
	/* Save network_settings */
	save_netset_t(config,p->network_settings);
	add_field_ptr(section,"network_settings","netset_t",p->network_settings);
	
	/* Save packlists */
	for(i = 0; i < p->no_packlists; ++i) {
		save_packlist_t(config,p->packlists[i]);
		add_field_ptr(section,"packlists","packlist_t",p->packlists[i]);
	}
	
	/* Save networks */
	for(i = 0; i < p->no_networks; ++i) {
		save_network_t(config,p->networks[i]);
		add_field_ptr(section,"networks","network_t",p->networks[i]);
	}
	
	/* Save settings */
	save_settings_t(config,p->settings);
	add_field_ptr(section,"settings","settings_t",p->settings);
	
	/* Save queues */
	for(i = 0; i < p->no_queues; ++i) {
		save_queue_t(config,p->queues[i]);
		add_field_ptr(section,"queues","queue_t",p->queues[i]);
	}
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_user_t(section_t *section) {
	section->ptr = alloc_user(NULL);
}

static void deinit_user_t(section_t *section) {
	if(section->ptr != NULL)
		free_user((user_t *)section->ptr);
}

static void load_user_t(section_t *section) {
	user_t *p = (user_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load hosts */
	lpp = find_fields(section,"hosts",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->hosts),&(p->no_hosts),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load privs */
	lp = find_field(section,"privs");
	if(lp != NULL) {
		p->privs = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load packlists */
	lpp = find_fields(section,"packlists",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->packlists),&(p->no_packlists),vp);
		}
		xfree(lpp);
	}
	
	/* Load username */
	lp = find_field(section,"username");
	if(lp == NULL)
		fail_loading(section,"username",NULL);
	else {
		p->username = (char *)xstrdup(lp);
	}
	
	/* Load last_logon */
	lp = find_field(section,"last_logon");
	if(lp != NULL) {
		p->last_logon = load_time_t(lp);
	}
	
	/* Load password */
	lp = find_field(section,"password");
	if(lp != NULL) {
		p->password = (char *)xstrdup(lp);
	}
	
	/* Load dirs */
	lpp = find_fields(section,"dirs",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->dirs),&(p->no_dirs),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load no_permitted_logons */
	lp = find_field(section,"no_permitted_logons");
	if(lp != NULL) {
		p->no_permitted_logons = load_int(lp);
	}
	
}


static void save_user_t(config_t *config, user_t *p) {
	section_t *section = new_section("user_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save hosts */
	for(i = 0; i < p->no_hosts; ++i) {
		add_field_char(section,"hosts",p->hosts[i]);
	}
	
	/* Save privs */
	add_field_char(section,"privs",p->privs);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save packlists */
	for(i = 0; i < p->no_packlists; ++i) {
		add_field_ptr(section,"packlists","packlist_t",p->packlists[i]);
	}
	
	/* Save username */
	add_field_char(section,"username",p->username);
	
	/* Save last_logon */
	add_field_time_t(section,"last_logon",p->last_logon);
	
	/* Save password */
	add_field_char(section,"password",p->password);
	
	/* Save dirs */
	for(i = 0; i < p->no_dirs; ++i) {
		add_field_char(section,"dirs",p->dirs[i]);
	}
	
	/* Save no_permitted_logons */
	add_field_int(section,"no_permitted_logons",p->no_permitted_logons);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_packlist_t(section_t *section) {
	section->ptr = alloc_packlist();
}

static void deinit_packlist_t(section_t *section) {
	if(section->ptr != NULL)
		free_packlist((packlist_t *)section->ptr);
}

static void load_packlist_t(section_t *section) {
	packlist_t *p = (packlist_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load packs */
	lpp = find_fields(section,"packs",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->packs),&(p->no_packs),vp);
		}
		xfree(lpp);
	}
	
	/* Load retries */
	lp = find_field(section,"retries");
	if(lp != NULL) {
		p->retries = load_int(lp);
	}
	
	/* Load filters */
	lpp = find_fields(section,"filters",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->filters),&(p->no_filters),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load nosend_reason */
	lp = find_field(section,"nosend_reason");
	if(lp != NULL) {
		p->nosend_reason = (char *)xstrdup(lp);
	}
	
	/* Load nolist */
	lp = find_field(section,"nolist");
	if(lp != NULL) {
		p->nolist = load_time_t(lp);
	}
	
	/* Load ignore_list */
	lp = find_field(section,"ignore_list");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		if(p->ignore_list != NULL && vp != NULL)
			free_ignore_list(p->ignore_list);
		if(vp != NULL)
			p->ignore_list = (ignore_list_t *)vp;
	}
	
	/* Load dirs */
	lpp = find_fields(section,"dirs",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->dirs),&(p->no_dirs),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load last_scan */
	lp = find_field(section,"last_scan");
	if(lp != NULL) {
		p->last_scan = load_time_t(lp);
	}
	
	/* Load command_limit */
	lp = find_field(section,"command_limit");
	if(lp != NULL) {
		p->command_limit = load_int(lp);
	}
	
	/* Load access */
	lp = find_field(section,"access");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		if(p->access != NULL && vp != NULL)
			free_access(p->access);
		if(vp != NULL)
			p->access = (access_t *)vp;
	}
	
	/* Load response */
	lp = find_field(section,"response");
	if(lp != NULL) {
		p->response = load_responsetype_t(lp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load no_filters */
	lp = find_field(section,"no_filters");
	if(lp != NULL) {
		p->no_filters = load_int(lp);
	}
	
	/* Load chat_interface */
	lp = find_field(section,"chat_interface");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->chat_interface = (interface_t *)vp;
	}
	
	/* Load dir_scan_interval */
	lp = find_field(section,"dir_scan_interval");
	if(lp != NULL) {
		p->dir_scan_interval = load_uint32_t(lp);
	}
	
	/* Load taglines */
	lpp = find_fields(section,"taglines",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->taglines),&(p->no_taglines),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load nolist_reason */
	lp = find_field(section,"nolist_reason");
	if(lp != NULL) {
		p->nolist_reason = (char *)xstrdup(lp);
	}
	
	/* Load scan_depth */
	lp = find_field(section,"scan_depth");
	if(lp != NULL) {
		p->scan_depth = load_int(lp);
	}
	
	/* Load nosend */
	lp = find_field(section,"nosend");
	if(lp != NULL) {
		p->nosend = load_time_t(lp);
	}
	
	/* Load auto_sort */
	lp = find_field(section,"auto_sort");
	if(lp != NULL) {
		p->auto_sort = load_sorttype_t(lp);
	}
	
	/* Load queue */
	lp = find_field(section,"queue");
	if(lp == NULL)
		fail_loading(section,"queue",NULL);
	else {
		vp = find_ptr(section,lp);
		p->queue = (queue_t *)vp;
		if(p->queue == NULL)
			fail_loading(section,"queue",lp);
	}
	
	/* Load type */
	lp = find_field(section,"type");
	if(lp != NULL) {
		p->type = load_listtype_t(lp);
	}
	
	/* Load time_limit */
	lp = find_field(section,"time_limit");
	if(lp != NULL) {
		p->time_limit = load_int(lp);
	}
	
	/* Load hash_display */
	lp = find_field(section,"hash_display");
	if(lp != NULL) {
		p->hash_display = load_hashtype_t(lp);
	}
	
}


static void save_packlist_t(config_t *config, packlist_t *p) {
	section_t *section = new_section("packlist_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save packs */
	for(i = 0; i < p->no_packs; ++i) {
		save_pack_t(config,p->packs[i]);
		add_field_ptr(section,"packs","pack_t",p->packs[i]);
	}
	
	/* Save retries */
	add_field_int(section,"retries",p->retries);
	
	/* Save filters */
	for(i = 0; i < p->no_filters; ++i) {
		add_field_char(section,"filters",p->filters[i]);
	}
	
	/* Save nosend_reason */
	add_field_char(section,"nosend_reason",p->nosend_reason);
	
	/* Save nolist */
	add_field_time_t(section,"nolist",p->nolist);
	
	/* Save ignore_list */
	save_ignore_list_t(config,p->ignore_list);
	add_field_ptr(section,"ignore_list","ignore_list_t",p->ignore_list);
	
	/* Save dirs */
	for(i = 0; i < p->no_dirs; ++i) {
		add_field_char(section,"dirs",p->dirs[i]);
	}
	
	/* Save last_scan */
	add_field_time_t(section,"last_scan",p->last_scan);
	
	/* Save command_limit */
	add_field_int(section,"command_limit",p->command_limit);
	
	/* Save access */
	save_access_t(config,p->access);
	add_field_ptr(section,"access","access_t",p->access);
	
	/* Save response */
	add_field_responsetype_t(section,"response",p->response);
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save no_filters */
	add_field_int(section,"no_filters",p->no_filters);
	
	/* Save chat_interface */
	add_field_ptr(section,"chat_interface","interface_t",p->chat_interface);
	
	/* Save dir_scan_interval */
	add_field_uint32_t(section,"dir_scan_interval",p->dir_scan_interval);
	
	/* Save taglines */
	for(i = 0; i < p->no_taglines; ++i) {
		add_field_char(section,"taglines",p->taglines[i]);
	}
	
	/* Save nolist_reason */
	add_field_char(section,"nolist_reason",p->nolist_reason);
	
	/* Save scan_depth */
	add_field_int(section,"scan_depth",p->scan_depth);
	
	/* Save nosend */
	add_field_time_t(section,"nosend",p->nosend);
	
	/* Save auto_sort */
	add_field_sorttype_t(section,"auto_sort",p->auto_sort);
	
	/* Save queue */
	add_field_ptr(section,"queue","queue_t",p->queue);
	
	/* Save type */
	add_field_listtype_t(section,"type",p->type);
	
	/* Save time_limit */
	add_field_int(section,"time_limit",p->time_limit);
	
	/* Save hash_display */
	add_field_hashtype_t(section,"hash_display",p->hash_display);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_pack_t(section_t *section) {
	section->ptr = alloc_pack();
}

static void deinit_pack_t(section_t *section) {
	if(section->ptr != NULL)
		free_pack((pack_t *)section->ptr);
}

static void load_pack_t(section_t *section) {
	pack_t *p = (pack_t *)section->ptr;
	char *lp;

	/* Load crc */
	lp = find_field(section,"crc");
	if(lp != NULL) {
		p->crc = (char *)xstrdup(lp);
	}
	
	/* Load file */
	lp = find_field(section,"file");
	if(lp == NULL)
		fail_loading(section,"file",NULL);
	else {
		p->file = (char *)xstrdup(lp);
	}
	
	/* Load size */
	lp = find_field(section,"size");
	if(lp != NULL) {
		p->size = load_off_t(lp);
	}
	
	/* Load hashed */
	lp = find_field(section,"hashed");
	if(lp != NULL) {
		p->hashed = load_time_t(lp);
	}
	
	/* Load no_gets */
	lp = find_field(section,"no_gets");
	if(lp != NULL) {
		p->no_gets = load_int(lp);
	}
	
	/* Load label */
	lp = find_field(section,"label");
	if(lp != NULL) {
		p->label = (char *)xstrdup(lp);
	}
	
	/* Load md5 */
	lp = find_field(section,"md5");
	if(lp != NULL) {
		p->md5 = (char *)xstrdup(lp);
	}
	
}

static void ref_count_pack_t(section_t *section) {
	pack_t *p = (pack_t *)section->ptr;
	p->ref_count = section->ptr_ref;
}


static void save_pack_t(config_t *config, pack_t *p) {
	section_t *section = new_section("pack_t",p);

	/* Lock lock */
	RLOCKR(&(p->lock));
	
	/* Save crc */
	add_field_char(section,"crc",p->crc);
	
	/* Save file */
	add_field_char(section,"file",p->file);
	
	/* Save size */
	add_field_off_t(section,"size",p->size);
	
	/* Save hashed */
	add_field_time_t(section,"hashed",p->hashed);
	
	/* Save no_gets */
	add_field_int(section,"no_gets",p->no_gets);
	
	/* Save label */
	add_field_char(section,"label",p->label);
	
	/* Save md5 */
	add_field_char(section,"md5",p->md5);
	
	/* Unlock lock */
	RUNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_ignore_list_t(section_t *section) {
	section->ptr = alloc_ignore_list();
}

static void deinit_ignore_list_t(section_t *section) {
	if(section->ptr != NULL)
		free_ignore_list((ignore_list_t *)section->ptr);
}

static void load_ignore_list_t(section_t *section) {
	ignore_list_t *p = (ignore_list_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load trigger */
	lp = find_field(section,"trigger");
	if(lp != NULL) {
		p->trigger = load_int(lp);
	}
	
	/* Load period */
	lp = find_field(section,"period");
	if(lp != NULL) {
		p->period = load_int(lp);
	}
	
	/* Load entries */
	lpp = find_fields(section,"entries",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->entries),&(p->no_entries),vp);
		}
		xfree(lpp);
	}
	
	/* Load last_prune */
	lp = find_field(section,"last_prune");
	if(lp != NULL) {
		p->last_prune = load_time_t(lp);
	}
	
	/* Load log */
	lp = find_field(section,"log");
	if(lp != NULL) {
		p->log = load_int(lp);
	}
	
}


static void save_ignore_list_t(config_t *config, ignore_list_t *p) {
	section_t *section = new_section("ignore_list_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save trigger */
	add_field_int(section,"trigger",p->trigger);
	
	/* Save period */
	add_field_int(section,"period",p->period);
	
	/* Save entries */
	for(i = 0; i < p->no_entries; ++i) {
		save_ignore_entry_t(config,p->entries[i]);
		add_field_ptr(section,"entries","ignore_entry_t",p->entries[i]);
	}
	
	/* Save last_prune */
	add_field_time_t(section,"last_prune",p->last_prune);
	
	/* Save log */
	add_field_int(section,"log",p->log);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_channel_t(section_t *section) {
	section->ptr = alloc_channel();
}

static void deinit_channel_t(section_t *section) {
	if(section->ptr != NULL)
		free_channel((channel_t *)section->ptr);
}

static void load_channel_t(section_t *section) {
	channel_t *p = (channel_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;

	/* Load key */
	lp = find_field(section,"key");
	if(lp != NULL) {
		p->key = (char *)xstrdup(lp);
	}
	
	/* Load nolist */
	lp = find_field(section,"nolist");
	if(lp != NULL) {
		p->nolist = load_time_t(lp);
	}
	
	/* Load plist */
	lp = find_field(section,"plist");
	if(lp != NULL) {
		p->plist = load_int(lp);
	}
	
	/* Load pformat */
	lp = find_field(section,"pformat");
	if(lp != NULL) {
		p->pformat = load_pformat_t(lp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load track_key */
	lp = find_field(section,"track_key");
	if(lp != NULL) {
		p->track_key = load_int(lp);
	}
	
	/* Load taglines */
	lpp = find_fields(section,"taglines",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->taglines),&(p->no_taglines),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
}


static void save_channel_t(config_t *config, channel_t *p) {
	section_t *section = new_section("channel_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save key */
	add_field_char(section,"key",p->key);
	
	/* Save nolist */
	add_field_time_t(section,"nolist",p->nolist);
	
	/* Save plist */
	add_field_int(section,"plist",p->plist);
	
	/* Save pformat */
	add_field_pformat_t(section,"pformat",p->pformat);
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save track_key */
	add_field_int(section,"track_key",p->track_key);
	
	/* Save taglines */
	for(i = 0; i < p->no_taglines; ++i) {
		add_field_char(section,"taglines",p->taglines[i]);
	}
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_interface_t(section_t *section) {
	section->ptr = alloc_interface(load_interfacetype_t(find_field(section,"type")));
}

static void deinit_interface_t(section_t *section) {
	if(section->ptr != NULL)
		free_interface((interface_t *)section->ptr);
}

static void load_interface_t(section_t *section) {
	interface_t *p = (interface_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load bind_ip */
	lp = find_field(section,"bind_ip");
	if(lp != NULL) {
		p->bind_ip = (char *)xstrdup(lp);
	}
	
	/* Load mode */
	lp = find_field(section,"mode");
	if(lp != NULL) {
		p->mode = load_interfacemode_t(lp);
	}
	
	/* Load dcc_port */
	lp = find_field(section,"dcc_port");
	if(lp != NULL) {
		p->dcc_port = load_unsigned_int(lp);
	}
	
	/* Load accept_per_sec */
	lp = find_field(section,"accept_per_sec");
	if(lp != NULL) {
		p->accept_per_sec = load_int(lp);
	}
	
	/* Load snd_bufsize */
	lp = find_field(section,"snd_bufsize");
	if(lp != NULL) {
		p->snd_bufsize = load_unsigned_int(lp);
	}
	
	/* Load dccserver_port */
	lp = find_field(section,"dccserver_port");
	if(lp != NULL) {
		p->dccserver_port = load_unsigned_int(lp);
	}
	
	/* Load def */
	lp = find_field(section,"def");
	if(lp != NULL) {
		p->def = load_int(lp);
	}
	
	/* Load stat_carry */
	lp = find_field(section,"stat_carry");
	if(lp != NULL) {
		p->stat_carry = load_uint32_t(lp);
	}
	
	/* Load dcc_timeout */
	lp = find_field(section,"dcc_timeout");
	if(lp != NULL) {
		p->dcc_timeout = load_unsigned_int(lp);
	}
	
	/* Load rcv_bufsize */
	lp = find_field(section,"rcv_bufsize");
	if(lp != NULL) {
		p->rcv_bufsize = load_unsigned_int(lp);
	}
	
	/* Load no_ports */
	lp = find_field(section,"no_ports");
	if(lp != NULL) {
		p->no_ports = load_unsigned_int(lp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load secure_mode */
	lp = find_field(section,"secure_mode");
	if(lp != NULL) {
		p->secure_mode = load_int(lp);
	}
	
	/* Load stat_mib */
	lp = find_field(section,"stat_mib");
	if(lp != NULL) {
		p->stat_mib = load_uint32_t(lp);
	}
	
	/* Load bandwidth */
	lp = find_field(section,"bandwidth");
	if(lp != NULL) {
		p->bandwidth = load_unsigned_int(lp);
	}
	
	/* Load record_rate */
	lp = find_field(section,"record_rate");
	if(lp != NULL) {
		p->record_rate = load_uint32_t(lp);
	}
	
	/* Load type */
	lp = find_field(section,"type");
	if(lp != NULL) {
		p->type = load_interfacetype_t(lp);
	}
	
	/* Load advertise_ip */
	lp = find_field(section,"advertise_ip");
	if(lp != NULL) {
		p->advertise_ip = (char *)xstrdup(lp);
	}
	
	/* Load dcc_packet */
	lp = find_field(section,"dcc_packet");
	if(lp != NULL) {
		p->dcc_packet = load_unsigned_int(lp);
	}
	
	/* Load send */
	if(p->type==INTERFACE_SEND) {
		/* Load send.pools */
		lpp = find_fields(section,"send.pools",&j);
		if(lpp != NULL) {
			for(i = 0; i < j; ++i) {
				vp = find_ptr(section,lpp[i]);
				if(vp != NULL)
					PTRARR_ADD(&(p->send.pools),&(p->send.no_pools),vp);
			}
			xfree(lpp);
		}
		
	}
	
	/* Load chat */
	if(p->type==INTERFACE_CHAT) {
		/* Load chat.max_no */
		lp = find_field(section,"chat.max_no");
		if(lp != NULL) {
			p->chat.max_no = load_int(lp);
		}
		
	}
	
	/* Load recv */
	if(p->type==INTERFACE_RECV) {
		/* Load recv.max_no_uploads */
		lp = find_field(section,"recv.max_no_uploads");
		if(lp != NULL) {
			p->recv.max_no_uploads = load_int(lp);
		}
		
		/* Load recv.access */
		lp = find_field(section,"recv.access");
		if(lp != NULL) {
			vp = find_ptr(section,lp);
			if(p->recv.access != NULL && vp != NULL)
				free_access(p->recv.access);
			if(vp != NULL)
				p->recv.access = (access_t *)vp;
		}
		
		/* Load recv.max_size */
		lp = find_field(section,"recv.max_size");
		if(lp != NULL) {
			p->recv.max_size = load_off_t(lp);
		}
		
		/* Load recv.dir */
		lp = find_field(section,"recv.dir");
		if(lp != NULL) {
			p->recv.dir = (char *)xstrdup(lp);
		}
		
	}
	
}


static void save_interface_t(config_t *config, interface_t *p) {
	section_t *section = new_section("interface_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save bind_ip */
	add_field_char(section,"bind_ip",p->bind_ip);
	
	/* Save send */
	if(p->type==INTERFACE_SEND) {
		/* Save send.pools */
		for(i = 0; i < p->send.no_pools; ++i) {
			save_pool_t(config,p->send.pools[i]);
			add_field_ptr(section,"send.pools","pool_t",p->send.pools[i]);
		}
		
	}
	
	/* Save mode */
	add_field_interfacemode_t(section,"mode",p->mode);
	
	/* Save dcc_port */
	add_field_unsigned_int(section,"dcc_port",p->dcc_port);
	
	/* Save accept_per_sec */
	add_field_int(section,"accept_per_sec",p->accept_per_sec);
	
	/* Save snd_bufsize */
	add_field_unsigned_int(section,"snd_bufsize",p->snd_bufsize);
	
	/* Save dccserver_port */
	add_field_unsigned_int(section,"dccserver_port",p->dccserver_port);
	
	/* Save def */
	add_field_int(section,"def",p->def);
	
	/* Save stat_carry */
	add_field_uint32_t(section,"stat_carry",p->stat_carry);
	
	/* Save dcc_timeout */
	add_field_unsigned_int(section,"dcc_timeout",p->dcc_timeout);
	
	/* Save rcv_bufsize */
	add_field_unsigned_int(section,"rcv_bufsize",p->rcv_bufsize);
	
	/* Save no_ports */
	add_field_unsigned_int(section,"no_ports",p->no_ports);
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save chat */
	if(p->type==INTERFACE_CHAT) {
		/* Save chat.max_no */
		add_field_int(section,"chat.max_no",p->chat.max_no);
		
	}
	
	/* Save secure_mode */
	add_field_int(section,"secure_mode",p->secure_mode);
	
	/* Save stat_mib */
	add_field_uint32_t(section,"stat_mib",p->stat_mib);
	
	/* Save bandwidth */
	add_field_unsigned_int(section,"bandwidth",p->bandwidth);
	
	/* Save recv */
	if(p->type==INTERFACE_RECV) {
		/* Save recv.max_no_uploads */
		add_field_int(section,"recv.max_no_uploads",p->recv.max_no_uploads);
		
		/* Save recv.access */
		save_access_t(config,p->recv.access);
		add_field_ptr(section,"recv.access","access_t",p->recv.access);
		
		/* Save recv.max_size */
		add_field_off_t(section,"recv.max_size",p->recv.max_size);
		
		/* Save recv.dir */
		add_field_char(section,"recv.dir",p->recv.dir);
		
	}
	
	/* Save record_rate */
	add_field_uint32_t(section,"record_rate",p->record_rate);
	
	/* Save type */
	add_field_interfacetype_t(section,"type",p->type);
	
	/* Save advertise_ip */
	add_field_char(section,"advertise_ip",p->advertise_ip);
	
	/* Save dcc_packet */
	add_field_unsigned_int(section,"dcc_packet",p->dcc_packet);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_netset_t(section_t *section) {
	section->ptr = alloc_netset();
}

static void deinit_netset_t(section_t *section) {
	if(section->ptr != NULL)
		free_netset((netset_t *)section->ptr);
}

static void load_netset_t(section_t *section) {
	netset_t *p = (netset_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;

	/* Load bind_ip */
	lp = find_field(section,"bind_ip");
	if(lp != NULL) {
		p->bind_ip = (char *)xstrdup(lp);
	}
	
	/* Load on_connect_delay */
	lp = find_field(section,"on_connect_delay");
	if(lp != NULL) {
		p->on_connect_delay = load_int(lp);
	}
	
	/* Load message_rate */
	lp = find_field(section,"message_rate");
	if(lp != NULL) {
		p->message_rate = load_float(lp);
	}
	
	/* Load no_autoconnect */
	lp = find_field(section,"no_autoconnect");
	if(lp != NULL) {
		p->no_autoconnect = load_int(lp);
	}
	
	/* Load nick */
	lp = find_field(section,"nick");
	if(lp == NULL)
		fail_loading(section,"nick",NULL);
	else {
		p->nick = (char *)xstrdup(lp);
	}
	
	/* Load realname */
	lp = find_field(section,"realname");
	if(lp == NULL)
		fail_loading(section,"realname",NULL);
	else {
		p->realname = (char *)xstrdup(lp);
	}
	
	/* Load irc_timeout */
	lp = find_field(section,"irc_timeout");
	if(lp != NULL) {
		p->irc_timeout = load_int(lp);
	}
	
	/* Load max_target */
	lp = find_field(section,"max_target");
	if(lp != NULL) {
		p->max_target = load_int(lp);
	}
	
	/* Load nick_tracking */
	lp = find_field(section,"nick_tracking");
	if(lp != NULL) {
		p->nick_tracking = load_int(lp);
	}
	
	/* Load recv_per_sec */
	lp = find_field(section,"recv_per_sec");
	if(lp != NULL) {
		p->recv_per_sec = load_int(lp);
	}
	
	/* Load join_delay */
	lp = find_field(section,"join_delay");
	if(lp != NULL) {
		p->join_delay = load_int(lp);
	}
	
	/* Load info_line */
	lp = find_field(section,"info_line");
	if(lp != NULL) {
		p->info_line = (char *)xstrdup(lp);
	}
	
	/* Load taglines */
	lpp = find_fields(section,"taglines",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->taglines),&(p->no_taglines),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load average_window */
	lp = find_field(section,"average_window");
	if(lp != NULL) {
		p->average_window = load_int(lp);
	}
	
	/* Load reconnect_delay */
	lp = find_field(section,"reconnect_delay");
	if(lp != NULL) {
		p->reconnect_delay = load_int(lp);
	}
	
	/* Load message_rate_max */
	lp = find_field(section,"message_rate_max");
	if(lp != NULL) {
		p->message_rate_max = load_int(lp);
	}
	
	/* Load loginname */
	lp = find_field(section,"loginname");
	if(lp == NULL)
		fail_loading(section,"loginname",NULL);
	else {
		p->loginname = (char *)xstrdup(lp);
	}
	
}


static void save_netset_t(config_t *config, netset_t *p) {
	section_t *section = new_section("netset_t",p);
	int i;

	/* Save bind_ip */
	add_field_char(section,"bind_ip",p->bind_ip);
	
	/* Save on_connect_delay */
	add_field_int(section,"on_connect_delay",p->on_connect_delay);
	
	/* Save message_rate */
	add_field_float(section,"message_rate",p->message_rate);
	
	/* Save no_autoconnect */
	add_field_int(section,"no_autoconnect",p->no_autoconnect);
	
	/* Save nick */
	add_field_char(section,"nick",p->nick);
	
	/* Save realname */
	add_field_char(section,"realname",p->realname);
	
	/* Save irc_timeout */
	add_field_int(section,"irc_timeout",p->irc_timeout);
	
	/* Save max_target */
	add_field_int(section,"max_target",p->max_target);
	
	/* Save nick_tracking */
	add_field_int(section,"nick_tracking",p->nick_tracking);
	
	/* Save recv_per_sec */
	add_field_int(section,"recv_per_sec",p->recv_per_sec);
	
	/* Save join_delay */
	add_field_int(section,"join_delay",p->join_delay);
	
	/* Save info_line */
	add_field_char(section,"info_line",p->info_line);
	
	/* Save taglines */
	for(i = 0; i < p->no_taglines; ++i) {
		add_field_char(section,"taglines",p->taglines[i]);
	}
	
	/* Save average_window */
	add_field_int(section,"average_window",p->average_window);
	
	/* Save reconnect_delay */
	add_field_int(section,"reconnect_delay",p->reconnect_delay);
	
	/* Save message_rate_max */
	add_field_int(section,"message_rate_max",p->message_rate_max);
	
	/* Save loginname */
	add_field_char(section,"loginname",p->loginname);
	
	add_section(config,section);
}


static void init_access_t(section_t *section) {
	section->ptr = alloc_access();
}

static void deinit_access_t(section_t *section) {
	if(section->ptr != NULL)
		free_access((access_t *)section->ptr);
}

static void load_access_t(section_t *section) {
	access_t *p = (access_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load flags */
	lp = find_field(section,"flags");
	if(lp != NULL) {
		p->flags = load_int(lp);
	}
	
	/* Load entries */
	lpp = find_fields(section,"entries",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->entries),&(p->no_entries),vp);
		}
		xfree(lpp);
	}
	
}


static void save_access_t(config_t *config, access_t *p) {
	section_t *section = new_section("access_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save flags */
	add_field_int(section,"flags",p->flags);
	
	/* Save entries */
	for(i = 0; i < p->no_entries; ++i) {
		save_access_entry_t(config,p->entries[i]);
		add_field_ptr(section,"entries","access_entry_t",p->entries[i]);
	}
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_access_entry_t(section_t *section) {
	section->ptr = alloc_access_entry();
}

static void deinit_access_entry_t(section_t *section) {
	if(section->ptr != NULL)
		free_access_entry((access_entry_t *)section->ptr);
}

static void load_access_entry_t(section_t *section) {
	access_entry_t *p = (access_entry_t *)section->ptr;
	char *lp;
	void *vp;

	/* Load network */
	lp = find_field(section,"network");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->network = (network_t *)vp;
	}
	
	/* Load flags */
	lp = find_field(section,"flags");
	if(lp != NULL) {
		p->flags = load_int(lp);
	}
	
	/* Load mode */
	lp = find_field(section,"mode");
	if(lp != NULL) {
		p->mode = load_int(lp);
	}
	
	/* Load channel */
	lp = find_field(section,"channel");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->channel = (channel_t *)vp;
	}
	
	/* Load host */
	lp = find_field(section,"host");
	if(lp != NULL) {
		p->host = (char *)xstrdup(lp);
	}
	
}


static void save_access_entry_t(config_t *config, access_entry_t *p) {
	section_t *section = new_section("access_entry_t",p);

	/* Save network */
	add_field_ptr(section,"network","network_t",p->network);
	
	/* Save flags */
	add_field_int(section,"flags",p->flags);
	
	/* Save mode */
	add_field_int(section,"mode",p->mode);
	
	/* Save channel */
	add_field_ptr(section,"channel","channel_t",p->channel);
	
	/* Save host */
	add_field_char(section,"host",p->host);
	
	add_section(config,section);
}


static void init_queue_t(section_t *section) {
	section->ptr = alloc_queue();
}

static void deinit_queue_t(section_t *section) {
	if(section->ptr != NULL)
		free_queue((queue_t *)section->ptr);
}

static void load_queue_t(section_t *section) {
	queue_t *p = (queue_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load priority */
	lp = find_field(section,"priority");
	if(lp != NULL) {
		p->priority = load_int(lp);
	}
	
	/* Load qsends */
	lpp = find_fields(section,"qsends",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->qsends),&(p->no_qsends),vp);
		}
		xfree(lpp);
	}
	
	/* Load last_dequeue */
	lp = find_field(section,"last_dequeue");
	if(lp != NULL) {
		p->last_dequeue = load_time_t(lp);
	}
	
	/* Load last_notify */
	lp = find_field(section,"last_notify");
	if(lp != NULL) {
		p->last_notify = load_time_t(lp);
	}
	
	/* Load pool */
	lp = find_field(section,"pool");
	if(lp == NULL)
		fail_loading(section,"pool",NULL);
	else {
		vp = find_ptr(section,lp);
		p->pool = (pool_t *)vp;
		if(p->pool == NULL)
			fail_loading(section,"pool",lp);
	}
	
	/* Load notify */
	lp = find_field(section,"notify");
	if(lp != NULL) {
		p->notify = load_int(lp);
	}
	
	/* Load queues_per_user */
	lp = find_field(section,"queues_per_user");
	if(lp != NULL) {
		p->queues_per_user = load_int(lp);
	}
	
	/* Load combined_queue_limit */
	lp = find_field(section,"combined_queue_limit");
	if(lp != NULL) {
		p->combined_queue_limit = load_int(lp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load bypass_size */
	lp = find_field(section,"bypass_size");
	if(lp != NULL) {
		p->bypass_size = load_off_t(lp);
	}
	
	/* Load last_checked */
	lp = find_field(section,"last_checked");
	if(lp != NULL) {
		p->last_checked = load_time_t(lp);
	}
	
	/* Load length */
	lp = find_field(section,"length");
	if(lp != NULL) {
		p->length = load_int(lp);
	}
	
	/* Load priority_queues */
	lp = find_field(section,"priority_queues");
	if(lp != NULL) {
		p->priority_queues = load_int(lp);
	}
	
	/* Load overflow_requeue */
	lp = find_field(section,"overflow_requeue");
	if(lp != NULL) {
		p->overflow_requeue = load_int(lp);
	}
	
}


static void save_queue_t(config_t *config, queue_t *p) {
	section_t *section = new_section("queue_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save priority */
	add_field_int(section,"priority",p->priority);
	
	/* Save qsends */
	for(i = 0; i < p->no_qsends; ++i) {
		save_send_t(config,p->qsends[i]);
		add_field_ptr(section,"qsends","send_t",p->qsends[i]);
	}
	
	/* Save last_dequeue */
	add_field_time_t(section,"last_dequeue",p->last_dequeue);
	
	/* Save last_notify */
	add_field_time_t(section,"last_notify",p->last_notify);
	
	/* Save pool */
	add_field_ptr(section,"pool","pool_t",p->pool);
	
	/* Save notify */
	add_field_int(section,"notify",p->notify);
	
	/* Save queues_per_user */
	add_field_int(section,"queues_per_user",p->queues_per_user);
	
	/* Save combined_queue_limit */
	add_field_int(section,"combined_queue_limit",p->combined_queue_limit);
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save bypass_size */
	add_field_off_t(section,"bypass_size",p->bypass_size);
	
	/* Save last_checked */
	add_field_time_t(section,"last_checked",p->last_checked);
	
	/* Save length */
	add_field_int(section,"length",p->length);
	
	/* Save priority_queues */
	add_field_int(section,"priority_queues",p->priority_queues);
	
	/* Save overflow_requeue */
	add_field_int(section,"overflow_requeue",p->overflow_requeue);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_settings_t(section_t *section) {
	section->ptr = alloc_settings();
}

static void deinit_settings_t(section_t *section) {
	if(section->ptr != NULL)
		free_settings((settings_t *)section->ptr);
}

static void load_settings_t(section_t *section) {
	settings_t *p = (settings_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;

	/* Load autosave_interval */
	lp = find_field(section,"autosave_interval");
	if(lp != NULL) {
		p->autosave_interval = load_int(lp);
	}
	
	/* Load admin_socket */
	lp = find_field(section,"admin_socket");
	if(lp != NULL) {
		p->admin_socket = (char *)xstrdup(lp);
	}
	
	/* Load hashing_io_usage */
	lp = find_field(section,"hashing_io_usage");
	if(lp != NULL) {
		p->hashing_io_usage = load_int(lp);
	}
	
	/* Load tick_interval */
	lp = find_field(section,"tick_interval");
	if(lp != NULL) {
		p->tick_interval = load_int(lp);
	}
	
	/* Load pid */
	lp = find_field(section,"pid");
	if(lp != NULL) {
		p->pid = (char *)xstrdup(lp);
	}
	
	/* Load hash_packs */
	lp = find_field(section,"hash_packs");
	if(lp != NULL) {
		p->hash_packs = load_int(lp);
	}
	
	/* Load log_interval */
	lp = find_field(section,"log_interval");
	if(lp != NULL) {
		p->log_interval = load_int(lp);
	}
	
	/* Load scripts */
	lpp = find_fields(section,"scripts",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			PTRARR_ADD(&(p->scripts),&(p->no_scripts),xstrdup(lpp[i]));
		}
		xfree(lpp);
	}
	
	/* Load log */
	lp = find_field(section,"log");
	if(lp != NULL) {
		p->log = (char *)xstrdup(lp);
	}
	
	/* Load list_frequency */
	lp = find_field(section,"list_frequency");
	if(lp != NULL) {
		p->list_frequency = load_int(lp);
	}
	
}


static void save_settings_t(config_t *config, settings_t *p) {
	section_t *section = new_section("settings_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save autosave_interval */
	add_field_int(section,"autosave_interval",p->autosave_interval);
	
	/* Save admin_socket */
	add_field_char(section,"admin_socket",p->admin_socket);
	
	/* Save hashing_io_usage */
	add_field_int(section,"hashing_io_usage",p->hashing_io_usage);
	
	/* Save tick_interval */
	add_field_int(section,"tick_interval",p->tick_interval);
	
	/* Save pid */
	add_field_char(section,"pid",p->pid);
	
	/* Save hash_packs */
	add_field_int(section,"hash_packs",p->hash_packs);
	
	/* Save log_interval */
	add_field_int(section,"log_interval",p->log_interval);
	
	/* Save scripts */
	for(i = 0; i < p->no_scripts; ++i) {
		add_field_char(section,"scripts",p->scripts[i]);
	}
	
	/* Save log */
	add_field_char(section,"log",p->log);
	
	/* Save list_frequency */
	add_field_int(section,"list_frequency",p->list_frequency);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_send_t(section_t *section) {
	section->ptr = alloc_send();
}

static void deinit_send_t(section_t *section) {
	if(section->ptr != NULL)
		free_send((send_t *)section->ptr);
}

static void load_send_t(section_t *section) {
	send_t *p = (send_t *)section->ptr;
	char *lp;
	void *vp;

	/* Load retries */
	lp = find_field(section,"retries");
	if(lp != NULL) {
		p->retries = load_int(lp);
	}
	
	/* Load network */
	lp = find_field(section,"network");
	if(lp == NULL)
		fail_loading(section,"network",NULL);
	else {
		vp = find_ptr(section,lp);
		p->network = (network_t *)vp;
		if(p->network == NULL)
			fail_loading(section,"network",lp);
	}
	
	/* Load connected */
	lp = find_field(section,"connected");
	if(lp != NULL) {
		p->connected = load_time_t(lp);
	}
	
	/* Load reason */
	lp = find_field(section,"reason");
	if(lp != NULL) {
		p->reason = (char *)xstrdup(lp);
	}
	
	/* Load nick */
	lp = find_field(section,"nick");
	if(lp == NULL)
		fail_loading(section,"nick",NULL);
	else {
		p->nick = (char *)xstrdup(lp);
	}
	
	/* Load last_contact */
	lp = find_field(section,"last_contact");
	if(lp != NULL) {
		p->last_contact = load_time_t(lp);
	}
	
	/* Load host */
	lp = find_field(section,"host");
	if(lp != NULL) {
		p->host = (char *)xstrdup(lp);
	}
	
	/* Load pool */
	lp = find_field(section,"pool");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->pool = (pool_t *)vp;
	}
	
	/* Load started */
	lp = find_field(section,"started");
	if(lp != NULL) {
		p->started = load_time_t(lp);
	}
	
	/* Load pack */
	lp = find_field(section,"pack");
	if(lp == NULL)
		fail_loading(section,"pack",NULL);
	else {
		vp = find_ptr(section,lp);
		p->pack = (pack_t *)vp;
		if(p->pack == NULL)
			fail_loading(section,"pack",lp);
	}
	
	/* Load queue */
	lp = find_field(section,"queue");
	if(lp != NULL) {
		vp = find_ptr(section,lp);
		p->queue = (queue_t *)vp;
	}
	
}


static void save_send_t(config_t *config, send_t *p) {
	section_t *section = new_section("send_t",p);

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save retries */
	add_field_int(section,"retries",p->retries);
	
	/* Save network */
	add_field_ptr(section,"network","network_t",p->network);
	
	/* Save connected */
	add_field_time_t(section,"connected",p->connected);
	
	/* Save reason */
	add_field_char(section,"reason",p->reason);
	
	/* Save nick */
	add_field_char(section,"nick",p->nick);
	
	/* Save last_contact */
	add_field_time_t(section,"last_contact",p->last_contact);
	
	/* Save host */
	add_field_char(section,"host",p->host);
	
	/* Save pool */
	add_field_ptr(section,"pool","pool_t",p->pool);
	
	/* Save started */
	add_field_time_t(section,"started",p->started);
	
	/* Save pack */
	save_pack_t(config,p->pack);
	add_field_ptr(section,"pack","pack_t",p->pack);
	
	/* Save queue */
	add_field_ptr(section,"queue","queue_t",p->queue);
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}


static void init_pool_t(section_t *section) {
	section->ptr = alloc_pool();
}

static void deinit_pool_t(section_t *section) {
	if(section->ptr != NULL)
		free_pool((pool_t *)section->ptr);
}

static void load_pool_t(section_t *section) {
	pool_t *p = (pool_t *)section->ptr;
	char **lpp;
	char *lp;
	int i;
	int j;
	void *vp;

	/* Load stat_carry */
	lp = find_field(section,"stat_carry");
	if(lp != NULL) {
		p->stat_carry = load_uint32_t(lp);
	}
	
	/* Load name */
	lp = find_field(section,"name");
	if(lp == NULL)
		fail_loading(section,"name",NULL);
	else {
		p->name = (char *)xstrdup(lp);
	}
	
	/* Load dequeue_algorithm */
	lp = find_field(section,"dequeue_algorithm");
	if(lp != NULL) {
		p->dequeue_algorithm = load_int(lp);
	}
	
	/* Load deleted */
	lp = find_field(section,"deleted");
	if(lp != NULL) {
		p->deleted = load_time_t(lp);
	}
	
	/* Load record_send */
	lp = find_field(section,"record_send");
	if(lp != NULL) {
		p->record_send = load_uint32_t(lp);
	}
	
	/* Load sends_per_user */
	lp = find_field(section,"sends_per_user");
	if(lp != NULL) {
		p->sends_per_user = load_int(lp);
	}
	
	/* Load stat_mib */
	lp = find_field(section,"stat_mib");
	if(lp != NULL) {
		p->stat_mib = load_uint32_t(lp);
	}
	
	/* Load send_min_bandwidth */
	lp = find_field(section,"send_min_bandwidth");
	if(lp != NULL) {
		p->send_min_bandwidth = load_unsigned_int(lp);
	}
	
	/* Load bandwidth */
	lp = find_field(section,"bandwidth");
	if(lp != NULL) {
		p->bandwidth = load_unsigned_int(lp);
	}
	
	/* Load record_rate */
	lp = find_field(section,"record_rate");
	if(lp != NULL) {
		p->record_rate = load_uint32_t(lp);
	}
	
	/* Load sends */
	lp = find_field(section,"sends");
	if(lp != NULL) {
		p->sends = load_unsigned_int(lp);
	}
	
	/* Load send_max_bandwidth */
	lp = find_field(section,"send_max_bandwidth");
	if(lp != NULL) {
		p->send_max_bandwidth = load_unsigned_int(lp);
	}
	
	/* Load csends */
	lpp = find_fields(section,"csends",&j);
	if(lpp != NULL) {
		for(i = 0; i < j; ++i) {
			vp = find_ptr(section,lpp[i]);
			if(vp != NULL)
				PTRARR_ADD(&(p->csends),&(p->no_csends),vp);
		}
		xfree(lpp);
	}
	
}


static void save_pool_t(config_t *config, pool_t *p) {
	section_t *section = new_section("pool_t",p);
	int i;

	/* Lock lock */
	LOCKR(&(p->lock));
	
	/* Save stat_carry */
	add_field_uint32_t(section,"stat_carry",p->stat_carry);
	
	/* Save name */
	add_field_char(section,"name",p->name);
	
	/* Save dequeue_algorithm */
	add_field_int(section,"dequeue_algorithm",p->dequeue_algorithm);
	
	/* Save deleted */
	add_field_time_t(section,"deleted",p->deleted);
	
	/* Save record_send */
	add_field_uint32_t(section,"record_send",p->record_send);
	
	/* Save sends_per_user */
	add_field_int(section,"sends_per_user",p->sends_per_user);
	
	/* Save stat_mib */
	add_field_uint32_t(section,"stat_mib",p->stat_mib);
	
	/* Save send_min_bandwidth */
	add_field_unsigned_int(section,"send_min_bandwidth",p->send_min_bandwidth);
	
	/* Save bandwidth */
	add_field_unsigned_int(section,"bandwidth",p->bandwidth);
	
	/* Save record_rate */
	add_field_uint32_t(section,"record_rate",p->record_rate);
	
	/* Save sends */
	add_field_unsigned_int(section,"sends",p->sends);
	
	/* Save send_max_bandwidth */
	add_field_unsigned_int(section,"send_max_bandwidth",p->send_max_bandwidth);
	
	/* Save csends */
	for(i = 0; i < p->no_csends; ++i) {
		save_send_t(config,p->csends[i]);
		add_field_ptr(section,"csends","send_t",p->csends[i]);
	}
	
	/* Unlock lock */
	UNLOCKR(&(p->lock));
	
	add_section(config,section);
}



static struct {
	char *type;
	void (*init)(section_t *);
	void (*deinit)(section_t *);
	void (*load)(section_t *);
	void (*ref_count)(section_t *);
} _section_funcs[] = {
	{"access_entry_t", init_access_entry_t, deinit_access_entry_t, load_access_entry_t, NULL},
	{"access_t", init_access_t, deinit_access_t, load_access_t, NULL},
	{"channel_t", init_channel_t, deinit_channel_t, load_channel_t, NULL},
	{"global_t", init_global_t, deinit_global_t, load_global_t, NULL},
	{"ignore_entry_t", init_ignore_entry_t, deinit_ignore_entry_t, load_ignore_entry_t, NULL},
	{"ignore_list_t", init_ignore_list_t, deinit_ignore_list_t, load_ignore_list_t, NULL},
	{"interface_t", init_interface_t, deinit_interface_t, load_interface_t, NULL},
	{"netset_t", init_netset_t, deinit_netset_t, load_netset_t, NULL},
	{"network_t", init_network_t, deinit_network_t, load_network_t, NULL},
	{"pack_t", init_pack_t, deinit_pack_t, load_pack_t, ref_count_pack_t},
	{"packlist_t", init_packlist_t, deinit_packlist_t, load_packlist_t, NULL},
	{"pool_t", init_pool_t, deinit_pool_t, load_pool_t, NULL},
	{"queue_t", init_queue_t, deinit_queue_t, load_queue_t, NULL},
	{"send_t", init_send_t, deinit_send_t, load_send_t, NULL},
	{"settings_t", init_settings_t, deinit_settings_t, load_settings_t, NULL},
	{"user_t", init_user_t, deinit_user_t, load_user_t, NULL},
	{NULL}
};