/**
 * KillServ Version 4.1
 *
 * Some Fun Ways To Kill A User
 *
 * This Module Is Compatible With Anope for Windows, Version 1.7.3 only
 *
 * This Module Is Compatible With Anope for *nix, Version 1.7.6 only
 *
 * While this module may compile on other versions, it will either
 *   fail to load, or can seriously cause problems with Services.
 *   Use on improper version is done at your own risk. You have been warned.
 *
 *
 * ***This Module Uses Commands Not Supported or "Recommended" by Anope Coders!***
 *   KillServ uses SVSKILL to remove users. This can cause desync problems with NickServ Logins!
 *     Don't complain to Anope support if you encounter errors!
 *
 **/

#include "module.h"

#define ksnick "KillServ"
#define ksident "Police"
#define kshost "Kill.You.Fast.Zell.Net"


#define AUTHOR "Zell"
#define VERSION "4.1"

int my_privmsg(char *source, int ac, char **av);
int event_kill(char *source, int ac, char **av);
int kslogcmds=1;
int ksglobals=0;
int ksadmins=1;
int ksenabled=1;
int kswallkill=1;
int ksrevenge=1;
CommandHash *Killserv_cmdTable[MAX_CMD_HASH];


void addClient(char *nick, char *realname);
void addMessageList(void);
void delClient(void);
char *s_KillServ = "KillServ";
void killserv(User * u, char *buf);


int do_peer(User * u);
int do_ping(User * u);
int do_flood(User * u);
int do_wline(User * u);
int do_ksset(User * u);
int do_help(User * u);
static int helpping(User * u);


int AnopeInit(int argc, char **argv)
{
    Message *msg = NULL;
    int status;
    msg = createMessage("PRIVMSG", my_privmsg);
    status = moduleAddMessage(msg, MOD_HEAD);
	msg = createMessage("KILL", event_kill);
	status = moduleAddMessage(msg, MOD_HEAD);
    if (status == MOD_ERR_OK) {
        addClient(s_KillServ, "KillMe");
        addMessageList();
    }
    moduleAddAuthor(AUTHOR);
    moduleAddVersion(VERSION);
    alog("KillServ: loaded, message status [%d]", status);
    return MOD_CONT;
}

int event_kill(char *source, int ac, char **av)
{
  if (!stricmp(s_KillServ,av[0])) {
    addClient(s_KillServ, "KillMe");
	if (kswallkill) {
		send_cmd(ServerName, "GLOBOPS :Alert: \2%s\2 used KILL on KillServ!", source);
	}
	if (ksrevenge) {
		send_cmd(ServerName, "SVSKILL %s :XKILLed (KillServ KILL Protection)", source);
	}
	return MOD_CONT;
  }
  return MOD_CONT;
} 

void AnopeFini()
{
    delClient();
}

int my_privmsg(char *source, int ac, char **av)
{
    User *u;
    char *s;

    /* First, some basic checks */
    if (ac != 2)
        return MOD_CONT;        /* bleh */
    if (!(u = finduser(source))) {
        return MOD_CONT;
    }                           /* non-user source */
    if (*av[0] == '#') {
        return MOD_CONT;
    }
    /* Channel message */
    /* we should prolly honour the ignore list here, but i cba for this... */
    s = strchr(av[0], '@');
    if (s) {
        *s++ = 0;
        if (stricmp(s, ServerName) != 0)
            return MOD_CONT;
    }
    if ((stricmp(av[0], s_KillServ)) == 0) {     /* its for US! */
        killserv(u, av[1]);
        return MOD_STOP;
    } else {                    /* ok it isnt us, let the old code have it */
        return MOD_CONT;
    }
}

void addClient(char *nick, char *realname)
{
#ifdef _WIN32
    NEWNICK(ksnick, ksident, kshost, realname, "+", 1);
	send_cmd(s_KillServ, "MODE %s +oNHSqip", s_KillServ);
#else
	anope_cmd_bot_nick(ksnick, ksident, kshost, realname, "oNHSqip");
#endif
}

void delClient(void)
{
    send_cmd(s_KillServ, "QUIT :Module Unloaded!");
}


