/************
 *  cset.c  *
 ************
 *
 * My code for creating all the "Channel Sets" on a per channel
 * basis. We manage them here, and then just insert/remove/return them 
 * when a channel calls for them.
 * Code for creating and modifying "Window Sets" on a per window
 * basis. 
 *
 * Note: Notice the shameless use of typecasting to get these functions
 *	 to work as painlessly as possible.
 *
 * Written by Scott H Kilau
 * Modified by Colten D Edwards for /wset
 *
 * Copyright(c) 1997
 *
 * See the COPYRIGHT file, or do a HELP IRCII COPYRIGHT
 */

#if 0
[Sheik(~sheik@spartan.pei.edu)] notice in struct.h that the cset struct *does*
          have a ->next pointer.. thats for the future when we may want to
                    daisy chain cset's that don't have channels yet..  ie  a user can
                              /cset *warez*  and know that all warez channels would get defaulted
#endif                              

#include "irc.h"
static char cvsrevision[] = "$Id: cset.c,v 1.1.1.1 2003/04/11 01:09:07 dan Exp $";
CVS_REVISION(cset_c)
#include "struct.h"
#include "vars.h"    /* for do_boolean() and var_settings[] */
#include "window.h"  /* for get_current_channel_by_refnum() */
#include "screen.h"  /* for curr_scr_win */
#include "names.h"   /* for lookup_channel() */
#include "log.h"
#include "ircaux.h"
#include "status.h"
#include "server.h"
#include "output.h"
#include "misc.h"
#include "list.h"
#include "cset.h"
#include "hash2.h"
#define MAIN_SOURCE
#include "modval.h"

void log_channel(CSetArray *, CSetList *);
void limit_channel(CSetArray *, CSetList *);
void set_msglog_channel_level(CSetArray *, CSetList *);

/*
 * Array of structures for each of the cset vars... allows us to
 * get an offset into the CSetList struct to that var
 */
static CSetArray cset_array[] = {
{ "AINV",			INT_TYPE_VAR,	offsetof(CSetList, set_ainv) ,NULL, 0 },
{ "ANNOY_KICK",			BOOL_TYPE_VAR,	offsetof(CSetList, set_annoy_kick) ,NULL, 0 },
{ "AOP",			BOOL_TYPE_VAR,	offsetof(CSetList, set_aop) ,NULL, 0 },
{ "AUTO_JOIN_ON_INVITE",	BOOL_TYPE_VAR,	offsetof(CSetList, set_auto_join_on_invite), NULL, 0 },
{ "AUTO_LIMIT",			INT_TYPE_VAR,	offsetof(CSetList, set_auto_limit), limit_channel, 0 },
{ "AUTO_REJOIN",		INT_TYPE_VAR,   offsetof(CSetList, set_auto_rejoin) ,NULL, 0 },
{ "BANTIME",			INT_TYPE_VAR,	offsetof(CSetList, set_bantime), NULL, 0 },
{ "BITCH",			BOOL_TYPE_VAR,	offsetof(CSetList, bitch_mode) ,NULL, 0 },
{ "CHANMODE",			STR_TYPE_VAR,	offsetof(CSetList, chanmode), NULL, 0 },
{ "CHANNEL_LOG",		BOOL_TYPE_VAR,	offsetof(CSetList, channel_log) ,log_channel, 0 },
{ "CHANNEL_LOG_FILE",		STR_TYPE_VAR,	offsetof(CSetList, channel_log_file), NULL, 0 },
{ "CHANNEL_LOG_LEVEL",		STR_TYPE_VAR,	offsetof(CSetList, log_level), set_msglog_channel_level, 0 },
{ "COMPRESS_MODES",		BOOL_TYPE_VAR,	offsetof(CSetList, compress_modes) ,NULL, 0 },
{ "CTCP_FLOOD_BAN",		BOOL_TYPE_VAR,	offsetof(CSetList, set_ctcp_flood_ban), NULL, 0 },
{ "DEOPFLOOD",			BOOL_TYPE_VAR,	offsetof(CSetList, set_deopflood) ,NULL, 0 },
{ "DEOPFLOOD_TIME",		INT_TYPE_VAR,	offsetof(CSetList, set_deopflood_time) ,NULL, 0 },
{ "DEOP_ON_DEOPFLOOD",		INT_TYPE_VAR,	offsetof(CSetList, set_deop_on_deopflood) ,NULL, 0 },
{ "DEOP_ON_KICKFLOOD",		INT_TYPE_VAR,	offsetof(CSetList, set_deop_on_kickflood) ,NULL, 0 },
{ "HACKING",			INT_TYPE_VAR,	offsetof(CSetList, set_hacking) ,NULL, 0 },
{ "JOINFLOOD",			BOOL_TYPE_VAR,	offsetof(CSetList, set_joinflood) ,NULL, 0 },
{ "JOINFLOOD_TIME",		INT_TYPE_VAR,	offsetof(CSetList, set_joinflood_time) ,NULL, 0 },
{ "KICKFLOOD",			BOOL_TYPE_VAR,	offsetof(CSetList, set_kickflood) ,NULL, 0 },
{ "KICKFLOOD_TIME",		INT_TYPE_VAR,	offsetof(CSetList, set_kickflood_time) ,NULL, 0 },
{ "KICK_IF_BANNED",		BOOL_TYPE_VAR,  offsetof(CSetList, set_kick_if_banned) ,NULL, 0 },
{ "KICK_ON_DEOPFLOOD",		INT_TYPE_VAR,   offsetof(CSetList, set_kick_on_deopflood) ,NULL, 0 },
{ "KICK_ON_JOINFLOOD",		INT_TYPE_VAR,	offsetof(CSetList, set_kick_on_joinflood) ,NULL, 0 },
{ "KICK_ON_KICKFLOOD",		INT_TYPE_VAR,   offsetof(CSetList, set_kick_on_kickflood) ,NULL, 0 },
{ "KICK_ON_NICKFLOOD",		INT_TYPE_VAR,   offsetof(CSetList, set_kick_on_nickflood) ,NULL, 0 },
{ "KICK_ON_PUBFLOOD",		INT_TYPE_VAR,   offsetof(CSetList, set_kick_on_pubflood) ,NULL, 0 },
{ "KICK_OPS",			BOOL_TYPE_VAR,	offsetof(CSetList, set_kick_ops), NULL, 0 },
{ "LAMEIDENT",			BOOL_TYPE_VAR,	offsetof(CSetList, set_lame_ident), NULL, 0},
{ "LAMELIST",			BOOL_TYPE_VAR,  offsetof(CSetList, set_lamelist) ,NULL, 0 },
{ "NICKFLOOD",			BOOL_TYPE_VAR,	offsetof(CSetList, set_nickflood) ,NULL, 0 },
{ "NICKFLOOD_TIME",		INT_TYPE_VAR,	offsetof(CSetList, set_nickflood_time) ,NULL, 0 },
{ "PUBFLOOD",			BOOL_TYPE_VAR,	offsetof(CSetList, set_pubflood) ,NULL, 0 },
{ "PUBFLOOD_IGNORE_TIME",	INT_TYPE_VAR,	offsetof(CSetList, set_pubflood_ignore) ,NULL, 0 },
{ "PUBFLOOD_TIME",		INT_TYPE_VAR,	offsetof(CSetList, set_pubflood_time) ,NULL, 0 },
{ "SHITLIST",			BOOL_TYPE_VAR,  offsetof(CSetList, set_shitlist) ,NULL, 0 },
{ "USERLIST",			BOOL_TYPE_VAR,  offsetof(CSetList, set_userlist) ,NULL, 0 },
{ NULL,				0,		0, NULL, 0 }
};