void addMessageList(void)
{
    Command *c;
    c = createCommand("ping", do_ping, is_services_oper, -1, -1, -1, -1, -1);
    addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
    c = createCommand("peer", do_peer, is_services_oper, -1, -1, -1, -1, -1);
    addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
	c = createCommand("flood", do_flood, is_services_oper, -1, -1, -1, -1, -1);
    addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
	c = createCommand("wline", do_wline, is_services_admin, -1, -1, -1, -1, -1);
    addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
	c = createCommand("set", do_ksset, is_services_admin, -1, -1, -1, -1, -1);
	addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
	c = createCommand("help", do_help, is_services_oper, -1, -1, -1, -1, -1);
    addCommand(Killserv_cmdTable, c, MOD_UNIQUE);
}

/*****************************************************************************/
/* Main KillServ routine. */
void killserv(User * u, char *buf)
{
    char *cmd, *s;

    cmd = strtok(buf, " ");

    if (!cmd) {
        return;
    } else if (stricmp(cmd, "\1PING") == 0) {
        if (!(s = strtok(NULL, "")))
            s = "\1";
        notice(s_KillServ, u->nick, "\1PING %s", s);
    } else if (skeleton) {
        notice_lang(s_KillServ, u, SERVICE_OFFLINE, s_KillServ);
    } else {
        mod_run_cmd(s_KillServ, u, Killserv_cmdTable, cmd);
    }
}

int do_ping(User * u)
{
	char *nick = strtok(NULL, " ");

	if (!ksenabled)
	{
		notice(s_KillServ, u->nick, "Sorry, but KillServ is disabled in Config.");
		return MOD_STOP;
	}
	else {
		notice(s_KillServ, u->nick, "Killing %s with Ping Timeout message", nick);
		if (ksglobals)
		{
			send_cmd(s_KillServ, "GLOBOPS :%s just used PING on %s", u->nick, nick);
		}
		if (kslogcmds)
		{
			alog("%s: %s PING %s", s_KillServ, u->nick, nick);
		}
		if (ksadmins)
		{
			send_cmd(s_KillServ, "ADCHAT :%s just used PING on %s", u->nick, nick);
		}
		send_cmd(s_KillServ, "SVSKILL %s :Ping Timeout", nick);
		return MOD_STOP;
	}
}
int do_peer(User * u)
{
	char *nick = strtok(NULL, " ");

	if (!ksenabled)
	{
		notice(s_KillServ, u->nick, "Sorry, but KillServ is disabled in Config.");
		return MOD_STOP;
	}
	else
	{
		notice(s_KillServ, u->nick, "Killing %s with Reset by Peer message", nick);
		if (ksglobals)
		{
			send_cmd(s_KillServ, "GLOBOPS :%s just used PEER on %s", u->nick, nick);
		}
		if (kslogcmds)
		{
			alog("%s: %s PEER %s", s_KillServ, u->nick, nick);
		}
		if (ksadmins)
		{
			send_cmd(s_KillServ, "ADCHAT :%s just used PEER on %s", u->nick, nick);
		}
		send_cmd(s_KillServ, "SVSKILL %s :Connection Reset by Peer", nick);
		return MOD_STOP;
	}
}