static WSetArray wset_array[] = {
{ "STATUS_AWAY",		STR_TYPE_VAR,	offsetof(WSet, status_away),		offsetof(WSet, away_format), BX_build_status },
{ "STATUS_CDCCCOUNT",		STR_TYPE_VAR,	offsetof(WSet, status_cdcccount),	offsetof(WSet, cdcc_format), BX_build_status },
{ "STATUS_CHANNEL",		STR_TYPE_VAR,	offsetof(WSet, status_channel),		offsetof(WSet, channel_format), BX_build_status },
{ "STATUS_CHANOP",		STR_TYPE_VAR,	offsetof(WSet, status_chanop),		-1, BX_build_status },
{ "STATUS_CLOCK",		STR_TYPE_VAR,	offsetof(WSet, status_clock),		offsetof(WSet, clock_format), BX_build_status },
{ "STATUS_CPU_SAVER",		STR_TYPE_VAR,	offsetof(WSet, status_cpu_saver), 	offsetof(WSet, cpu_saver_format), BX_build_status },
{ "STATUS_DCCCOUNT",		STR_TYPE_VAR,	offsetof(WSet, status_dcccount),	offsetof(WSet, dcccount_format), BX_build_status },
{ "STATUS_FLAG",		STR_TYPE_VAR,   offsetof(WSet, status_flag),		offsetof(WSet, flag_format), BX_build_status },
{ "STATUS_FORMAT",              STR_TYPE_VAR,   offsetof(WSet, format_status),		-1, BX_build_status },
{ "STATUS_FORMAT1",             STR_TYPE_VAR,   offsetof(WSet, format_status[1]),	-1, BX_build_status },
{ "STATUS_FORMAT2",             STR_TYPE_VAR,   offsetof(WSet, format_status[2]),	-1, BX_build_status },
{ "STATUS_FORMAT3",             STR_TYPE_VAR,   offsetof(WSet, format_status[3]),	-1, BX_build_status },
{ "STATUS_HALFOP",		STR_TYPE_VAR,	offsetof(WSet, status_halfop),		-1, BX_build_status },
{ "STATUS_HOLD",		STR_TYPE_VAR,	offsetof(WSet, status_hold),		-1, BX_build_status },
{ "STATUS_HOLD_LINES",		STR_TYPE_VAR,	offsetof(WSet, status_hold_lines),	offsetof(WSet, hold_lines_format), BX_build_status },
{ "STATUS_LAG",			STR_TYPE_VAR,	offsetof(WSet, status_lag),		offsetof(WSet, lag_format), BX_build_status },
{ "STATUS_MAIL",		STR_TYPE_VAR,	offsetof(WSet, status_mail),		offsetof(WSet, mail_format), BX_build_status },
{ "STATUS_MODE",		STR_TYPE_VAR,	offsetof(WSet, status_mode),		offsetof(WSet, mode_format), BX_build_status },
{ "STATUS_MSGCOUNT",		STR_TYPE_VAR,	offsetof(WSet, status_msgcount),	offsetof(WSet, msgcount_format), BX_build_status },
{ "STATUS_NICK",		STR_TYPE_VAR,	offsetof(WSet, status_nick),		offsetof(WSet, nick_format), BX_build_status },
{ "STATUS_NOTIFY",		STR_TYPE_VAR,	offsetof(WSet, status_notify),		offsetof(WSet, notify_format), BX_build_status },
{ "STATUS_OPER_KILLS",		STR_TYPE_VAR,	offsetof(WSet, status_oper_kills),	offsetof(WSet, kills_format), BX_build_status },
{ "STATUS_QUERY",		STR_TYPE_VAR,	offsetof(WSet, status_query),		offsetof(WSet, query_format), BX_build_status },
{ "STATUS_SCROLLBACK",		STR_TYPE_VAR,	offsetof(WSet, status_scrollback),	-1, BX_build_status },
{ "STATUS_SERVER",		STR_TYPE_VAR,	offsetof(WSet, status_server),		offsetof(WSet, server_format), BX_build_status },
{ "STATUS_TOPIC",		STR_TYPE_VAR,	offsetof(WSet, status_topic),		offsetof(WSet, topic_format), BX_build_status },
{ "STATUS_UMODE",		STR_TYPE_VAR,	offsetof(WSet, status_umode),		offsetof(WSet, umode_format), BX_build_status },
{ "STATUS_USER0",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats0),	-1, BX_build_status },
{ "STATUS_USER1",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats1),	-1, BX_build_status },
{ "STATUS_USER10",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats10),	-1, BX_build_status },
{ "STATUS_USER11",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats11),	-1, BX_build_status },
{ "STATUS_USER12",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats12),	-1, BX_build_status },
{ "STATUS_USER13",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats13),	-1, BX_build_status },
{ "STATUS_USER14",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats14),	-1, BX_build_status },
{ "STATUS_USER15",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats15),	-1, BX_build_status },
{ "STATUS_USER16",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats16),	-1, BX_build_status },
{ "STATUS_USER17",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats17),	-1, BX_build_status },
{ "STATUS_USER18",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats18),	-1, BX_build_status },
{ "STATUS_USER19",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats19),	-1, BX_build_status },
{ "STATUS_USER2",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats2),	-1, BX_build_status },
{ "STATUS_USER20",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats20),	-1, BX_build_status },
{ "STATUS_USER21",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats21),	-1, BX_build_status },
{ "STATUS_USER22",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats22),	-1, BX_build_status },
{ "STATUS_USER23",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats23),	-1, BX_build_status },
{ "STATUS_USER24",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats24),	-1, BX_build_status },
{ "STATUS_USER25",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats25),	-1, BX_build_status },
{ "STATUS_USER26",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats26),	-1, BX_build_status },
{ "STATUS_USER27",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats27),	-1, BX_build_status },
{ "STATUS_USER28",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats28),	-1, BX_build_status },
{ "STATUS_USER29",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats29),	-1, BX_build_status },
{ "STATUS_USER3",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats3),	-1, BX_build_status },
{ "STATUS_USER30",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats30),	-1, BX_build_status },
{ "STATUS_USER31",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats31),	-1, BX_build_status },
{ "STATUS_USER32",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats32),	-1, BX_build_status },
{ "STATUS_USER33",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats33),	-1, BX_build_status },
{ "STATUS_USER34",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats34),	-1, BX_build_status },
{ "STATUS_USER35",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats35),	-1, BX_build_status },
{ "STATUS_USER36",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats36),	-1, BX_build_status },
{ "STATUS_USER37",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats37),	-1, BX_build_status },
{ "STATUS_USER38",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats38),	-1, BX_build_status },
{ "STATUS_USER39",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats39),	-1, BX_build_status },
{ "STATUS_USER4",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats4),	-1, BX_build_status },
{ "STATUS_USER5",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats5),	-1, BX_build_status },
{ "STATUS_USER6",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats6),	-1, BX_build_status },
{ "STATUS_USER7",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats7),	-1, BX_build_status },
{ "STATUS_USER8",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats8),	-1, BX_build_status },
{ "STATUS_USER9",		STR_TYPE_VAR,	offsetof(WSet, status_user_formats9),	-1, BX_build_status },
{ "STATUS_USERS",		STR_TYPE_VAR,	offsetof(WSet, status_users),		offsetof(WSet, status_users_format), BX_build_status },
{ "STATUS_VOICE",		STR_TYPE_VAR,	offsetof(WSet, status_voice),		-1, BX_build_status },
{ "STATUS_WINDOW",		STR_TYPE_VAR,	offsetof(WSet, status_window),		-1, BX_build_status },
{ NULL,				0,		0, -1, NULL } 
};

CSetList *cset_queue = NULL;

/*
 * returns the requested int from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
int BX_get_cset_int_var(CSetList *tmp, int var)
{
	int val = *(int *)((void *)tmp + cset_array[var].offset);
	return val;
}

char *BX_get_cset_str_var(CSetList *tmp, int var)
{
	char *s = *(char **) ((void *)tmp + cset_array[var].offset);
	return s;
}

/*
 * returns the requested int from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
int cset_getflag(CSetList *tmp, int var)
{
	int val = *(int *)((void *)tmp + cset_array[var].flag);
	return val;
}

/*
 * sets the requested int from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
void cset_setflag(CSetList *tmp, int var, int value)
{
	int *ptr = (int *) ((void *)tmp + cset_array[var].flag);
	*ptr = value;
}

/*
 * returns the requested int ADDRESS from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
static void * get_cset_int_var_address(CSetList *tmp, int var)
{
	void *ptr = ((void *)tmp + cset_array[var].offset);
	return ptr;
}



/*
 * sets the requested int from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
void BX_set_cset_int_var(CSetList *tmp, int var, int value)
{
	int *ptr = (int *) ((void *)tmp + cset_array[var].offset);
	*ptr = value;
}


void BX_set_cset_str_var(CSetList *tmp, int var, char *value)
{
	char **ptr = (char **) ((void *)tmp + cset_array[var].offset);
	if (value)
		malloc_strcpy(ptr, value);
	else
		new_free(ptr);
}

/*
 * Next few functions ripped from vars.c, as we are really doing the same
 * thing as those functions did, with a couple changes... The nice
 * thing about this is that we will get the same "feel" now with
 * SET's and CSET's
 */
static int find_cset_variable(CSetArray *array, char *org_name, int *cnt)
{
	CSetArray *v, *first;
	int     len, var_index;
	char    *name = NULL;

	len = strlen(org_name);
	name = alloca(len + 1);
	strcpy(name, org_name);

	upper(name);
	var_index = 0;
	for (first = array; first->name; first++, var_index++) 
	{
		if (strncmp(name, first->name, len) == 0) 
		{
			*cnt = 1;
			break;
		}
	}
	if (first->name) 
	{
		if (strlen(first->name) != len) 
		{
			v = first;
			for (v++; v->name; v++, (*cnt)++) 
			{
				if (strncmp(name, v->name, len) != 0)
					break;
			}
		}
		return (var_index);
	}
	else 
	{
		*cnt = 0;
		return (-1);
	}
}


static void set_cset_var_value(CSetList *tmp, int var_index, char *value)
{
	char    *rest;
	CSetArray *var;

	var = &(cset_array[var_index]);

	switch (var->type) 
	{
	case BOOL_TYPE_VAR:
        	if (value && *value && (value = next_arg(value, &rest))) {
			if (do_boolean(value, (int *)get_cset_int_var_address(tmp, var_index)))
			{
				say("Value must be either ON, OFF, or TOGGLE");
				break;
			}
			if (var->func)
				var->func(var, tmp);
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF]));
		}
		else 
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF]));
		break;

	case INT_TYPE_VAR:
		if (value && *value && (value = next_arg(value, &rest))) 
		{
			int     val;

			if (!is_number(value)) 
			{
				say("Value of %s must be numeric!", var->name);
				break;
			}
			if ((val = atoi(value)) < 0) 
			{
				say("Value of %s must be greater than 0", var->name);
				break;
			}
			set_cset_int_var(tmp, var_index, val);
			if (var->func)
				var->func(var, tmp);
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index)));
		}
		else 
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index)));
		break;
	case STR_TYPE_VAR:
		if (value && *value)
		{
			set_cset_str_var(tmp, var_index, value);
			if (var->func)
				var->func(var, tmp);
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_str_var(tmp, var_index) ));
		}
		else
			put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, (char *)get_cset_str_var(tmp, var_index)));
	}
}

CSetList *check_cset_queue(char *channel, int add)
{
	CSetList *c = NULL;
	int found = 0;
	if (!strchr(channel, '*') && !(c = (CSetList *)find_in_list((List **)&cset_queue, channel, 0)))
	{
		if (!add) 
		{
			for (c = cset_queue; c; c = c->next)
				if (!my_stricmp(c->channel, channel) || wild_match(c->channel, channel))
					return c;
			return NULL;
		}
		c = create_csets_for_channel(channel);
		add_to_list((List **)&cset_queue, (List *)c);
		found++;
	}
	if (c)
		return c;
	if (add && !found)
	{
		for (c = cset_queue; c; c = c->next)
			if (!my_stricmp(c->channel, channel))
				return c;
		c = create_csets_for_channel(channel);
		c->next = cset_queue;
		cset_queue = c;
		return c;
	}
	return NULL;
}