int do_flood(User * u)
{
	char *nick = strtok(NULL, " ");

	if (!ksenabled)
	{
		notice(s_KillServ, u->nick, "Sorry, but KillServ is disabled in Config.");
		return MOD_STOP;
	}
	else {
		notice(s_KillServ, u->nick, "Killing %s with Flood message", nick);
		if (ksglobals)
		{
			send_cmd(s_KillServ, "GLOBOPS :%s just used FLOOD on %s", u->nick, nick);
		}
		if (kslogcmds)
		{
			alog("%s: %s FLOOD %s", s_KillServ, u->nick, nick);
		}
		if (ksadmins)
		{
			send_cmd(s_KillServ, "ADCHAT :%s just used FLOOD on %s", u->nick, nick);
		}
		send_cmd(s_KillServ, "SVSKILL %s :Excess Flood", nick);
		return MOD_STOP;
	}
}
int do_wline(User * u)
{
	char *nick = strtok(NULL, " ");

	if (!ksenabled)
	{
		notice(s_KillServ, u->nick, "Sorry, but KillServ is disabled in Config.");
		return MOD_STOP;
	}
	else {
		notice(s_KillServ, u->nick, "Killing %s with W:Line Message", nick);
		if (ksglobals)
		{
			send_cmd(s_KillServ, "GLOBOPS :%s just used WLINE on %s", u->nick, nick);
		}
		if (kslogcmds)
		{
			alog("%s: %s WLINE %s", s_KillServ, u->nick, nick);
		}
		if (ksadmins)
		{
			send_cmd(s_KillServ, "ADCHAT :%s just used WLINE on %s", u->nick, nick);
		}
		send_cmd(s_OperServ, "SVSKILL %s :User has been permanently banned (W:Lined)", nick);
		return MOD_STOP;
	}
}
//Function for Set command
int do_ksset(User * u)
{
	char *cmd = strtok(NULL, " ");
	char *opt = strtok(NULL, " ");

	if (!cmd)
	{
		//No Parameters were specified at all. Warn the user and stop.
		notice(s_KillServ, u->nick, "Syntax Error: Specify Option when using SET!");
		return MOD_STOP;
	}
	else if (!stricmp(cmd, "logcmds"))
	{
		//User said LOGCMDS -- now check if On/Off was specified. Is allowed to specify nothing.
		if (!opt)
		{
			//No On/Off specified. Is it enabled?
			if (!kslogcmds)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "Logging of Commands is Currently Disabled");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "Logging of Commands is Currently Enabled");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!kslogcmds)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Disabled the Logging of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				kslogcmds = 0;
				notice(s_KillServ, u->nick, "Disabled the Logging of Commands.");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to enable it.
			if (kslogcmds)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Enabled the Logging of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				kslogcmds = 1;
				notice(s_KillServ, u->nick, "Enabled the Logging of Commands.");
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and say the current setting.
			if (kslogcmds)
			{
				notice(s_KillServ, u->nick, "Logging is Currently Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "Logging is Currently Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	else if (!stricmp(cmd, "global"))
	{
		//User said GLOBAL. Did they say an option?
		if (!opt)
		{
			//No Option. Is it Enabled?
			if (!ksglobals)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "GlobOps of Commands is Currently Disabled");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "GlobOps of Commands is Currently Enabled");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!ksglobals)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Disabled the GlobOps of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				ksglobals = 0;
				notice(s_KillServ, u->nick, "Disabled the GlobOps of Commands.");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to Enable it.
			if (ksglobals)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Enabled the GlobOps of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				ksglobals = 1;
				notice(s_KillServ, u->nick, "Enabled the GlobOps of Commands.");
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and echo the current setting.
			if (ksglobals)
			{
				notice(s_KillServ, u->nick, "GlobOps of Commands is Currently Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "GlobOps of Commands is Currently Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	else if (!stricmp(cmd, "admin"))
	{
		//User said ADMIN. Did they say an option?
		if (!opt)
		{
			//No Option. Is it Enabled?
			if (!ksadmins)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "Admin-Notice of Commands is Currently Disabled");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "Admin-Notice of Commands is Currently Enabled");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!ksadmins)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Disabled the Admin-Notice of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				ksadmins = 0;
				notice(s_KillServ, u->nick, "Disabled the Admin-Notice of Commands.");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to Enable it.
			if (ksadmins)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Enabled the Admin-Notice of Commands.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				ksadmins = 1;
				notice(s_KillServ, u->nick, "Enabled the Admin-Notice of Commands.");
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and echo the current setting.
			if (ksadmins)
			{
				notice(s_KillServ, u->nick, "Admin-Notice of Commands is Currently Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "Admin-Notice of Commands is Currently Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	else if (!stricmp(cmd, "enabled"))
	{
		//User said ENABLED. Did they say an option?
		if (!opt)
		{
			//No Option. Is it Enabled?
			if (!ksenabled)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "KillServ is Currently Disabled");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "KillServ is Currently Enabled");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!ksenabled)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "KillServ has been Disabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				ksenabled = 0;
				notice(s_KillServ, u->nick, "KillServ has been Disabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has disabled KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to Enable it.
			if (ksenabled)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "KillServ has been Enabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				ksenabled = 1;
				notice(s_KillServ, u->nick, "KillServ has been Enabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has enabled KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and echo the current setting.
			if (ksenabled)
			{
				notice(s_KillServ, u->nick, "KillServ is Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "KillServ is Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	else if (!stricmp(cmd, "kill"))
	{
		//User said KILL. Did they say an option?
		if (!opt)
		{
			//No Option. Is it Enabled?
			if (!kswallkill)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "Global notice for Kills on KillServ is disabled.");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "Global notice for Kills on KillServ is enabled.");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!kswallkill)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Global Notice for Kills on KillServ has been disabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				kswallkill = 0;
				notice(s_KillServ, u->nick, "Global Notice for Kills on KillServ has been disabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has disabled Revenge GlobOps on KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to Enable it.
			if (kswallkill)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Global Notice for Kills on KillServ has been enabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				kswallkill = 1;
				notice(s_KillServ, u->nick, "Global Notice for Kills on KillServ has been enabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has enabled Revenge GlobOps on KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and echo the current setting.
			if (kswallkill)
			{
				notice(s_KillServ, u->nick, "Revenge GlobOps on KillServ is Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "Revenge GlobOps on KillServ is Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	else if (!stricmp(cmd, "revenge"))
	{
		//User said REVENGE. Did they say an option?
		if (!opt)
		{
			//No Option. Is it Enabled?
			if (!ksrevenge)
			{
				//Disabled. Tell the user.
				notice(s_KillServ, u->nick, "Revenge Kills for Kills on KillServ is disabled.");
				return MOD_STOP;
			}
			else
			{
				//Enabled. Tell the user.
				notice(s_KillServ, u->nick, "Revenge Kills for Kills on KillServ is enabled.");
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "off"))
		{
			//User wants to disable it.
			if (!ksrevenge)
			{
				//Its already off, but tell the user we disabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Revenge Kills for KillServ has been disabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we disable it.
				ksrevenge = 0;
				notice(s_KillServ, u->nick, "Revenge Kills for KillServ has been disabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has disabled Revenge Kills on KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else if (!stricmp(opt, "on"))
		{
			//User wants to Enable it.
			if (ksrevenge)
			{
				//Its already on, but tell the user we enabled it.
				//Sanity check to prevent writing the same number over itself.
				notice(s_KillServ, u->nick, "Revenge Kills for KillServ has been enabled.");
				return MOD_STOP;
			}
			else
			{
				//Now we enable it.
				ksrevenge = 1;
				notice(s_KillServ, u->nick, "Revenge Kills for KillServ has been enabled.");
				send_cmd(s_KillServ, "GLOBOPS :%s has enabled Revenge Kills on KillServ.", u->nick);
				return MOD_STOP;
			}
		}
		else
		{
			//You must have specified something other than On or Off.
			//Warning to the user, and echo the current setting.
			if (ksrevenge)
			{
				notice(s_KillServ, u->nick, "Revenge Kills on KillServ is Enabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u->nick, "Revenge Kills on KillServ is Disabled.");
				notice(s_KillServ, u->nick, "Syntax Error: only use parameters ON or OFF.");
				return MOD_STOP;
			}
		}	
	}
	//If we are here, then the user said something we dont recognize.
	//This could mean a typo, or user that can't read the help!! LoL --Zell
	else
	{
		//We need to tell the user what they said wrong.
		notice(s_KillServ, u->nick, "Sorry, \2%s\2 is not a valid command for SET.", cmd);
		//Tell them about the HELP feature.
		notice(s_KillServ, u->nick, "For more information, use \2/msg %s HELP SET", s_KillServ);
		//We have a %s pointing to s_KillServ in case the network has set a different name.
		//This module allows the network to use a name other than KillServ.
		return MOD_STOP;
	}
}

int do_help(User * u)
{
    u_char *cmd = strtok(NULL, " ");
	u_char *opt = strtok(NULL, " ");

    if (!cmd) {
        notice(s_KillServ, u->nick, " KillServ is a Network Killer. Commands:");
		notice(s_KillServ, u->nick, "   \2PING\2         Ping Timeout");
		notice(s_KillServ, u->nick, "   \2PEER\2        Connection Reset by Peer");
		notice(s_KillServ, u->nick, "   \2FLOOD\2         Excess Flood");
		if(is_services_admin(u)) {
			notice(s_KillServ, u->nick, "   Services Admin Commands:");
			notice(s_KillServ, u->nick, "   \2WLINE\2      W:Line Kill (Fake Ban Line)");
			notice(s_KillServ, u->nick, "   \2SET\2        Change KillServ Configuration");
		}
		if (ksenabled) {
			notice(s_KillServ, u->nick, "KillServ is Enabled.");
		}
		if (!ksenabled) {
			notice(s_KillServ, u->nick, "KillServ is Disabled. You cannot use commands other than HELP.");
		}
    } 

	else {
		if (!stricmp(cmd, "ping")) 
		{ 
			helpping(u);
			return MOD_STOP;
		}
		else if (!stricmp(cmd, "peer")) 
		{ 
			helppeer(u);
			return MOD_STOP;
		}
		else if (!stricmp(cmd, "flood")) 
		{ 
			helpfld(u);
			return MOD_STOP;
		}
		else if (!stricmp(cmd, "wline")) 
		{ 
			if (is_services_admin(u))
			{
				helpwlin(u);
				return MOD_STOP;
			}
			else
			{
				notice(s_KillServ, u-> nick, " Access Denied ");
				return MOD_STOP;
			}
		}
		else if (!stricmp(cmd, "set"))
		{
			if (is_services_admin(u))
			{
				if (!opt)
				{
					helpkset(u);
					return MOD_STOP;
				}
				if (!stricmp(opt, "logcmds"))
				{
					helpksetl(u);
					return MOD_STOP;
				}
				else if (!stricmp(opt, "global"))
				{
					helpksetg(u);
					return MOD_STOP;
				}
				else if (!stricmp(opt, "admin"))
				{
					helpkseta(u);
					return MOD_STOP;
				}
				else if (!stricmp(opt, "enabled"))
				{
					helpksete(u);
					return MOD_STOP;
				}
				else if (!stricmp(opt, "kill"))
				{
					helpksetk(u);
					return MOD_STOP;
				}
				else if (!stricmp(opt, "revenge"))
				{
					helpksetr(u);
					return MOD_STOP;
				}
				else {
					helpkset(u);
					return MOD_STOP;
				}
			}
			else
			{
				notice(s_KillServ, u->nick, " Access Denied ");
				return MOD_STOP;
			}
		}
		else { notice(s_KillServ, u->nick, "Invalid Command or No Help Available for %s", cmd); }
    }
    return MOD_CONT;
}

static int helpping(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2PING\2 Nick"); /* Help */
	notice(s_KillServ, u->nick, "Boot 'em");
	return MOD_CONT;		/* required statement */
}

int helppeer(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2PEER\2 Nick"); /* Help */
	notice(s_KillServ, u->nick, "Boot 'em");
	return MOD_CONT;		/* required statement */
}
int helpfld(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2FLOOD\2 Nick"); /* Help */
	notice(s_KillServ, u->nick, "Boot 'em");
	return MOD_CONT;		/* required statement */
}
int helpwlin(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2WLINE\2 Nick"); /* Help */
	notice(s_KillServ, u->nick, "Boot 'em");
	return MOD_CONT;		/* required statement */
}
int helpkset(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET\2 [OPTION] [On/Off] "); /* Help */
	notice(s_KillServ, u->nick, "Options: [LOGCMDS] [GLOBAL] [ADMIN] [ENABLED] ");
	notice(s_KillServ, u->nick, "For help, /msg KillServ HELP SET OPTION");
	return MOD_CONT;
}
int helpksetl(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET LOGCMDS\2 [On/Off] ");
	notice(s_KillServ, u->nick, "Enable or Disable logging of Command Usage");
	return MOD_CONT;
}
int helpksetg(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET GLOBAL\2 [On/Off] ");
	notice(s_KillServ, u->nick, "Enable or Disable GlobOps on Command Usage");
	return MOD_CONT;
}
int helpkseta(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET ADMIN\2 [On/Off] ");
	notice(s_KillServ, u->nick, "Enable or Disable AdminChat Notice on Command Usage");
	return MOD_CONT;
}
int helpksete(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET ENABLED\2 [On/Off] ");
	notice(s_KillServ, u->nick, "Enable or Disable KillServ");
	return MOD_CONT;
}
int helpksetk(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET KILL\2 [On/Off] ");
	notice(s_KillServ, u->nick, "Enable or Disable GlobOps when KillServ is Killed.");
	return MOD_CONT;
}
int helpksetr(User * u) {
	notice(s_KillServ, u->nick, "Syntax: \2SET REVENGE\2 [On/Off] ");
	notice(s_KillServ, u->nick, "When Enabled, KillServ will Kill any user who kills it.");
	return MOD_CONT;
}