static inline void cset_variable_case1(char *channel, int var_index, char *args)
{
	ChannelList *chan = NULL;
	int tmp = 0;
	int count = 0;
	/* 
	 * implement a queue for channels that don't exist... later...
	 * go home if user doesn't have any channels.
	 */
	if (current_window->server != -1)
	{
		for (chan = get_server_channels(current_window->server); chan; chan = chan->next) 
		{
			tmp = var_index;
			if (wild_match(channel, chan->channel))
			{
				set_cset_var_value(chan->csets, tmp, args);
				count++;
			}
		}
	}
	/* no channel match. lets check the queue */
/*	if (!count)*/
	{
		CSetList *c = NULL;
		if (!count)
			check_cset_queue(channel, 1);
		for (c = cset_queue; c; c = c->next)
		{
			tmp = var_index;
			if (!my_stricmp(channel, c->channel) || wild_match(channel, c->channel))
			{
				set_cset_var_value(c, tmp, args);
				count++;
			}
		}
		if (!count)
			say("CSET_VARIABLE: No match in cset queue for %s", channel);
	}
}

static inline void cset_variable_casedef(char *channel, int cnt, int var_index, char *args)
{
	ChannelList *chan = NULL; 
	int tmp, tmp2;
	int count = 0;
	
	if (current_window->server != -1)
	{
		for (chan = get_server_channels(current_window->server); chan; chan = chan->next) 
		{
			tmp = var_index;
			tmp2 = cnt;
			if (wild_match(channel, chan->channel)) 
			{
				for (tmp2 += tmp; tmp < tmp2; tmp++)
					set_cset_var_value(chan->csets, tmp, empty_string);
				count++;
			}
		}
	}
/*	if (!count) */
	{
		CSetList *c = NULL;
		if (!count)
			check_cset_queue(channel, 1);
		for (c = cset_queue; c; c = c->next)
		{
			tmp = var_index;
			tmp2 = cnt;
			if (!my_stricmp(channel, c->channel) || wild_match(channel, c->channel))
			{
				for (tmp2 +=tmp; tmp < tmp2; tmp++)
					set_cset_var_value(c, tmp, empty_string);
				count++;
			}
		}
		if (!count)
			say("CSET_VARIABLE: No match in cset queue for %s", channel);
		return;
	}

}

static inline void cset_variable_noargs(char *channel)
{
	int var_index = 0;
	ChannelList *chan = NULL; 
	int count = 0;

	if (current_window->server != -1)
	{
		for (chan = get_server_channels(current_window->server); chan; chan = chan->next) 
		{
			if (wild_match(channel, chan->channel)) 
			{	
				for (var_index = 0; var_index < NUMBER_OF_CSETS; var_index++)
					set_cset_var_value(chan->csets, var_index, empty_string);
				count++;
			}
		}
	}
/*	if (!count) */
	{
		CSetList *c = NULL;
		if (!count)
			check_cset_queue(channel, 1);
		for (c = cset_queue; c; c = c->next)
		{
			if (!wild_match(channel, c->channel))
				continue;
			for (var_index = 0; var_index < NUMBER_OF_CSETS; var_index++)
				set_cset_var_value(c, var_index, empty_string);
			count++;
		}
		if (!count)
			say("CSET_VARIABLE: No match in cset queue for %s", channel ? channel : empty_string);
		return;
	}

}

char *set_cset(char *var, ChannelList *chan, char *value)
{
int var_index, cnt = 0;
	var_index = find_cset_variable(cset_array, var, &cnt);
	if (cnt == 1)
	{
		CSetArray *var;
		var = &(cset_array[var_index]);
		switch(var->type)
		{
			case BOOL_TYPE_VAR:
			{
				int i = my_atol(value);
				set_cset_int_var(chan->csets, var_index, i? 1 : 0);
				break;
			}
			case INT_TYPE_VAR:
			{
				int i = my_atol(value);
				set_cset_int_var(chan->csets, var_index, i);
				break;
			}
			case STR_TYPE_VAR:
			{
				set_cset_str_var(chan->csets, var_index, value);
				break;
			}
			default:
				return NULL;
		}
		return value;
	}
	return NULL;
}

char *get_cset(char *var, ChannelList *chan, char *value)
{
int var_index, cnt = 0;
	var_index = find_cset_variable(cset_array, var, &cnt);
	if (cnt == 1)
	{
		char s[81];
		CSetArray *var;
		var = &(cset_array[var_index]);
		*s = 0;
		switch (var->type)
		{
			case BOOL_TYPE_VAR:
			{
				strcpy(s, get_cset_int_var(chan->csets, var_index)?var_settings[ON] : var_settings[OFF]);
				if (value)
				{
					int val = -1;
					if (!my_stricmp(value, on))
						val = 1;
					else if (!my_stricmp(value, off))
						val = 0;
					else
					{
						if (isdigit((unsigned char)*value))
							val = (int)(*value - '0');
					}
					if (val != -1)
						set_cset_int_var(chan->csets, var_index, val);
				}
				break;
			}
			case INT_TYPE_VAR:
			{
				strncpy(s, ltoa(get_cset_int_var(chan->csets, var_index)), 30);
				if (value && isdigit((unsigned char)*value))
					set_cset_int_var(chan->csets, var_index, my_atol(value)); 
				break;
			}
			case STR_TYPE_VAR:
			{
				char *t;
				t = m_strdup(get_cset_str_var(chan->csets, var_index));
				if (value)
					set_cset_str_var(chan->csets, var_index, value);
				return t;
			}
		}		
		return m_strdup(s && *s ? s : empty_string);
	}
	return m_strdup(empty_string);
}

BUILT_IN_COMMAND(cset_variable)
{
	char    *var, *channel = NULL;
	int     no_args = 1, cnt, var_index, hook = 1;

	if (from_server != -1 && current_window->server != -1)
	{
		if (args && *args && (is_channel(args) || *args == '*'))
			channel = next_arg(args, &args);
		else
			channel = get_current_channel_by_refnum(0);
	}
	else if (args && *args && (is_channel(args) || *args == '*'))
		channel = next_arg(args, &args);
		
	if (!channel)
		return;

	if ((var = next_arg(args, &args)) != NULL) 
	{
		if (*var == '-') 
		{
			var++;
			args = NULL;
		}
		var_index = find_cset_variable(cset_array, var, &cnt);
		
		if (hook)
		{
			switch (cnt) 
			{
				case 0:
					say("No such variable \"%s\"", var);
					return;
				case 1:
					cset_variable_case1(channel, var_index, args);
					return;
				default:
					say("%s is ambiguous", var);
					cset_variable_casedef(channel, cnt, var_index, args);
					return;
			}
		}
	}
	if (no_args)
		cset_variable_noargs(channel);
}

CSetList *create_csets_for_channel(char *channel)
{
	CSetList *tmp; 
#ifdef VAR_DEBUG
 	int i;
	
	for (i = 1; i < NUMBER_OF_CSETS - 1; i++)
		if (strcmp(cset_array[i-1].name, cset_array[i].name) >= 0)
			ircpanic("Variable [%d] (%s) is out of order.", i, cset_array[i].name);
#endif

	if (check_cset_queue(channel, 0))
	{
		if ((tmp = (CSetList *)find_in_list((List **)&cset_queue, channel, 0)))
			return tmp;
		for (tmp = cset_queue; tmp; tmp = tmp->next)
			if (!my_stricmp(tmp->channel, channel) || wild_match(tmp->channel, channel))
				return tmp;
	}		
	tmp = (CSetList *) new_malloc(sizeof(CSetList));
	/* use default settings. */
	tmp->set_aop = get_int_var(AOP_VAR);
	tmp->set_annoy_kick = get_int_var(ANNOY_KICK_VAR);
	tmp->set_ainv = get_int_var(AINV_VAR);
	tmp->set_auto_join_on_invite = get_int_var(AUTO_JOIN_ON_INVITE_VAR);
	tmp->set_auto_rejoin = get_int_var(AUTO_REJOIN_VAR);
	tmp->set_bantime = get_int_var(BANTIME_VAR);
	tmp->compress_modes = get_int_var(COMPRESS_MODES_VAR);
	tmp->bitch_mode = get_int_var(BITCH_VAR);
	tmp->channel_log = 0;
	
	tmp->log_level = m_strdup("ALL");	
	set_msglog_channel_level(cset_array, tmp); 
#if defined(WINNT) || defined(__EMX__)
	tmp->channel_log_file = m_sprintf("~/bx-conf/%s.log", channel+1);
#else
	tmp->channel_log_file = m_sprintf("~/.BitchX/%s.log", channel+1);
#endif
	tmp->set_joinflood = get_int_var(JOINFLOOD_VAR);
	tmp->set_joinflood_time = get_int_var(JOINFLOOD_TIME_VAR);
	tmp->set_ctcp_flood_ban = get_int_var(CTCP_FLOOD_BAN_VAR);
	tmp->set_deop_on_deopflood = get_int_var(DEOP_ON_DEOPFLOOD_VAR);
	tmp->set_deop_on_kickflood = get_int_var(DEOP_ON_KICKFLOOD_VAR);
	tmp->set_deopflood = get_int_var(DEOPFLOOD_VAR);
	tmp->set_deopflood_time = get_int_var(DEOPFLOOD_TIME_VAR);

	tmp->set_hacking = get_int_var(HACKING_VAR);

	tmp->set_kick_on_deopflood = get_int_var(KICK_ON_DEOPFLOOD_VAR);
	tmp->set_kick_on_joinflood = get_int_var(KICK_ON_JOINFLOOD_VAR);
	tmp->set_kick_on_kickflood = get_int_var(KICK_ON_KICKFLOOD_VAR);
	tmp->set_kick_on_nickflood = get_int_var(KICK_ON_NICKFLOOD_VAR);
	tmp->set_kick_on_pubflood = get_int_var(KICK_ON_PUBFLOOD_VAR);

	tmp->set_kickflood = get_int_var(KICKFLOOD_VAR);
	tmp->set_kickflood_time = get_int_var(KICKFLOOD_TIME_VAR);
	tmp->set_kick_ops = get_int_var(KICK_OPS_VAR);
	tmp->set_nickflood = get_int_var(NICKFLOOD_VAR);
	tmp->set_nickflood_time = get_int_var(NICKFLOOD_TIME_VAR);

	tmp->set_pubflood = get_int_var(PUBFLOOD_VAR);
	tmp->set_pubflood_time = get_int_var(PUBFLOOD_TIME_VAR);
	tmp->set_pubflood_ignore = 60;
	tmp->set_userlist = get_int_var(USERLIST_VAR);
	tmp->set_shitlist = get_int_var(SHITLIST_VAR);
	tmp->set_lamelist = get_int_var(LAMELIST_VAR);
	tmp->set_lame_ident = get_int_var(LAMEIDENT_VAR);
	tmp->set_kick_if_banned = get_int_var(KICK_IF_BANNED_VAR);
	tmp->set_auto_limit = get_int_var(AUTO_LIMIT_VAR);

	
	malloc_strcpy(&tmp->chanmode, get_string_var(CHANMODE_VAR));
	malloc_strcpy(&tmp->channel, channel);

	return tmp;
}

void remove_csets_for_channel(CSetList *tmp)
{
	new_free(&tmp->channel);
	new_free(&tmp->channel_log_file);
	new_free(&tmp->chanmode);
	new_free(&tmp);
}



static int find_wset_variable(WSetArray *array, char *org_name, int *cnt)
{
	WSetArray *v, *first;
	int     len, var_index;
	char    *name = NULL;

	len = strlen(org_name);
	name = alloca(len + 1);
	strcpy(name, org_name);

	upper(name);
	var_index = 0;
	for (first = array; first->name; first++, var_index++) 
	{
		if (strncmp(name, first->name, len) == 0) 
		{
			*cnt = 1;
			break;
		}
	}
	if (first->name) 
	{
		if (strlen(first->name) != len) 
		{
			v = first;
			for (v++; v->name; v++, (*cnt)++) 
			{
				if (strncmp(name, v->name, len) != 0)
					break;
			}
		}
		return (var_index);
	}
	else 
	{
		*cnt = 0;
		return (-1);
	}
}




/*
 * returns the requested int from the cset struct
 * Will work fine with either BOOL or INT type of csets.
 */
char *BX_get_wset_string_var(WSet *tmp, int var)
{
	char **ptr = (char **)((unsigned long)tmp + wset_array[var].offset);
	return *ptr;
}

/*
 * returns the requested int ADDRESS from the wset struct
 * Will work fine with STR_TYPE_VAR type of csets.
 */
static char ** get_wset_str_var_address(WSet *tmp, int var)
{
	char **ptr = (char **)((unsigned long)tmp + wset_array[var].offset);
	return ptr;
}

/*
 * returns the requested int ADDRESS from the wset struct
 * Will work fine with STR_TYPE_VAR type of csets.
 */
char ** get_wset_format_var_address(WSet *tmp, int var)
{
	char **ptr = NULL;
	if (wset_array[var].format_offset != -1)
		ptr = (char **)((unsigned long)tmp + wset_array[var].format_offset);
	return ptr;
}

/*
 * sets the requested string from the wset struct
 */

void BX_set_wset_string_var(WSet *tmp, int var, char *value)
{
	char **ptr = (char **)((unsigned long)tmp + wset_array[var].offset);
	if (value && *value)
		malloc_strcpy(ptr, value);
	else
		new_free(ptr);
}





static void set_wset_var_value(Window *win, int var_index, char *value)
{
	WSetArray *var;

	var = &(wset_array[var_index]);

	switch (var->type) 
	{
	case STR_TYPE_VAR:
		{
			char **val = NULL;
			if ((val = get_wset_str_var_address(win->wset, var_index))) 
			{
				if (value)
				{
					if (*value)
						malloc_strcpy(val, value);
					else
					{
						put_it("%s", convert_output_format(fget_string_var(FORMAT_SET_FSET), "%s %s", var->name, *val?*val:empty_string));
						return;
					}
				} else
					new_free(val);
				if (var->func)
					(var->func) (win, *val, 0);
				say("Value of %s set to %s", var->name, *val ?
					*val : "<EMPTY>");
			}
		}
		break;
	default:
		say("WSET_type not supported");
	}
}

static inline void wset_variable_case1(Window *win, char *name, int var_index, char *args)
{
Window *tmp = NULL;
int count = 0;
int i;
	if (!name)
	{
		set_wset_var_value(win, var_index, args);
		return;
	}
	while ((traverse_all_windows(&tmp)))
	{
		i = var_index;
		if (*name == '*')
		{
			set_wset_var_value(tmp, i, args);
			count++;
		}
		else if ((tmp->name && wild_match(name, tmp->name)) || (tmp->refnum == my_atol(name)))
		{
			set_wset_var_value(tmp, i, args);
			count++;
		}
	}
	if (!count)
		say("No such window name [%s]", name);
}

static inline void wset_variable_casedef(Window *win, char *name, int cnt, int var_index, char *args)
{
Window *tmp = NULL;
int count = 0;
int c, i;
	if (!name)
	{
		for (cnt +=var_index; var_index < cnt; var_index++)
			set_wset_var_value(win, var_index, args);
		return;
	}
	while ((traverse_all_windows(&tmp)))
	{
		c = cnt;
		i = var_index;
		if (*name == '*')
		{
			for (c += i; i < c; i++)
				set_wset_var_value(tmp, i, empty_string);
			count++;
		}
		else if ((tmp->name && wild_match(name, tmp->name)) || (tmp->refnum == my_atol(name)) ) 
		{
			for (c += i; i < c; i++)
				set_wset_var_value(tmp, i, empty_string);
			count++;
		}
	}
	if (!count)
		say("No such window name [%s]", name);
}

static inline void wset_variable_noargs(Window *win, char *name)
{
Window *tmp = NULL;
int var_index = 0;
	if (!name)
	{
		for (var_index = 0; var_index < NUMBER_OF_WSETS; var_index++)
			set_wset_var_value(win, var_index, empty_string);
	} 
	else
	{
		int count = 0;
		while ((traverse_all_windows(&tmp)))
		{
			if (*name == '*')
			{
				for (var_index = 0; var_index < NUMBER_OF_WSETS; var_index++)
					set_wset_var_value(tmp, var_index, empty_string);
				count++;
			}
			else if ((tmp->name && wild_match(name, tmp->name)) || (tmp->refnum == my_atol(name)))
			{
				for (var_index = 0; var_index < NUMBER_OF_WSETS; var_index++)
					set_wset_var_value(tmp, var_index, empty_string);
				count++;
			}
		}
		if (!count)
			say("No such window name [%s]", name);
	}
}


BUILT_IN_COMMAND(wset_variable)
{
	char    *var;
	char	*possible;
	char 	*name = NULL;
	int     no_args = 1, cnt, var_index;
	Window *win = screen_list->window_list;

	if (args)
	{
		if (*args == '*')
			name = next_arg(args, &args);
		else if (args && *args)
		{
			possible = LOCAL_COPY(args);
			name = next_arg(possible, &possible);
			if (!(win = get_window_by_name(name)))
			{
				win = get_window_by_refnum(my_atol(name));
				if (!win)
				{
					if (isdigit((unsigned char)*name))
					{
						say("No such window refnum %d", my_atol(name));
						return;
					}
				} 
				else if (isdigit((unsigned char)*name))
					var = next_arg(args, &args);
				name = NULL;
			}
			else
				var = next_arg(args, &args);
		}
	}
	else 
		win = current_window;

	
	if ((var = next_arg(args, &args)) != NULL) 
	{
		if (*var == '-') 
		{
			var++;
			args = NULL;
		}
		var_index = find_wset_variable(wset_array, var, &cnt);
		switch (cnt) 
		{
			case 0:
				say("No such variable \"%s\"", var);
				return;
			case 1:
				wset_variable_case1(win, name, var_index, args);
				update_all_status(win, NULL, 0);
				update_all_windows();
				return;
			default:
				say("%s is ambiguous", var);
				wset_variable_casedef(win, name, cnt, var_index, args);
				return;
		}
	}
	if (no_args) 
		wset_variable_noargs(win, name);
}


WSet *create_wsets_for_window(Window *win)
{
	WSet *tmp; 
#ifdef VAR_DEBUG
 	int i;
	
	for (i = 1; i < NUMBER_OF_CSETS - 1; i++)
		if (strcmp(wset_array[i-1].name, wset_array[i].name) >= 0)
			ircpanic("Variable [%d] (%s) is out of order.", i, wset_array[i].name);
#endif

	tmp = (WSet *) new_malloc(sizeof(WSet));

	malloc_strcpy(&tmp->status_channel, get_string_var(STATUS_CHANNEL_VAR));
	malloc_strcpy(&tmp->status_chanop, get_string_var(STATUS_CHANOP_VAR));
	malloc_strcpy(&tmp->status_halfop, get_string_var(STATUS_HALFOP_VAR));
	malloc_strcpy(&tmp->status_clock, get_string_var(STATUS_CLOCK_VAR));
	malloc_strcpy(&tmp->status_hold_lines, get_string_var(STATUS_HOLD_LINES_VAR));
	malloc_strcpy(&tmp->status_hold, get_string_var(STATUS_HOLD_VAR));
	malloc_strcpy(&tmp->status_voice, get_string_var(STATUS_VOICE_VAR));
	malloc_strcpy(&tmp->status_dcccount, get_string_var(STATUS_DCCCOUNT_VAR));
	malloc_strcpy(&tmp->status_cdcccount, get_string_var(STATUS_CDCCCOUNT_VAR));
	malloc_strcpy(&tmp->status_cpu_saver, get_string_var(STATUS_CPU_SAVER_VAR));
	malloc_strcpy(&tmp->status_lag, get_string_var(STATUS_LAG_VAR));
	malloc_strcpy(&tmp->status_away, get_string_var(STATUS_AWAY_VAR));
	malloc_strcpy(&tmp->status_mail, get_string_var(STATUS_MAIL_VAR));
	malloc_strcpy(&tmp->status_mode, get_string_var(STATUS_MODE_VAR));
	malloc_strcpy(&tmp->status_notify, get_string_var(STATUS_NOTIFY_VAR));
	malloc_strcpy(&tmp->status_oper_kills, get_string_var(STATUS_OPER_KILLS_VAR));
	malloc_strcpy(&tmp->status_query, get_string_var(STATUS_QUERY_VAR));
	malloc_strcpy(&tmp->status_server, get_string_var(STATUS_SERVER_VAR));
	malloc_strcpy(&tmp->status_topic, get_string_var(STATUS_TOPIC_VAR));
	malloc_strcpy(&tmp->status_umode, get_string_var(STATUS_UMODE_VAR));
	malloc_strcpy(&tmp->status_users, get_string_var(STATUS_USERS_VAR));
	malloc_strcpy(&tmp->status_msgcount, get_string_var(STATUS_MSGCOUNT_VAR));
	malloc_strcpy(&tmp->status_nick, get_string_var(STATUS_NICK_VAR));
	malloc_strcpy(&tmp->status_flag, get_string_var(STATUS_FLAG_VAR));		
	malloc_strcpy(&tmp->status_scrollback, get_string_var(STATUS_SCROLLBACK_VAR));

	malloc_strcpy(&tmp->format_status[0], get_string_var(STATUS_FORMAT_VAR));
	malloc_strcpy(&tmp->format_status[1], get_string_var(STATUS_FORMAT1_VAR));
	malloc_strcpy(&tmp->format_status[2], get_string_var(STATUS_FORMAT2_VAR));
	malloc_strcpy(&tmp->format_status[3], get_string_var(STATUS_FORMAT3_VAR));

	malloc_strcpy(&tmp->status_user_formats0, get_string_var(STATUS_USER0_VAR));
	malloc_strcpy(&tmp->status_user_formats1, get_string_var(STATUS_USER1_VAR));
	malloc_strcpy(&tmp->status_user_formats10, get_string_var(STATUS_USER10_VAR));
	malloc_strcpy(&tmp->status_user_formats11, get_string_var(STATUS_USER11_VAR));
	malloc_strcpy(&tmp->status_user_formats12, get_string_var(STATUS_USER12_VAR));
	malloc_strcpy(&tmp->status_user_formats13, get_string_var(STATUS_USER13_VAR));
	malloc_strcpy(&tmp->status_user_formats14, get_string_var(STATUS_USER14_VAR));
	malloc_strcpy(&tmp->status_user_formats15, get_string_var(STATUS_USER15_VAR));
	malloc_strcpy(&tmp->status_user_formats16, get_string_var(STATUS_USER16_VAR));
	malloc_strcpy(&tmp->status_user_formats17, get_string_var(STATUS_USER17_VAR));
	malloc_strcpy(&tmp->status_user_formats18, get_string_var(STATUS_USER18_VAR));
	malloc_strcpy(&tmp->status_user_formats19, get_string_var(STATUS_USER19_VAR));
	malloc_strcpy(&tmp->status_user_formats2, get_string_var(STATUS_USER2_VAR));
	malloc_strcpy(&tmp->status_user_formats20, get_string_var(STATUS_USER20_VAR));
	malloc_strcpy(&tmp->status_user_formats21, get_string_var(STATUS_USER21_VAR));
	malloc_strcpy(&tmp->status_user_formats22, get_string_var(STATUS_USER22_VAR));
	malloc_strcpy(&tmp->status_user_formats23, get_string_var(STATUS_USER23_VAR));
	malloc_strcpy(&tmp->status_user_formats24, get_string_var(STATUS_USER24_VAR));
	malloc_strcpy(&tmp->status_user_formats25, get_string_var(STATUS_USER25_VAR));
	malloc_strcpy(&tmp->status_user_formats26, get_string_var(STATUS_USER26_VAR));
	malloc_strcpy(&tmp->status_user_formats27, get_string_var(STATUS_USER27_VAR));
	malloc_strcpy(&tmp->status_user_formats28, get_string_var(STATUS_USER28_VAR));
	malloc_strcpy(&tmp->status_user_formats29, get_string_var(STATUS_USER29_VAR));
	malloc_strcpy(&tmp->status_user_formats3, get_string_var(STATUS_USER3_VAR));
	malloc_strcpy(&tmp->status_user_formats30, get_string_var(STATUS_USER30_VAR));
	malloc_strcpy(&tmp->status_user_formats31, get_string_var(STATUS_USER31_VAR));
	malloc_strcpy(&tmp->status_user_formats32, get_string_var(STATUS_USER32_VAR));
	malloc_strcpy(&tmp->status_user_formats33, get_string_var(STATUS_USER33_VAR));
	malloc_strcpy(&tmp->status_user_formats34, get_string_var(STATUS_USER34_VAR));
	malloc_strcpy(&tmp->status_user_formats35, get_string_var(STATUS_USER35_VAR));
	malloc_strcpy(&tmp->status_user_formats36, get_string_var(STATUS_USER36_VAR));
	malloc_strcpy(&tmp->status_user_formats37, get_string_var(STATUS_USER37_VAR));
	malloc_strcpy(&tmp->status_user_formats38, get_string_var(STATUS_USER38_VAR));
	malloc_strcpy(&tmp->status_user_formats39, get_string_var(STATUS_USER39_VAR));
	malloc_strcpy(&tmp->status_user_formats4, get_string_var(STATUS_USER4_VAR));
	malloc_strcpy(&tmp->status_user_formats5, get_string_var(STATUS_USER5_VAR));
	malloc_strcpy(&tmp->status_user_formats6, get_string_var(STATUS_USER6_VAR));
	malloc_strcpy(&tmp->status_user_formats7, get_string_var(STATUS_USER7_VAR));
	malloc_strcpy(&tmp->status_user_formats8, get_string_var(STATUS_USER8_VAR));
	malloc_strcpy(&tmp->status_user_formats9, get_string_var(STATUS_USER9_VAR));
	malloc_strcpy(&tmp->status_window, get_string_var(STATUS_WINDOW_VAR));
	win->wset = tmp;	
	return tmp;
}

void remove_wsets_for_window(Window *tmp)
{
	new_free(&tmp->wset->status_channel);
	new_free(&tmp->wset->status_clock); 
	new_free(&tmp->wset->status_hold_lines);
	new_free(&tmp->wset->status_hold);
	new_free(&tmp->wset->status_voice);
	new_free(&tmp->wset->status_dcccount);
	new_free(&tmp->wset->status_cdcccount);
	new_free(&tmp->wset->status_lag); 
	new_free(&tmp->wset->status_away); 
	new_free(&tmp->wset->status_nick);
	new_free(&tmp->wset->status_flag);	
	new_free(&tmp->wset->status_mail);
	new_free(&tmp->wset->status_msgcount);
	new_free(&tmp->wset->status_cpu_saver);
	new_free(&tmp->wset->status_chanop);
	new_free(&tmp->wset->status_mode);
	
	new_free(&tmp->wset->status_notify);
	new_free(&tmp->wset->status_oper_kills);
	new_free(&tmp->wset->status_query);
	new_free(&tmp->wset->status_server);
	new_free(&tmp->wset->status_topic);
	new_free(&tmp->wset->status_umode);
	new_free(&tmp->wset->status_users);
	new_free(&tmp->wset->status_scrollback);
	new_free(&tmp->wset->status_halfop);	

	new_free(&tmp->wset->status_user_formats1);
	new_free(&tmp->wset->status_user_formats10);
	new_free(&tmp->wset->status_user_formats11);
	new_free(&tmp->wset->status_user_formats12);
	new_free(&tmp->wset->status_user_formats13);
	new_free(&tmp->wset->status_user_formats14);
	new_free(&tmp->wset->status_user_formats15);
	new_free(&tmp->wset->status_user_formats16);
	new_free(&tmp->wset->status_user_formats17);
	new_free(&tmp->wset->status_user_formats18);
	new_free(&tmp->wset->status_user_formats19);
	new_free(&tmp->wset->status_user_formats2);
	new_free(&tmp->wset->status_user_formats20);
	new_free(&tmp->wset->status_user_formats21);
	new_free(&tmp->wset->status_user_formats22);
	new_free(&tmp->wset->status_user_formats23);
	new_free(&tmp->wset->status_user_formats24);
	new_free(&tmp->wset->status_user_formats25);
	new_free(&tmp->wset->status_user_formats26);
	new_free(&tmp->wset->status_user_formats27);
	new_free(&tmp->wset->status_user_formats28);
	new_free(&tmp->wset->status_user_formats29);
	new_free(&tmp->wset->status_user_formats3);
	new_free(&tmp->wset->status_user_formats30);
	new_free(&tmp->wset->status_user_formats31);
	new_free(&tmp->wset->status_user_formats32);
	new_free(&tmp->wset->status_user_formats33);
	new_free(&tmp->wset->status_user_formats34);
	new_free(&tmp->wset->status_user_formats35);
	new_free(&tmp->wset->status_user_formats36);
	new_free(&tmp->wset->status_user_formats37);
	new_free(&tmp->wset->status_user_formats38);
	new_free(&tmp->wset->status_user_formats39);
	new_free(&tmp->wset->status_user_formats4);
	new_free(&tmp->wset->status_user_formats5);
	new_free(&tmp->wset->status_user_formats6);
	new_free(&tmp->wset->status_user_formats7);
	new_free(&tmp->wset->status_user_formats8);
	new_free(&tmp->wset->status_user_formats9);
	new_free(&tmp->wset->status_user_formats0);

	new_free(&tmp->wset->format_status[0]);
	new_free(&tmp->wset->format_status[1]);
	new_free(&tmp->wset->format_status[2]);
	new_free(&tmp->wset->format_status[3]); 

	new_free(&tmp->wset->status_format[0]);
	new_free(&tmp->wset->status_format[1]);
	new_free(&tmp->wset->status_format[2]);
	new_free(&tmp->wset->status_format[3]); 
	new_free(&tmp->wset->status_line[0]);
	new_free(&tmp->wset->status_line[1]);
	new_free(&tmp->wset->status_line[2]);

	new_free(&tmp->wset->mode_format);
	new_free(&tmp->wset->umode_format);
	new_free(&tmp->wset->topic_format);
	new_free(&tmp->wset->query_format);
	new_free(&tmp->wset->clock_format);
	new_free(&tmp->wset->hold_lines_format);
	new_free(&tmp->wset->channel_format);
	new_free(&tmp->wset->mail_format);
	new_free(&tmp->wset->server_format);
	new_free(&tmp->wset->notify_format);
	new_free(&tmp->wset->kills_format);
	new_free(&tmp->wset->lag_format);
	new_free(&tmp->wset->cpu_saver_format);
	new_free(&tmp->wset->msgcount_format);
	new_free(&tmp->wset->dcccount_format);
	new_free(&tmp->wset->cdcc_format);
	new_free(&tmp->wset->nick_format);
	new_free(&tmp->wset->away_format);
	new_free(&tmp->wset->flag_format);
	new_free(&tmp->wset->status_users_format);
	new_free(&tmp->wset->status_window);
	new_free(&tmp->wset->window_special_format);
	new_free(&tmp->wset);
}

void log_channel(CSetArray *var, CSetList *cs)
{
	ChannelList *chan;
	if (!cs->channel_log_file)
	{
		bitchsay("Try setting a channel log file first");
		set_cset_int_var(cs, CHANNEL_LOG_CSET, 0);
		return;
	}
	if ((chan = lookup_channel(cs->channel, from_server, 0)))
		do_log(cs->channel_log, cs->channel_log_file, &chan->msglog_fp);
}

void set_msglog_channel_level(CSetArray *var, CSetList *cs)
{
	ChannelList *chan;
	if ((chan = lookup_channel(cs->channel, from_server, 0)))
	{
		chan->log_level = parse_lastlog_level(cs->log_level, 1);
		set_cset_str_var(cs, CHANNEL_LOG_LEVEL_CSET, bits_to_lastlog_level(chan->log_level));
	}
}

void do_logchannel(unsigned long level, ChannelList *chan, char *format, ...)
{
	if (!chan || !get_cset_int_var(chan->csets, CHANNEL_LOG_CSET))
		return;
	if ((chan->log_level & level) && format)
	{
		char s[BIG_BUFFER_SIZE+1];
		va_list args;
		va_start(args, format);
		vsnprintf(s, BIG_BUFFER_SIZE, format, args);
		va_end(args);
		add_to_log(chan->msglog_fp, now, s, logfile_line_mangler);
	}
}

void set_channel_limit(ChannelList *channel, int currentlimit, int add, int numusers)
{
	if ((now - channel->limit_time) < 30)
		return;
	if (add && numusers)
	{
		if ((currentlimit - numusers) < (add / 2) && ((numusers + add) != currentlimit))
			my_send_to_server(channel->server, "MODE %s +l %d", channel->channel, numusers + add);
		else if ((currentlimit - numusers) > (currentlimit + (add / 2)) && ((numusers + add) != currentlimit))
			my_send_to_server(channel->server, "MODE %s +l %d", channel->channel, numusers + add);
	}
	else
		my_send_to_server(channel->server, "MODE %s -l", channel->channel);
	channel->limit_time = now;
}

void check_channel_limit(ChannelList *chan)
{
	if (chan && chan->csets && chan->csets->set_auto_limit && chan->chop)
	{
		int count = 0;
		NickList *nick;
		for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
			count++;
		set_channel_limit(chan, chan->limit, chan->csets->set_auto_limit, count);
	}
}

void limit_channel(CSetArray *var, CSetList *cs)
{
ChannelList *chan;
	if ((chan = lookup_channel(cs->channel, from_server, 0)))
	{
		if (cs->set_auto_limit)
		{
			int count = 0;
			NickList *nick;
			for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
				count++;
			set_channel_limit(chan, chan->limit, cs->set_auto_limit, count);
		} else
			set_channel_limit(chan, chan->limit, 0, 0);
	}
}

#ifdef GUI
CSetArray *return_cset_var(int nummer)
{
   return &cset_array[nummer];
}

WSetArray *return_wset_var(int nummer)
{
   return &wset_array[nummer];
}
#endif

