/* bzflag
 * Copyright (c) 1993 - 2005 Tim Riker
 *
 * This package is free software;  you can redistribute it and/or
 * modify it under the terms of the license found in the file
 * named LICENSE that should have accompanied this file.
 *
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifdef _MSC_VER
#pragma warning( 4:4786)
#endif

// interface header
#include "commands.h"

#include "WorldEventManager.h"

// system implementation headers
#include <vector>
#include <string>
#include <sstream>
#ifdef HAVE_CSTDIO
#include <cstdio>
#else
#include <stdio.h>
#endif
#ifdef HAVE_CSTRING
#include <cstring>
#else
#include <string.h>
#endif
#include <time.h>

// common implementation headers
#include "Address.h"
#include "CommandManager.h"
#include "LagInfo.h"
#include "NetHandler.h"
#include "PlayerInfo.h"
#include "TimeKeeper.h"
#include "VotingArbiter.h"
#include "global.h"
#include "version.h"

// local implementation headers
#include "CmdLineOptions.h"
#include "FlagHistory.h"
#include "FlagInfo.h"
#include "PackVars.h"
#include "Permissions.h"
#include "RecordReplay.h"
#include "MasterBanList.h"


#if defined(_WIN32)
#define popen _popen
#define pclose _pclose
#endif

//"Race to 7" by RPG
bool match_in_progress = false;
//End "Race to 7" by RPG

// FIXME -- need to pull communication out of bzfs.cxx...

// extern to initialize permission groups
extern void initGroups();

// externs that poll, veto, vote, and clientquery require
extern void sendMessage(int playerIndex, PlayerId dstPlayer, const char *message);
extern void sendPlayerMessage(GameKeeper::Player *playerData, PlayerId dstPlayer,
			      const char *message);
extern CmdLineOptions *clOptions;
extern uint16_t curMaxPlayers;

// externs that ghost needs
extern void removePlayer(int playerIndex, const char *reason, bool notify=true);
extern void playerKilled(int victimIndex, int killerIndex, int reason, int16_t shotIndex, const FlagType* flagType, int phydrv, bool respawnOnBase = false);
// externs that shutdownserver requires
extern bool done;

// externs that superkill and gameover requires
extern bool gameOver;
extern char *getDirectMessageBuffer();
extern void broadcastMessage(uint16_t code, int len, const void *msg);

#include "PlayerInfo.h"
extern TeamInfo team[NumTeams];
extern void sendTeamUpdate(int playerIndex = -1, int teamIndex1 = -1, int teamIndex2 = -1);
extern int numFlags;
extern void zapFlag(FlagInfo & flag);
extern void sendFlagUpdate(FlagInfo &flag);
extern void resetFlag(FlagInfo &flag);
extern void sendDrop(FlagInfo &flag);

// externs that countdown requires
extern bool countdownActive;
extern int countdownDelay;
extern TimeKeeper countdownPauseStart;

// externs that identify and password requires
extern void sendIPUpdate(int targetPlayer, int playerIndex);
extern void sendPlayerInfo(void);

// externs that the flag command requires
extern void zapAllFlags();

tmCustomSlashCommandMap	customCommands;

class NoDigit {
public:
  bool operator() (char c) {return !isdigit(c);}
};

int getSlotNumber(std::string player) {
  int slot = -1; // invalid
  if (player[0] == '#') {
    // string player is a slot number
    player[0] = '0';
    if(find_if(player.begin(), player.end(), NoDigit()) == player.end()) {
      // a valid number is in the string
      slot = atoi(player.c_str());
    }
  } else {
    // invalid number.. may be a player callsign
    slot = GameKeeper::Player::getPlayerIDByName(player);
  }
  
  GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(slot);
  if (!p)
    slot = -1; // not a player

  return slot;
}

static void handleMuteCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::mute)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the unmute command");
    return;
  }
  
  
  std::vector<std::string> argv = TextUtils::tokenize(message, " \t", 3, true);

  if (argv.size() < 2) {
    sendMessage(ServerPlayer, t, "Syntax: /mute <#slot | PlayerName | \"Player Name\">");
    return;
  }
  
  int i = getSlotNumber(argv[1]);
  
  char msg[MessageLen];
  
  // Player not found
  if (i < 0) {
    snprintf(msg, MessageLen, "player \"%s\" not found", argv[1].c_str());
    sendMessage(ServerPlayer, t, msg);
    return;
  }
  
  // mute the player
  GameKeeper::Player *muteData = GameKeeper::Player::getPlayerByIndex(i);
  if (muteData) {
    muteData->accessInfo.revokePerm(PlayerAccessInfo::talk);
    snprintf(msg, MessageLen, "You have been muted by %s.", playerData->player.getCallSign());
    sendMessage(ServerPlayer, i, msg);
    // confirm player is muted
    snprintf(msg, MessageLen, "player id #%d \"%s\" is now muted.", i, muteData->player.getCallSign());
    sendMessage(ServerPlayer, t, msg);
  }
}

static void handleUnmuteCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::mute)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the unmute command");
    return;
  }
  
  
  std::vector<std::string> argv = TextUtils::tokenize(message, " \t", 3, true);

  if (argv.size() < 2) {
    sendMessage(ServerPlayer, t, "Syntax: /unmute <#slot | PlayerName | \"Player Name\">");
    return;
  }
  
  int i = getSlotNumber(argv[1]);
  
  char msg[MessageLen];
  
  // Player not found
  if (i < 0) {
    snprintf(msg, MessageLen, "player \"%s\" not found", argv[1].c_str());
    sendMessage(ServerPlayer, t, msg);
    return;
  }
  
  // unmute the player
  GameKeeper::Player *unmuteData = GameKeeper::Player::getPlayerByIndex(i);
  if (unmuteData) {
    unmuteData->accessInfo.grantPerm(PlayerAccessInfo::talk);
    snprintf(msg, MessageLen, "You have been unmuted by %s.", playerData->player.getCallSign());
    sendMessage(ServerPlayer, i, msg);
    // confirm player is unmuted
    snprintf(msg, MessageLen, "player id #%d \"%s\" is now unmuted.", i, unmuteData->player.getCallSign());
    sendMessage(ServerPlayer, t, msg);
  }
}

static void handleUptimeCmd(GameKeeper::Player *playerData, const char *)
{
  float rawTime;
  int t = playerData->getIndex();
  char reply[MessageLen] = {0};

  rawTime = float(TimeKeeper::getCurrent() - TimeKeeper::getStartTime());
  snprintf(reply, MessageLen, "%s.", TimeKeeper::printTime(rawTime).c_str());
  sendMessage(ServerPlayer, t, reply);
}

static void handleServerQueryCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  DEBUG2("Server query requested by %s [%d]\n",
	 playerData->player.getCallSign(), t);

  sendMessage(ServerPlayer, t,
	      TextUtils::format("BZFS Version: %s", getAppVersion()).c_str());
  return;
}


static void handlePartCmd(GameKeeper::Player *playerData, const char *message)
{
  std::string byeStatement = "";

  if (strlen(message) > 5) {
    if (!TextUtils::isWhitespace(*(message+5))) {
      char reply[MessageLen] = {0};
      snprintf(reply, MessageLen, "Unknown command [%s]", message);
      sendMessage(ServerPlayer, playerData->getIndex(), reply);
      return;
    }
    byeStatement = message + 6;
  }

  if (byeStatement[0] != '\0') {
    std::string message2;
    message2 = TextUtils::format("%s has left (\"%s\") ",
				 playerData->player.getCallSign(),  byeStatement.c_str());

    DEBUG2("%s has quit with the message \"%s\"\n", playerData->player.getCallSign(), byeStatement.c_str());
    sendMessage(ServerPlayer, AllPlayers, message2.c_str());
  }

  // now to kick the player
  int t = playerData->getIndex();
  removePlayer(t, byeStatement.c_str());
}


static void handleQuitCmd(GameKeeper::Player *playerData, const char *message)
{
  std::string byeStatement = "";

  if (strlen(message) > 5) {
    if (!TextUtils::isWhitespace(*(message+5))) {
      char reply[MessageLen] = {0};
      snprintf(reply, MessageLen, "Unknown command [%s]", message);
      sendMessage(ServerPlayer, playerData->getIndex(), reply);
      return;
    }
    byeStatement = message + 6;
  }

  if (byeStatement[0] != '\0') {
    std::string message2;
    message2 = TextUtils::format("%s has quit (\"%s\") ",
				 playerData->player.getCallSign(),  byeStatement.c_str());

    DEBUG2("%s has quit with the message \"%s\"\n", playerData->player.getCallSign(), byeStatement.c_str());
    sendMessage(ServerPlayer, AllPlayers, message2.c_str());
  }

  // now to kick the player
  int t = playerData->getIndex();
  removePlayer(t, byeStatement.c_str());
}


static void handleMsgCmd(GameKeeper::Player *playerData, const char *message)
{
  int from = playerData->getIndex();
  int to= -1;

  std::string message2;
  size_t callsignStart=0, callsignEnd=0, messageStart=0;

  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::privateMessage)) {
    char reply[MessageLen] = {0};
    snprintf(reply, MessageLen, "%s, you are not presently authorized to /msg people privately", playerData->player.getCallSign());
    sendMessage(ServerPlayer, from, reply);
    return;
  }

  // start from after "/msg"
  std::string arguments = &message[4];
  std::string recipient = std::string("");

  // skip any leading whitespace
  callsignStart = 0;
  while ((callsignStart < arguments.size()) &&
	 (isspace(arguments[callsignStart]))) {
    callsignStart++;
  }

  // make sure there was _some_ whitespace after /msg
  if (callsignStart == 0) {
    sendMessage(ServerPlayer, from, "Usage: /msg \"some callsign\" some message");
    return;
  }

  // find the player name, optionally quoted
  if (arguments[callsignStart] == '"') {
    callsignStart++;

    // find the trailing quote
    bool foundQuote = false;
    callsignEnd = callsignStart;
    while ((callsignEnd + 1 < arguments.size()) &&
	   (!foundQuote)) {
      callsignEnd++;
      if (arguments[callsignEnd] == '"') {
	foundQuote = true;
	messageStart = callsignEnd + 1;
	callsignEnd--;
      }
    }

    // no quote means a mismatch
    if (!foundQuote) {
      sendMessage(ServerPlayer, from, "Quote mismatch?");
      sendMessage(ServerPlayer, from, "Usage: /msg \"some callsign\" some message");
      return;
    }

  } else {
    // unquoted callsign

    // find the first matching name (not the longest for sake of performance)
    bool foundCallsign = false;
    callsignEnd = callsignStart;
    while ((callsignEnd + 1 < arguments.size()) &&
	   (!foundCallsign)) {
      callsignEnd++;
      if (!isspace(arguments[callsignEnd])) {
	continue;
      }

      // we have a space
      recipient = arguments.substr(callsignStart, callsignEnd - callsignStart);
      messageStart = callsignEnd;

      to = GameKeeper::Player::getPlayerIDByName(recipient);
      if (to < curMaxPlayers) {
	callsignEnd--;
	foundCallsign = true;
      }
    }
  }

  recipient = arguments.substr(callsignStart, callsignEnd - callsignStart + 1);

  if (recipient[0] == '>') {
    // /msg >admin sends on admin channel, /msg >team on team channel
    recipient.erase(0,1);
    if (TextUtils::toupper(recipient) == "ADMIN") 
      to = AdminPlayers;				
    else if (TextUtils::toupper(recipient) == "TEAM") 
      to = 250 - (int)playerData->player.getTeam();
  } else {
    to = GameKeeper::Player::getPlayerIDByName(recipient);

    // valid callsign
    if ((to < 0) || (to >= curMaxPlayers)) {
      message2 = TextUtils::format("\"%s\" is not here.  No such callsign.", recipient.c_str());
      sendMessage(ServerPlayer, from, message2.c_str());
      return;
    }
  }

  // make sure there is something to send
  if ((messageStart >= arguments.size() - 1) || (messageStart == 0)) {
    // found player, but nothing to send
    message2 = TextUtils::format("No text to send to \"%s\".", recipient.c_str());
    sendMessage(ServerPlayer, from, message2.c_str());
    return;
  }

  // send the message
  sendPlayerMessage(playerData, to, arguments.c_str() + messageStart + 1);
  return;
}


static void handlePasswordCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (playerData->accessInfo.passwordAttemptsMax()) {
    DEBUG1("\"%s\" (%s) has attempted too many /password tries\n",
	   playerData->player.getCallSign(),
	   playerData->netHandler->getTargetIP());
    sendMessage(ServerPlayer, t, "Too many attempts");
  } else {
    if ((clOptions->password != "") && strncmp(message + 10, clOptions->password.c_str(), clOptions->password.size()) == 0 && clOptions->password.length() == strlen(message + 10)) {
      playerData->accessInfo.setAdmin();
      sendPlayerInfo();
      sendMessage(ServerPlayer, t, "You are now an administrator!");
    } else {
      sendMessage(ServerPlayer, t, "Wrong Password!");
    }
  }
  return;
}


static void handleSetCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  int setvar = playerData->accessInfo.hasPerm(PlayerAccessInfo::setVar) ? 1 : 0;
  int setall = playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll) ? 1 : 0;
  char message2[MessageLen];
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::setVar)
      && !playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the set command");
	DEBUG3("set failed by %s, setvar=%d, setall=%d\n",playerData->player.getCallSign(),setvar,setall);
   return;
  }
  if (Replay::enabled()) {
    sendMessage(ServerPlayer, t, "You can't /set variables in replay mode");
    return;
  }
  DEBUG3("set executed by %s, setvar=%d, setall=%d\n",playerData->player.getCallSign(),setvar,setall);
  std::string command = (message + 1);
  // we aren't case sensitive but CMDMGR is
  for (int i = 0; i < 3 /*"set"*/; ++i)
    command[i] = tolower(command[i]);
  sendMessage(ServerPlayer, t, CMDMGR.run(command).c_str());
  snprintf(message2, MessageLen, "Variable Modification Notice by %s of %s",
	   playerData->player.getCallSign(), command.c_str());
  sendMessage(ServerPlayer, AllPlayers, message2);
  return;
}


static void handleResetCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::setVar)
      && !playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the reset command");
    return;
  }
  if (Replay::enabled()) {
    sendMessage(ServerPlayer, t, "You can't /reset variables in replay mode");
    return;
  }
  std::string command = (message + 1);
  // we aren't case sensitive but CMDMGR is
  for (int i = 0; i < 5 /*"reset"*/; ++i)
    command[i] = tolower(command[i]);
  sendMessage(ServerPlayer, t, CMDMGR.run(command).c_str());
  return;
}


static void handleShutdownserverCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::shutdownServer)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the shutdown command");
    return;
  }
  done = true;
  return;
}


static void handleSuperkillCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::superKill)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the superkill command");
    return;
  }
  for (int i = 0; i < curMaxPlayers; i++)
    removePlayer(i, "/superkill");
  gameOver = true;
  if (clOptions->timeManualStart)
    countdownActive = false;
  return;
}


static void handleGameoverCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::endGame)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the gameover command");
    return;
  }

  void *buf, *bufStart = getDirectMessageBuffer();
  buf = nboPackUByte(bufStart, t);
  buf = nboPackUShort(buf, uint16_t(NoTeam));
  broadcastMessage(MsgScoreOver, (char*)buf - (char*)bufStart, bufStart);
  gameOver = true;
  if (clOptions->timeManualStart) {
    countdownActive = false;
    countdownPauseStart = TimeKeeper::getNullTime();
    clOptions->countdownPaused = false;
    return;
  }
}


static void handleCountdownCmd(GameKeeper::Player *playerData, const char *message)
{
  // /countdown starts timed game, if start is manual, everyone is allowed to
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::countdown)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the countdown command");
    return;
  } else if (!clOptions->timeManualStart) {
    sendMessage(ServerPlayer, t, "This server was not configured for manual clock countdowns");
    return;
  } else if (countdownDelay > 0) {
    sendMessage(ServerPlayer, t, "There is a countdown already in progress");
    return;
  }

  // if the timelimit is not set .. don't countdown
  if (clOptions->timeLimit > 1.0f) {
    std::vector<std::string> parts = TextUtils::tokenize(message, " \t",2);
    
    if (parts.size() > 1) {
      // we have an argument
      
      if (parts[1] == "pause") {
	// pause the countdown
	if (!countdownActive) {
	  sendMessage(ServerPlayer, t, "There is no active game to pause");
	  return;
	} else if (clOptions->countdownPaused) {
	  sendMessage(ServerPlayer, t, "The game is already paused");
	  return;
	}
	clOptions->countdownPaused = true;
	sendMessage(ServerPlayer, AllPlayers, TextUtils::format("Countdown paused by %s",playerData->player.getCallSign()).c_str());
	return;
      } else if (parts[1] == "resume") {
	// resume countdown if it was paused before
	if (!clOptions->countdownPaused) {
	  sendMessage(ServerPlayer, t, "The game is not paused");
	  return;
	}
	clOptions->countdownPaused = false;
	sendMessage(ServerPlayer, AllPlayers, TextUtils::format("Countdown resumed by %s",playerData->player.getCallSign()).c_str());
	return;
	      
      } else {
	// so it's the countdown delay? else tell the player how to use /countdown
	std::istringstream timespec(message+10);
	if (!(timespec >> countdownDelay)) {
	  sendMessage(ServerPlayer, t, "Usage: /countdown [<seconds>|pause|resume]");
	  return;
	}
      }
    } else {
      countdownDelay = 10;
    }
    
    // cancel here if a game is already running
    if (countdownActive) {
      sendMessage(ServerPlayer, t, "A game is already in progress");
      countdownDelay = -1;
      return;
    }

    // limit/sanity check
    const int max_delay = 120;
    if (countdownDelay > max_delay) {
      sendMessage(ServerPlayer, t, TextUtils::format("Countdown set to %d instead of %d", max_delay, countdownDelay).c_str());
      countdownDelay = max_delay;
    } else if (countdownDelay < 0) {
      sendMessage(ServerPlayer, t, TextUtils::format("Countdown set to 0 instead of %d", countdownDelay).c_str());
      countdownDelay = 0;
    }

    sendMessage(ServerPlayer, AllPlayers, TextUtils::format("Team scores reset, countdown started by %s.",playerData->player.getCallSign()).c_str());

    // let everyone know what's going on
    long int timeArray[4];
    std::string matchBegins;
    if (countdownDelay == 0) {
      matchBegins = "Match begins now!";
    } else {
      TimeKeeper::convertTime(countdownDelay, timeArray);
      std::string countdowntime = TimeKeeper::printTime(timeArray);
      matchBegins = TextUtils::format("Match begins in about %s", countdowntime.c_str());
    }
    sendMessage(ServerPlayer, AllPlayers, matchBegins.c_str());

    TimeKeeper::convertTime(clOptions->timeLimit, timeArray);
    std::string timelimit = TimeKeeper::printTime(timeArray);
    matchBegins = TextUtils::format("Match duration is %s", timelimit.c_str());
    sendMessage(ServerPlayer, AllPlayers, matchBegins.c_str());
		
    // make sure the game always start unpaused
    clOptions->countdownPaused = false;
    countdownPauseStart = TimeKeeper::getNullTime();

  } else {
    sendMessage(ServerPlayer, AllPlayers, "Team scores reset.");
    sendMessage(ServerPlayer, t, "The server is not configured for timed matches.");
  }

  // reset team scores
  for (int i = RedTeam; i <= PurpleTeam; i++) {
    team[i].team.lost = team[i].team.won = 0;
  }
  sendTeamUpdate();

  return;
}


static void handleFlagCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::flagMod)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the flag command");
    return;
  }
  if (strncasecmp(message + 6, "reset", 5) == 0) {
    bool onlyUnused = strncasecmp(message + 11, " unused", 7) == 0;
    bz_resetFlags(onlyUnused);
  } else if (strncasecmp(message + 6, "up", 2) == 0) {
    for (int i = 0; i < numFlags; i++) {
      FlagInfo &flag = *FlagInfo::get(i);
      if (flag.flag.type->flagTeam == ::NoTeam) {
	sendDrop(flag);
	flag.flag.status = FlagGoing;
	if (!flag.required)
	  flag.flag.type = Flags::Null;
	sendFlagUpdate(flag);
      }
    }

  } else if (strncasecmp(message + 6, "show", 4) == 0) {
    for (int i = 0; i < numFlags; i++) {
      char showMessage[MessageLen];
      FlagInfo::get(i)->getTextualInfo(showMessage);
      sendMessage(ServerPlayer, t, showMessage);
    }
  } else {
    sendMessage(ServerPlayer, t, "reset|show|up");
  }
  return;
}


static void handleKickCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::kick)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the kick command");
    return;
  }
  int i;
  std::vector<std::string> argv = TextUtils::tokenize(message, " \t", 3, true);

  if (argv.size() < 3) {
    sendMessage(ServerPlayer, t, "Syntax: /kick <#slot | PlayerName | \"Player Name\"> <reason>");
    sendMessage(ServerPlayer, t, "	Please keep in mind that reason is displayed to the user.");
    return;
  }
  

  i = getSlotNumber(argv[1]);

  if (i >= 0) {
    char kickmessage[MessageLen];
    
    GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(i);

    // admins can override antiperms
    if (!playerData->accessInfo.isAdmin()) {
      // otherwise make sure the player is not protected with an antiperm      
      if ((p != NULL) && (p->accessInfo.hasPerm(PlayerAccessInfo::antikick))) {
	snprintf(kickmessage, MessageLen, "%s is protected from being kicked.", p->player.getCallSign());
	sendMessage(ServerPlayer, i, kickmessage);
	return;
      }
    }

    snprintf(kickmessage, MessageLen, "You were kicked off the server by %s",
	    playerData->player.getCallSign());
    sendMessage(ServerPlayer, i, kickmessage);
    if (argv.size() > 2) {
      snprintf(kickmessage, MessageLen, " reason given : %s",argv[2].c_str());
      sendMessage(ServerPlayer, i, kickmessage);
    }
    snprintf(kickmessage, MessageLen, "%s kicked by %s, reason: %s", p->player.getCallSign(), playerData->player.getCallSign(),argv[2].c_str());
    sendMessage(ServerPlayer, AdminPlayers, kickmessage);
    removePlayer(i, "/kick");
  } else {
    char errormessage[MessageLen];
    snprintf(errormessage, MessageLen, "player \"%s\" not found", argv[1].c_str());
    sendMessage(ServerPlayer, t, errormessage);
  }
  return;
}

static void handleKillCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::kill)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the kill command");
    return;
  }
  int i;
  std::vector<std::string> argv = TextUtils::tokenize(message, " \t", 3, true);

  if (argv.size() < 2) {
    sendMessage(ServerPlayer, t, "Syntax: /kill <#slot | PlayerName | \"Player Name\">  [reason]");
    sendMessage(ServerPlayer, t, "	Please keep in mind that reason is displayed to the user.");
    return;
  }

  i = getSlotNumber(argv[1]);

  if (i >= 0) {
    char killmessage[MessageLen];

    // admins can override antiperms
    if (!playerData->accessInfo.isAdmin()) {
      // otherwise make sure the player is not protected with an antiperm
      GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(i);
      if ((p != NULL) && (p->accessInfo.hasPerm(PlayerAccessInfo::antikill))) {
	snprintf(killmessage, MessageLen, "%s is protected from being killed.", p->player.getCallSign());
	sendMessage(ServerPlayer, i, killmessage);
	return;
      }
    }

    snprintf(killmessage, MessageLen, "You were killed by %s",
	     playerData->player.getCallSign());
    sendMessage(ServerPlayer, i, killmessage);
    if (argv.size() > 2) {
      snprintf(killmessage, MessageLen, " reason given : %s",argv[2].c_str());
      sendMessage(ServerPlayer, i, killmessage);
    }
    // kill the player
    playerKilled(i, ServerPlayer, 0, -1, Flags::Null, -1);

  } else {
    char errormessage[MessageLen];
    snprintf(errormessage, MessageLen, "player \"%s\" not found", argv[1].c_str());
    sendMessage(ServerPlayer, t, errormessage);
  }
  return;
}

static void handleBanlistCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::banlist)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the banlist command");
    return;
  }
  clOptions->acl.sendBans(t);
  return;
}


static void handleHostBanlistCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::banlist)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the banlist command");
    return;
  }
  clOptions->acl.sendHostBans(t);
  return;
}


static void handleBanCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::ban) &&
      !playerData->accessInfo.hasPerm(PlayerAccessInfo::shortBan)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the ban command");
    return;
  }

  std::string msg = message;
  std::vector<std::string> argv = TextUtils::tokenize(msg, " \t", 4, true);

  if (argv.size() < 4) {
    sendMessage(ServerPlayer, t, "Syntax: /ban <#slot | PlayerName | \"Player Name\" | ip> <duration> <reason>");
    sendMessage(ServerPlayer, t, "	Please keep in mind that reason is displayed to the user.");
  } else {
    std::string ip = argv[1];
    std::string reason;
    int durationInt = clOptions->banTime;
    
    int victim = getSlotNumber(argv[1]);
    
    if (victim >= 0) {
      // valid slot or callsign
      GameKeeper::Player *playerBannedData  = GameKeeper::Player::getPlayerByIndex(victim);
      if (playerBannedData)
	ip = playerBannedData->netHandler->getTargetIP();
    }

    // set the ban time
    if (argv.size() >= 3) {
      int specifiedDuration = TextUtils::parseDuration(argv[2]);
      if ((durationInt > 0) &&
	  ((specifiedDuration > durationInt) || (specifiedDuration <= 0)) &&
	  !playerData->accessInfo.hasPerm(PlayerAccessInfo::ban)) {
	sendMessage (ServerPlayer, t, "You only have SHORTBAN privileges,"
				      " using default ban time");
      } else {
	durationInt = specifiedDuration;
      }
    }

    // set the ban reason
    if (argv.size() == 4) {
      reason = argv[3];
    }

    // reload the banlist in case anyone else has added
    clOptions->acl.load();

    if (clOptions->acl.ban(ip, playerData->player.getCallSign(), durationInt,
			   reason.c_str())) {
      clOptions->acl.save();

      sendMessage(ServerPlayer, t, "IP pattern added to banlist");

      char kickmessage[MessageLen];
      GameKeeper::Player *otherPlayer;
      for (int i = 0; i < curMaxPlayers; i++) {
	otherPlayer = GameKeeper::Player::getPlayerByIndex(i);
	if (otherPlayer && !clOptions->acl.validate
	    (otherPlayer->netHandler->getIPAddress())) {

	  // admins can override antiperms
	  if (!playerData->accessInfo.isAdmin()) {
	    // make sure this player isn't protected
	    GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(i);
	    if ((p != NULL)
		&& (p->accessInfo.hasPerm(PlayerAccessInfo::antiban))) {
	      snprintf(kickmessage, MessageLen, 
		      "%s is protected from being banned (skipped).",
		      p->player.getCallSign());
	      sendMessage(ServerPlayer, t, kickmessage);
	      continue;
	    }
	  }

	  snprintf(kickmessage, MessageLen, "You were banned from this server by %s",
		  playerData->player.getCallSign());
	  sendMessage(ServerPlayer, i, kickmessage);
	  if (reason.length() > 0) {
	    snprintf(kickmessage, MessageLen, "Reason given: %s", reason.c_str());
	    sendMessage(ServerPlayer, i, kickmessage);
	  }
	  if (otherPlayer) {
	    snprintf(kickmessage, MessageLen, "%s banned by %s, reason: %s", otherPlayer->player.getCallSign(), playerData->player.getCallSign(),reason.c_str());
	    sendMessage(ServerPlayer, AdminPlayers, kickmessage);
	  }
	  removePlayer(i, "/ban");
	}
      }
    } else {
      char errormessage[MessageLen];
      snprintf(errormessage, MessageLen, "Malformed address or invalid Player/Slot: %s", argv[1].c_str());
      sendMessage(ServerPlayer, t, errormessage);
    }
  }
  return;
}


static void handleHostBanCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::ban) &&
      !playerData->accessInfo.hasPerm(PlayerAccessInfo::shortBan)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the ban command");
    return;
  }

  std::string msg = message;
  std::vector<std::string> argv = TextUtils::tokenize( msg, " \t", 4 );

  if (argv.size() < 2) {
    sendMessage(ServerPlayer, t, "Syntax: /hostban <host pattern> [duration] [reason]");
    sendMessage(ServerPlayer, t, "	Please keep in mind that reason is displayed to the user.");
  } else {
    std::string hostpat = argv[1];
    std::string reason;
    int durationInt = clOptions->banTime;

    // set the ban time
    if (argv.size() >= 3) {
      int specifiedDuration = TextUtils::parseDuration(argv[2]);
      if ((durationInt > 0) &&
	  ((specifiedDuration > durationInt) || (specifiedDuration <= 0)) &&
	  !playerData->accessInfo.hasPerm(PlayerAccessInfo::ban)) {
	sendMessage (ServerPlayer, t, "You only have SHORTBAN privileges,"
				      " using default ban time");
      } else {
	durationInt = specifiedDuration;
      }
    }

    // set the ban reason
    if( argv.size() == 4 ) {
      reason = argv[3];
    }

    clOptions->acl.hostBan(hostpat, playerData->player.getCallSign(),
			   durationInt,
			   reason.c_str());
    clOptions->acl.save();

    GameKeeper::Player::setAllNeedHostbanChecked(true);

    sendMessage(ServerPlayer, t, "Host pattern added to banlist");
  }
  return;
}


static void handleUnbanCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::unban)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the unban command");
    return;
  }

  if (clOptions->acl.unban(message + 7)) {
    sendMessage(ServerPlayer, t, "Removed IP pattern from the ban list");
    clOptions->acl.save();
  } else {
    sendMessage(ServerPlayer, t, "No pattern removed");
  }
  return;
}

static void handleHostUnbanCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::unban)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the unban command");
    return;
  }

  if (clOptions->acl.hostUnban(message + 11)) {
    sendMessage(ServerPlayer, t, "Removed host pattern from the ban list");
    clOptions->acl.save();
  } else {
    sendMessage(ServerPlayer, t, "No pattern removed");
  }
  return;
}


static void handleLagwarnCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::lagwarn)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the lagwarn command");
    return;
  }

  char reply[MessageLen] = {0};

  if (message[8] == ' ') {
    const char *maxlag = message + 9;
    clOptions->lagwarnthresh = (float) (atoi(maxlag) / 1000.0);
    snprintf(reply, MessageLen, "lagwarn is now %d ms", int(clOptions->lagwarnthresh * 1000 + 0.5));
  } else {
    snprintf(reply, MessageLen, "lagwarn is set to %d ms", int(clOptions->lagwarnthresh * 1000 + 0.5));
  }
  sendMessage(ServerPlayer, t, reply);
  return;
}


bool lagCompare(const GameKeeper::Player *a, const GameKeeper::Player *b)
{
  if (a->player.isObserver() && !b->player.isObserver())
    return true;
  if (!a->player.isObserver() && b->player.isObserver())
    return false;
  return a->lagInfo.getLag() < b->lagInfo.getLag();
}

static void handleLagstatsCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::lagStats)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the lagstats command");
    return;
  }
  // yeah, ok this is ugly but it works - curMaxPlayers is never >255
  GameKeeper::Player *sortedPlayer[256];
  int i = 0, j = 0;
  for (i = 0; i < curMaxPlayers; i++) {
    GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(i);
    if (p != NULL) {
      sortedPlayer[j++] = p;
    }
  }
  std::sort(sortedPlayer, sortedPlayer + j, lagCompare);

  char reply[MessageLen];
  for (i = 0; i < j; i++) {
    GameKeeper::Player *p = sortedPlayer[i];
    p->lagInfo.getLagStats(reply);
    if (reply[0])
      sendMessage(ServerPlayer, t, reply);
  }
}


static void handleIdlestatsCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::idleStats)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the idlestats command");
    return;
  }

  GameKeeper::Player *otherData;
  std::string reply;
  for (int i = 0; i < curMaxPlayers; i++) {
    otherData = GameKeeper::Player::getPlayerByIndex(i);
    if (!otherData)
      continue;
    reply = otherData->player.getIdleStat();
    if (reply != "")
      sendMessage(ServerPlayer, t, reply.c_str());
  }
  return;
}


static void handleFlaghistoryCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::flagHistory)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the flaghistory command");
    return;
  }

  char reply[MessageLen];
  for (int i = 0; i < curMaxPlayers; i++) {
    GameKeeper::Player *otherData = GameKeeper::Player::getPlayerByIndex(i);
    if (otherData != NULL && otherData->player.isPlaying()
	&& !otherData->player.isObserver()) {
      snprintf(reply, MessageLen, "%-16s : ", otherData->player.getCallSign());
      otherData->flagHistory.get(reply+strlen(reply));
      sendMessage(ServerPlayer, t, reply);
    }
  }
}


static void handlePlayerlistCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::playerList)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the playerlist command");
    return;
  }

  GameKeeper::Player *otherData;
  char reply[MessageLen] = {0};

  for (int i = 0; i < curMaxPlayers; i++) {
    otherData = GameKeeper::Player::getPlayerByIndex(i);
    if (otherData && otherData->player.isPlaying()) {
      otherData->netHandler->getPlayerList(reply);
      sendMessage(ServerPlayer, t, reply);
    }
  }
  return;
}


static void handleReportCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::talk)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the report command");
    return;
  }

  if (strlen(message + 1) < 8) {
    sendMessage(ServerPlayer, t, "Nothing reported");
  } else {
    time_t now = time(NULL);
    char* timeStr = ctime(&now);
    std::string reportStr;
    reportStr = reportStr + timeStr + "Reported by " +
      playerData->player.getCallSign() + ": " + (message + 8);
    if (clOptions->reportFile.size() > 0) {
      std::ofstream ofs(clOptions->reportFile.c_str(), std::ios::out | std::ios::app);
      ofs << reportStr << std::endl << std::endl;
    }
    if (clOptions->reportPipe.size() > 0) {
      FILE* pipeWrite = popen(clOptions->reportPipe.c_str(), "w");
      if (pipeWrite != NULL) {
	fprintf(pipeWrite, "%s\n\n", reportStr.c_str());
      } else {
	DEBUG1("Couldn't write report to the pipe\n");
      }
      pclose(pipeWrite);
    }
    if (clOptions->reportFile.size() == 0 && clOptions->reportPipe.size() == 0) {
      sendMessage(ServerPlayer, t, "The report command is disabled on this server");
    } else {
      std::string temp = std::string("**\"") + playerData->player.getCallSign() + "\" reports: " +
			 (message + 8);
      if (temp.size() <= (unsigned) MessageLen) {
	sendMessage (ServerPlayer, AdminPlayers, temp.c_str());
	return;
      }
      const std::vector<std::string> words = TextUtils::tokenize(temp, " \t");
      unsigned int cur = 0;
      const unsigned int wordsize = words.size();
      while (cur != wordsize) {
	std::string temp2;
	while (temp2.size() <= (unsigned) MessageLen &&
	       cur != wordsize &&
	       (temp2.size() + words[cur].size()) <= (unsigned) MessageLen) {
	    temp2 += words[cur] + " ";
	    ++cur;
	}
	sendMessage (ServerPlayer, AdminPlayers, temp2.c_str());
      }
      sendMessage (ServerPlayer, AdminPlayers, message);
      DEBUG1("Player %s [%d] has filed a report (time: %s).\n",
	     playerData->player.getCallSign(), t, timeStr);

      sendMessage(ServerPlayer, t, "Your report has been filed. Thank you.");
    }
  }

  return;
}


static void handleHelpCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  char reply[MessageLen] = {0};

  if (strlen(message + 1) == 4) {
    const std::vector<std::string>& chunks = clOptions->textChunker.getChunkNames();
    sendMessage(ServerPlayer, t, "Available help pages (use /help <page>)");
    for (int i = 0; i < (int) chunks.size(); i++) {
      sendMessage(ServerPlayer, t, chunks[i].c_str());
    }
  } else {
    bool foundChunk = false;
    const std::vector<std::string>& chunks = clOptions->textChunker.getChunkNames();
    for (int i = 0; i < (int)chunks.size() && (!foundChunk); i++) {
      if (chunks[i] == (message +6)){
	const std::vector<std::string>* lines = clOptions->textChunker.getTextChunk((message + 6));
	if (lines != NULL) {
	  for (int j = 0; j < (int)lines->size(); j++) {
	    sendMessage(ServerPlayer, t, (*lines)[j].c_str());
	  }
	  foundChunk = true;
	  break;
	}
      }
    }
    if (!foundChunk) {
      snprintf(reply, MessageLen, "Help command %s not found", message + 6);
      sendMessage(ServerPlayer, t, reply);
    }
  }
  return;
}


static void handleIdentifyCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!passFile.size()){
    sendMessage(ServerPlayer, t, "/identify command disabled");
    return;
  }
  // player is trying to send an ID
  if (playerData->accessInfo.isVerified()) {
    sendMessage(ServerPlayer, t, "You have already identified");
  } else if (playerData->accessInfo.gotAccessFailure()) {
    sendMessage(ServerPlayer, t, "You have attempted to identify too many times");
  } else {
    // get their info
    if (!playerData->accessInfo.isRegistered()) {
      // not in DB, tell them to reg
      sendMessage(ServerPlayer, t, "This callsign is not registered,"
		  " please register it with a /register command");
    } else {
      if (playerData->accessInfo.isPasswordMatching(message + 10)) {
	sendMessage(ServerPlayer, t, "Password Accepted, welcome back.");

	// get their real info
	playerData->accessInfo.setPermissionRights();

	// if they have the PLAYERLIST permission, send the IP list
	sendIPUpdate(t, -1);
	sendPlayerInfo();
      } else {
	playerData->accessInfo.setLoginFail();
	sendMessage(ServerPlayer, t, "Identify Failed, please make sure"
		    " your password was correct");
      }
    }
  }
  return;
}


static void handleRegisterCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!passFile.size()){
    sendMessage(ServerPlayer, t, "/register command disabled");
    return;
  }
  if (playerData->accessInfo.isVerified()) {
    sendMessage(ServerPlayer, t, "You have already registered and"
		" identified this callsign");
  } else {
    if (playerData->accessInfo.isRegistered()) {
      sendMessage(ServerPlayer, t, "This callsign is already registered,"
		  " if it is yours /identify to login");
    } else {
      if (strlen(message) > 12) {
	playerData->accessInfo.storeInfo(message + 10);
	sendMessage(ServerPlayer, t, "Callsign registration confirmed,"
		    " please /identify to login");
      } else {
	sendMessage(ServerPlayer, t, "Your password must be 3 or more characters");
      }
    }
  }
  return;
}


static void handleGhostCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!passFile.size()){
    sendMessage(ServerPlayer, t, "/ghost command disabled");
    return;
  }
  char *p1 = (char*)strchr(message + 1, '\"');
  char *p2 = 0;
  if (p1) p2 = strchr(p1 + 1, '\"');
  if (!p2) {
    sendMessage(ServerPlayer, t, "not enough parameters, usage"
		" /ghost \"CALLSIGN\" PASSWORD");
  } else {
    std::string ghostie(p1 + 1, p2 - p1 - 1);
    std::string ghostPass = p2 + 2;

    makeupper(ghostie);

    int user = GameKeeper::Player::getPlayerIDByName(ghostie);
    if (user == -1) {
      sendMessage(ServerPlayer, t, "There is no user logged in by that name");
    } else {
      if (!userExists(ghostie)) {
	sendMessage(ServerPlayer, t, "That callsign is not registered");
      } else {
	if (!verifyUserPassword(ghostie, ghostPass)) {
	  sendMessage(ServerPlayer, t, "Invalid Password");
	} else {
	  sendMessage(ServerPlayer, t, "Ghosting User");
	  char temp[MessageLen];
	  snprintf(temp, MessageLen, "Your Callsign is registered to another user,"
		  " You have been ghosted by %s",
		  playerData->player.getCallSign());
	  sendMessage(ServerPlayer, user, temp);
	  removePlayer(user, "Ghost");
	}
      }
    }
  }
  return;
}


static void handleDeregisterCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!passFile.size()){
    sendMessage(ServerPlayer, t, "/deregister command disabled");
    return;
  }
  if (!playerData->accessInfo.isVerified()) {
    sendMessage(ServerPlayer, t, "You must be registered and verified to run the deregister command");
    return;
  }

  if (strlen(message) == 11) {
    // removing own callsign
    passwordDatabase.erase(playerData->accessInfo.getName());
    userDatabase.erase(playerData->accessInfo.getName());
    PlayerAccessInfo::updateDatabases();
    sendMessage(ServerPlayer, t, "Your callsign has been deregistered");
  } else if (strlen(message) > 12
	     && playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll)) {
    char reply[MessageLen];

    // removing someone else's
    std::string name = message + 12;
    makeupper(name);
    if (userExists(name)) {

      // admins can override antiperms
      if (!playerData->accessInfo.isAdmin()) {
	// make sure this player isn't protected
	int v = GameKeeper::Player::getPlayerIDByName(name);
	GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(v);
	if ((p != NULL) && (p->accessInfo.hasPerm(PlayerAccessInfo::antideregister))) {
	  snprintf(reply, MessageLen, "%s is protected from being deregistered.", p->player.getCallSign());
	  sendMessage(ServerPlayer, t, reply);
	  return;
	}
      }

      passwordDatabase.erase(name);
      userDatabase.erase(name);
      PlayerAccessInfo::updateDatabases();

      snprintf(reply, MessageLen, "%s has been deregistered", name.c_str());
      sendMessage(ServerPlayer, t, reply);
    } else {
      snprintf(reply, MessageLen, "user %s does not exist", name.c_str());
      sendMessage(ServerPlayer, t, reply);
    }
  } else if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll)) {
    sendMessage(ServerPlayer, t, "You do not have permission to deregister this user");
  }

  return;
}


static void handleSetpassCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!passFile.size()){
    sendMessage(ServerPlayer, t, "/setpass command disabled");
    return;
  }
  if (!playerData->accessInfo.isVerified()) {
    sendMessage(ServerPlayer, t, "You must be registered and verified to run the setpass command");
    return;
  }

  size_t startPosition = 7;
  /* skip any leading whitespace */
  while (isspace(message[++startPosition]))
    ;
  if (startPosition == strlen(message) || !isspace(message[8])) {
    sendMessage(ServerPlayer, t, "Not enough parameters: usage /setpass PASSWORD");
    return;
  }
  std::string pass = message + startPosition;
  playerData->accessInfo.setPasswd(pass);
  char text[MessageLen];
  snprintf(text, MessageLen, "Your password is now set to \"%s\"", pass.c_str());
  sendMessage(ServerPlayer, t, text);
  return;
}


static void handleGrouplistCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  sendMessage(ServerPlayer, t, "Group List:");
  PlayerAccessMap::iterator itr = groupAccess.begin();
  while (itr != groupAccess.end()) {
    sendMessage(ServerPlayer, t, itr->first.c_str());
    itr++;
  }
  return;
}


static void handleShowgroupCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  std::string settie;

  if (strlen(message) == 10) {	 // show own groups
    if (playerData->accessInfo.isVerified()) {
      settie = playerData->accessInfo.getName();
    } else {
      sendMessage(ServerPlayer, t, "You are not identified");
    }
  } else if (playerData->accessInfo.hasPerm(PlayerAccessInfo::showOthers)) {
    // show groups for other player
    char *p1 = (char*) strchr(message + 1, '\"');
    char *p2 = 0;
    if (p1) p2 = strchr(p1 + 1, '\"');
    if (p2) {
      settie = std::string(p1 + 1, p2 - p1 - 1);
      makeupper(settie);
    } else {
      sendMessage(ServerPlayer, t, "wrong format, usage"
		  " /showgroup  or  /showgroup \"CALLSIGN\"");
    }
  } else {
    sendMessage(ServerPlayer, t, "No permission!");
  }

  // something is wrong
  if (settie != "") {
    int playerIndex = GameKeeper::Player::getPlayerIDByName(settie);
    // once for global groups
    if (playerIndex < curMaxPlayers) {
      GameKeeper::Player* target = GameKeeper::Player::getPlayerByIndex(playerIndex);
      if (target != NULL) {
	PlayerAccessInfo &info = target->accessInfo;
	// FIXME remove local groups from this list. better yet unify the two.
	std::string line = "Global Groups (only extras) for ";
	line += settie;
	line += ": ";
	std::vector<std::string>::iterator itr = info.groups.begin();
	while (itr != info.groups.end()) {
	  line += *itr;
	  line += " ";
	  itr++;
	}
	while (line.size() > (unsigned int)MessageLen) {
	  sendMessage(ServerPlayer, t, line.substr(0, MessageLen).c_str());
	  line.erase(line.begin(), line.begin() + (MessageLen - 1));
	}
	sendMessage(ServerPlayer, t, line.c_str());
      }
    }
    // once for local groups
    if (userExists(settie)) {
      PlayerAccessInfo &info = PlayerAccessInfo::getUserInfo(settie);

      std::string line = "Local groups for ";
      line += settie;
      line += ": ";
      std::vector<std::string>::iterator itr = info.groups.begin();
      while (itr != info.groups.end()) {
	line += *itr;
	line += " ";
	itr++;
      }
      while (line.size() > (unsigned int)MessageLen) {
	sendMessage(ServerPlayer, t, line.substr(0, MessageLen).c_str());
	line.erase(line.begin(), line.begin() + (MessageLen - 1));
      }
      sendMessage(ServerPlayer, t, line.c_str());
    } else {
      sendMessage(ServerPlayer, t, "There is no user by that name");
    }
  }
  return;
}


static void handleGrouppermsCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  sendMessage(ServerPlayer, t, "Group List:");
  PlayerAccessMap::iterator itr = groupAccess.begin();
  std::string line;
  while (itr != groupAccess.end()) {
    line = itr->first + ":   ";
    sendMessage(ServerPlayer, t, line.c_str());

    // allows first
    if (itr->second.explicitAllows.any()) {
      sendMessage(ServerPlayer, t, "  Allows");
      for (int i = 0; i < PlayerAccessInfo::lastPerm; i++) {
     	if (itr->second.explicitAllows.test(i) && !itr->second.explicitDenys.test(i) ) {
	  line = "     ";
	  line += nameFromPerm((PlayerAccessInfo::AccessPerm)i);
	  sendMessage(ServerPlayer, t, line.c_str());
      	}
      }
    }
		
    // same about denys
    if (itr->second.explicitDenys.any()) {
      sendMessage(ServerPlayer, t, "  Denys");
      for (int i = 0; i < PlayerAccessInfo::lastPerm; i++) {
     	if (itr->second.explicitDenys.test(i) ) {
	  line = "     ";
	  line += nameFromPerm((PlayerAccessInfo::AccessPerm)i);
	  sendMessage(ServerPlayer, t, line.c_str());
      	}
      }
    }
			
    itr++;
  }
  return;
}


static void handleSetgroupCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!userDatabaseFile.size()) {
    sendMessage(ServerPlayer, t, "/setgroup command disabled");
    return;
  }
  char *p1 = (char*)strchr(message + 1, '\"');
  char *p2 = 0;
  if (p1) p2 = strchr(p1 + 1, '\"');
  if (!p2) {
    sendMessage(ServerPlayer, t, "not enough parameters, usage /setgroup \"CALLSIGN\" GROUP");
  } else {
    std::string settie(p1 + 1, p2 - p1 - 1);
    std::string group = p2 + 2;

    makeupper(settie);
    makeupper(group);

    if (userExists(settie)) {
      if (!playerData->accessInfo.canSet(group)) {
	sendMessage(ServerPlayer, t, "You do not have permission to set this group");
      } else {
	PlayerAccessInfo &info = PlayerAccessInfo::getUserInfo(settie);

	if (info.addGroup(group)) {
	  sendMessage(ServerPlayer, t, "Group Add successful");
	  int getID = GameKeeper::Player::getPlayerIDByName(settie);
	  if (getID != -1) {
	    char temp[MessageLen];
	    snprintf(temp, MessageLen, "you have been added to the %s group, by %s",
		    group.c_str(), playerData->player.getCallSign());
	    sendMessage(ServerPlayer, getID, temp);
	    GameKeeper::Player::getPlayerByIndex(getID)->accessInfo.
	      addGroup(group);
	  }
	  PlayerAccessInfo::updateDatabases();
	} else {
	  sendMessage(ServerPlayer, t, "Group Add failed (user may already be in that group)");
	}
      }
    } else {
      sendMessage(ServerPlayer, t, "There is no user by that name");
    }
  }
  return;
}


static void handleRemovegroupCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  if (!userDatabaseFile.size()) {
    sendMessage(ServerPlayer, t, "/removegroup command disabled");
    return;
  }
  char *p1 = (char*)strchr(message + 1, '\"');
  char *p2 = 0;
  if (p1) p2 = strchr(p1 + 1, '\"');
  if (!p2) {
    sendMessage(ServerPlayer, t, "not enough parameters, usage /removegroup \"CALLSIGN\" GROUP");
  } else {
    std::string settie(p1 + 1, p2 - p1 - 1);
    std::string group = p2 + 2;

    makeupper(settie);
    makeupper(group);
    if (userExists(settie)) { 
      if (!playerData->accessInfo.canSet(group)) {
	sendMessage(ServerPlayer, t, "You do not have permission to remove this group");
      } else {
	PlayerAccessInfo &info = PlayerAccessInfo::getUserInfo(settie);
	if (info.removeGroup(group)) {
	  sendMessage(ServerPlayer, t, "Group Remove successful");
	  int getID = GameKeeper::Player::getPlayerIDByName(settie);
	  if (getID != -1) {
	    char temp[MessageLen];
	    snprintf(temp, MessageLen, "You have been removed from the %s group, by %s",
		    group.c_str(), playerData->player.getCallSign());
	    sendMessage(ServerPlayer, getID, temp);
	    GameKeeper::Player::getPlayerByIndex(getID)->accessInfo.
	      removeGroup(group);
	  }
	  PlayerAccessInfo::updateDatabases();
	} else {
	  sendMessage(ServerPlayer, t, "Group Remove failed (user may not have been in group)");
	}
      }
    } else {
      sendMessage(ServerPlayer, t, "There is no user by that name");
    }
  }
  return;
}


static void handleReloadCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::setAll)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the reload command");
    return;
  }

  // reload the banlist
  clOptions->acl.load();

  groupAccess.clear();
  userDatabase.clear();
  passwordDatabase.clear();
  initGroups();
  if (passFile.size())
    readPassFile(passFile);
  if (userDatabaseFile.size())
    PlayerAccessInfo::readPermsFile(userDatabaseFile);
  GameKeeper::Player::reloadAccessDatabase();
  sendMessage(ServerPlayer, t, "Databases reloaded");

  // Validate all of the current players

  std::string reason;
  char kickmessage[MessageLen];

  // Check host bans
  GameKeeper::Player::setAllNeedHostbanChecked(true);

  // Check IP bans
  for (int i = 0; i < curMaxPlayers; i++) {
    GameKeeper::Player *otherPlayer = GameKeeper::Player::getPlayerByIndex(i);
      if (otherPlayer && !clOptions->acl.validate
	(otherPlayer->netHandler->getIPAddress())) {
	  // admins can override antiperms
	  if (!playerData->accessInfo.isAdmin()) {
	    // make sure this player isn't protected
	    GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(i);
	    if ((p != NULL)
		&& (p->accessInfo.hasPerm(PlayerAccessInfo::antiban))) {
	      snprintf(kickmessage, MessageLen, 
		    "%s is protected from being banned (skipped).",
		    p->player.getCallSign());
	      sendMessage(ServerPlayer, t, kickmessage);
	      continue;
	    }
	  }

	  snprintf(kickmessage, MessageLen, "You were banned from this server by %s",
		  playerData->player.getCallSign());
	  sendMessage(ServerPlayer, i, kickmessage);
	  if (reason.length() > 0) {
	    snprintf(kickmessage, MessageLen, "Reason given: %s", reason.c_str());
	    sendMessage(ServerPlayer, i, kickmessage);
	  }
	  removePlayer(i, "/ban");
	}
  }
  return;
}


static void handleVoteCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  char reply[MessageLen] = {0};
  std::string callsign = std::string(playerData->player.getCallSign());

  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::vote)) {
    /* permission denied for /vote */
    snprintf(reply, MessageLen, "%s, you are presently not authorized to run /vote", callsign.c_str());
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  /* make sure that there is a poll arbiter */
  if (BZDB.isEmpty("poll")) {
    sendMessage(ServerPlayer, t, "ERROR: the poll arbiter has disappeared (this should never happen)");
    return;
  }

  // only need to get this once
  static VotingArbiter *arbiter = (VotingArbiter *)BZDB.getPointer("poll");

  /* make sure that there is a poll to vote upon */
  if ((arbiter != NULL) && !arbiter->knowsPoll()) {
    sendMessage(ServerPlayer, t, "A poll is not presently in progress.  There is nothing to vote on");
    return;
  }

  std::string voteCmd = &message[5];
  std::string answer;

  /* find the start of the vote answer */
  size_t startPosition = 0;
  while ((startPosition < voteCmd.size()) &&
	 (isspace(voteCmd[startPosition]))) {
    startPosition++;
  }

  /* stash the answer ('yes', 'no', etc) in lowercase to simplify comparison */
  for (size_t i = startPosition;  i < voteCmd.size() && !isspace(voteCmd[i]); i++) {
    answer += tolower(voteCmd[i]);
  }

  std::vector<std::string> yesAnswers;
  yesAnswers.push_back("y");
  yesAnswers.push_back("1");
  yesAnswers.push_back("yes");
  yesAnswers.push_back("yea");
  yesAnswers.push_back("si"); // spanish+
  yesAnswers.push_back("ja");  // german
  yesAnswers.push_back("oui"); // french
  yesAnswers.push_back("sim"); // portuguese
  yesAnswers.push_back("tak"); // polish

  std::vector<std::string> noAnswers;
  noAnswers.push_back("n");
  noAnswers.push_back("0");
  noAnswers.push_back("no");
  noAnswers.push_back("nay");
  noAnswers.push_back("nein"); // german
  noAnswers.push_back("nien"); // german misspelled
  noAnswers.push_back("non"); // french
  noAnswers.push_back("nao"); // portuguese
  noAnswers.push_back("nie"); // polish

  // see if the vote response is a valid yes or no answer
  int vote = -1;
  unsigned int maxAnswerCount = noAnswers.size() > yesAnswers.size() ? noAnswers.size() : yesAnswers.size();
  for (unsigned int v = 0; v < maxAnswerCount; v++) {
    if (v < yesAnswers.size()) {
      if (answer == yesAnswers[v]) {
	vote = 1;
	break;
      }
    }
    if (v < noAnswers.size()) {
      if (answer == noAnswers[v]) {
	vote = 0;
	break;
      }
    }
  }

  // cast the vote or complain
  bool cast = false;
  if (vote == 0) {
    if ((cast = arbiter->voteNo(callsign)) == true) {
      /* player voted no */
      snprintf(reply, MessageLen, "%s, your vote in opposition of the %s has been recorded", callsign.c_str(), arbiter->getPollAction().c_str());
      sendMessage(ServerPlayer, t, reply);
    }
  } else if (vote == 1) {
    if ((cast = arbiter->voteYes(callsign)) == true) {
      /* player voted yes */
      snprintf(reply, MessageLen, "%s, your vote in favor of the %s has been recorded", callsign.c_str(), arbiter->getPollAction().c_str());
      sendMessage(ServerPlayer, t, reply);
    }
  } else {
    if (answer.length() == 0) {
      snprintf(reply, MessageLen, "%s, you did not provide a vote answer", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
    } else {
      snprintf(reply, MessageLen, "%s, you did not vote in favor or in opposition", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
    }
    sendMessage(ServerPlayer, t, "Usage: /vote yes|no|y|n|1|0|yea|nay|si|ja|nein|oui|non|sim|nao");
    return;
  }

  if (arbiter->hasVoted(callsign)) {
    /* player already voted */
    snprintf(reply, MessageLen, "%s, you have already voted on the poll to %s %s", callsign.c_str(), arbiter->getPollAction().c_str(), arbiter->getPollTarget().c_str());
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  if (!cast){
    /* There was an error while voting, probably could send a less generic message */
    snprintf(reply, MessageLen, "%s, there was an error while voting on the poll to %s %s", callsign.c_str(), arbiter->getPollAction().c_str(), arbiter->getPollTarget().c_str());
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  return;
}


static void handleVetoCmd(GameKeeper::Player *playerData, const char * /*message*/)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::veto)) {
    /* permission denied for /veto */
    sendMessage(ServerPlayer, t,
		TextUtils::format
		("%s, you are presently not authorized to run /veto",
		 playerData->player.getCallSign()).c_str());
    return;
  }

  /* make sure that there is a poll arbiter */
  if (BZDB.isEmpty("poll")) {
    sendMessage(ServerPlayer, t, "ERROR: the poll arbiter has disappeared (this should never happen)");
    return;
  }

  // only need to do this once
  static VotingArbiter *arbiter = (VotingArbiter *)BZDB.getPointer("poll");

  /* make sure there is an unexpired poll */
  if ((arbiter != NULL) && !arbiter->knowsPoll()) {
    sendMessage(ServerPlayer, t,
		TextUtils::format
		("%s, there is presently no active poll to veto",
		 playerData->player.getCallSign()).c_str());
    return;
  }

  sendMessage(ServerPlayer, t,
	      TextUtils::format("%s, you have cancelled the poll to %s %s",
				  playerData->player.getCallSign(),
				  arbiter->getPollAction().c_str(),
				  arbiter->getPollTarget().c_str()).c_str());

  /* poof */
  arbiter->forgetPoll();

  sendMessage(ServerPlayer, AllPlayers,
	      TextUtils::format("The poll was cancelled by %s",
				  playerData->player.getCallSign()).c_str());

  return;
}


static void handlePollCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  char reply[MessageLen] = {0};
  std::string callsign = std::string(playerData->player.getCallSign());

  DEBUG2("\"%s\" has requested a poll: %s\n", callsign.c_str(), message);

  /* make sure player has permission to request a poll */
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::poll)) {
    snprintf(reply, MessageLen, "%s, you are presently not authorized to run /poll", callsign.c_str());
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  DEBUG3("Player has permission to run /poll\n");

  /* make sure that there is a poll arbiter */
  if (BZDB.isEmpty("poll")) {
    sendMessage(ServerPlayer, t, "ERROR: the poll arbiter has disappeared (this should never happen)");
    return;
  }

  DEBUG3("BZDB poll value is not empty\n");

  // only need to do this once
  static VotingArbiter *arbiter = (VotingArbiter *)BZDB.getPointer("poll");

  DEBUG3("Arbiter was acquired with address 0x%p\n", arbiter);

  /* make sure that there is not a poll active already */
  if (arbiter->knowsPoll()) {
    snprintf(reply, MessageLen, "A poll to %s %s is presently in progress", arbiter->getPollAction().c_str(), arbiter->getPollTarget().c_str());
    sendMessage(ServerPlayer, t, reply);
    sendMessage(ServerPlayer, t, "Unable to start a new poll until the current one is over");
    return;
  }

  DEBUG3("The arbiter says there is not another poll active\n");

  // get available voter count
  unsigned short int available = 0;
  for (int i = 0; i < curMaxPlayers; i++) {
    // any registered/known users on the server (including observers)
    // are eligible to vote
    GameKeeper::Player *otherData = GameKeeper::Player::getPlayerByIndex(i);
    if (otherData && otherData->accessInfo.exists()) {
      available++;
    }
  }

  DEBUG3("There are %d available players for %d votes required\n", available, clOptions->votesRequired);

  /* make sure there are enough players to even make a poll that has a chance
   * of succeeding (not counting the person being acted upon)
   */
  if (available - 1 < clOptions->votesRequired) {
    sendMessage(ServerPlayer, t, "Unable to initiate a new poll.  There are not enough registered players playing.");
    snprintf(reply, MessageLen, "There needs to be at least %d other %s and only %d %s available.",
	    clOptions->votesRequired,
	    clOptions->votesRequired - 1 == 1 ? "player" : "players",
	    available - 1,
	    available - 1 == 1 ? "is" : "are");
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  std::string arguments = &message[5]; /* skip "/poll" */
  std::string cmd = "";

  DEBUG3("The arguments string is [%s]\n", arguments.c_str());

  /* find the start of the command */
  size_t startPosition = 0;
  while ((startPosition < arguments.size()) &&
	 (isspace(arguments[startPosition]))) {
    startPosition++;
  }

  DEBUG3("Start position is %d\n", (int)startPosition);

  /* find the end of the command */
  size_t endPosition = startPosition + 1;
  while ((endPosition < arguments.size()) &&
	 (!isspace(arguments[endPosition]))) {
    endPosition++;
  }

  DEBUG3("End position is %d\n", (int)endPosition);

  /* stash the command ('kick', etc) in lowercase to simplify comparison */
  if ((startPosition != arguments.size()) &&
      (endPosition > startPosition)) {
    for (size_t i = startPosition; i < endPosition; i++) {
      cmd += tolower(arguments[i]);
    }
  }

  DEBUG3("Command is %s\n", cmd.c_str());

  /* handle subcommands */

  if ((cmd == "ban") || (cmd == "kick") || (cmd == "kill") || (cmd == "set") || (cmd == "flagreset")) {
    std::string target;
    std::string targetIP = "";

    arguments = arguments.substr(endPosition);

    DEBUG3("Command arguments are [%s]\n", arguments.c_str());

    /* find the start of the target (e.g. player name) */
    startPosition = 0;
    while ((startPosition < arguments.size()) &&
	   (isspace(arguments[startPosition]))) {
      startPosition++;
    }
    // do not include a starting quote, if given
    if (arguments[startPosition] == '"') {
      startPosition++;
    }

    DEBUG3("Start position for target is %d\n", (int)startPosition);

    /* find the end of the target */
    endPosition = arguments.size() - 1;
    while ((endPosition > 0) &&
	   (isspace(arguments[endPosition]))) {
      endPosition--;
    }
    // do not include a trailing quote, if given
    if (arguments[endPosition] == '"') {
      endPosition--;
    }

    DEBUG3("End position for target is %d\n", (int)endPosition);

    target = arguments.substr(startPosition, endPosition - startPosition + 1);

    DEBUG3("Target specified to vote upon is [%s]\n", target.c_str());

    if ((target.length() == 0) && (cmd != "flagreset")) {
      snprintf(reply, MessageLen, "%s, no target was specified for the [%s] vote", callsign.c_str(), cmd.c_str());
      sendMessage(ServerPlayer, t, reply);
      snprintf(reply, MessageLen, "Usage: /poll %s target", cmd.c_str());
      sendMessage(ServerPlayer, t, reply);
      return;
    }

    // Make sure the specific poll type is allowed
    if ((cmd == "set") && (!playerData->accessInfo.hasPerm(PlayerAccessInfo::pollSet))) {
      snprintf(reply, MessageLen, "%s, you may not /poll set on this server", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      DEBUG3("Player %s is not allowed to /poll set\n", callsign.c_str());
      return;
    }
    if ((cmd == "flagreset") && (!playerData->accessInfo.hasPerm(PlayerAccessInfo::pollFlagReset))) {
      snprintf(reply, MessageLen, "%s, you may not /poll flagreset on this server", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      DEBUG3("Player %s is not allowed to /poll flagreset\n", callsign.c_str());
      return;
    }
    if ((cmd == "ban") && (!playerData->accessInfo.hasPerm(PlayerAccessInfo::pollBan))) {
      snprintf(reply, MessageLen, "%s, you may not /poll ban on this server", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      DEBUG3("Player %s is not allowed to /poll ban\n", callsign.c_str());
      return;
    }
    if ((cmd == "kick") && (!playerData->accessInfo.hasPerm(PlayerAccessInfo::pollKick))) {
      snprintf(reply, MessageLen, "%s, you may not /poll kick on this server", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      DEBUG3("Player %s is not allowed to /poll kick\n", callsign.c_str());
      return;
    }

    if ((cmd == "kill") && (!playerData->accessInfo.hasPerm(PlayerAccessInfo::pollKill))) {
      snprintf(reply, MessageLen, "%s, you may not /poll kill on this server", callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      DEBUG3("Player %s is not allowed to /poll kill\n", callsign.c_str());
      return;
    }

	if ((cmd != "set") && (cmd != "flagreset")) {
      // all polls that are not set or flagreset polls take a player name

      /* make sure the requested player is actually here */
      int v = GameKeeper::Player::getPlayerIDByName(target);
      if (v >= curMaxPlayers) {
	/* wrong name? */
	snprintf(reply, MessageLen, 
		"The player specified for a %s vote is not here", cmd.c_str());
	sendMessage(ServerPlayer, t, reply);
	return;
      }
      GameKeeper::Player* targetData = GameKeeper::Player::getPlayerByIndex(v);
      if (!targetData) {
	/* wrong name? */
	snprintf(reply, MessageLen, "The server has no information on %s.", cmd.c_str());
	sendMessage(ServerPlayer, t, reply);
	return;
      }
      targetIP = targetData->netHandler->getTargetIP();

      // admins can override antiperms
      if (!playerData->accessInfo.isAdmin()) {
	// otherwise make sure the player is not protected with an antiperm
	GameKeeper::Player *p = GameKeeper::Player::getPlayerByIndex(v);
	if (p != NULL) {
	  if (p->accessInfo.hasPerm(PlayerAccessInfo::antipoll)) {
	    snprintf(reply, MessageLen, "%s is protected from being polled against.", p->player.getCallSign());
	    sendMessage(ServerPlayer, t, reply);
	    return;
	  }
	  if (cmd == "ban") {
	    if (p->accessInfo.hasPerm(PlayerAccessInfo::antipollban)) {
	      snprintf(reply, MessageLen, "%s is protected from being poll banned.", p->player.getCallSign());
	      sendMessage(ServerPlayer, t, reply);
	      return;
	    }
	  } else if (cmd == "kick") {
	    if (p->accessInfo.hasPerm(PlayerAccessInfo::antipollkick)) {
	      snprintf(reply, MessageLen, "%s is protected from being poll kicked.", p->player.getCallSign());
	      sendMessage(ServerPlayer, t, reply);
	      return;
	    }
	  } else if (cmd == "kill") {
	    if (p->accessInfo.hasPerm(PlayerAccessInfo::antipollkill)) {
	      snprintf(reply, MessageLen, "%s is protected from being poll killed.", p->player.getCallSign());
	      sendMessage(ServerPlayer, t, reply);
	      return;
	    }
	  }
	}
      } // end admin check

    }

    /* create and announce the new poll */
    bool canDo = false;
    if (cmd == "ban") {
      canDo = (arbiter->pollToBan(target, callsign, targetIP));
    } else if (cmd == "kick") {
      canDo = (arbiter->pollToKick(target, callsign, targetIP));
    } else if (cmd == "kill") {
      canDo = (arbiter->pollToKill(target, callsign, targetIP));
    } else if (cmd == "set") {
      canDo = (arbiter->pollToSet(target, callsign));
    } else if (cmd == "flagreset") {
      canDo = (arbiter->pollToResetFlags(callsign));
    }

    if (!canDo) {
      snprintf(reply, MessageLen, "You are not able to request a %s poll right now, %s", cmd.c_str(), callsign.c_str());
      sendMessage(ServerPlayer, t, reply);
      return;
    } else {
      snprintf(reply, MessageLen, "A poll to %s %s has been requested by %s", cmd.c_str(), target.c_str(), callsign.c_str());
      sendMessage(ServerPlayer, AllPlayers, reply);
    }

    unsigned int necessaryToSucceed = (unsigned int)((clOptions->votePercentage / 100.0) * (double)available);
    snprintf(reply, MessageLen, "%d player%s available, %d additional affirming vote%s required to pass the poll (%f %%)", available, available==1?" is":"s are", necessaryToSucceed, necessaryToSucceed==1?"":"s", clOptions->votePercentage);
    sendMessage(ServerPlayer, AllPlayers, reply);

    // set the number of available voters
    arbiter->setAvailableVoters(available);

    // keep track of who is allowed to vote
    for (int j = 0; j < curMaxPlayers; j++) {
      // any registered/known users on the server (including
      // observers) are eligible to vote
      GameKeeper::Player *otherData = GameKeeper::Player::getPlayerByIndex(j);
      if (otherData && otherData->accessInfo.exists()) {
	arbiter->grantSuffrage(otherData->player.getCallSign());
      }
    }

    // automatically place a vote for the player requesting the poll
    DEBUG3("Attempting to automatically place a vote for [%s]\n", callsign.c_str());

    bool voted = arbiter->voteYes(callsign);
    if (!voted) {
      sendMessage(ServerPlayer, t, "Unable to automatically place your vote for some unknown reason");
      DEBUG3("Unable to automatically place a vote for [%s]\n", callsign.c_str());
    }

  } else if (cmd == "vote") {
    std::string voteCmd = "/vote ";
    voteCmd += arguments;
    handleVoteCmd(playerData, voteCmd.c_str());
    return;

  } else if (cmd == "veto") {
    std::string vetoCmd = "/veto ";
    vetoCmd += arguments;
    handleVetoCmd(playerData, vetoCmd.c_str());
    return;

  } else {
    sendMessage(ServerPlayer, t, "Invalid option to the poll command");
    sendMessage(ServerPlayer, t, "Usage: /poll vote yes|no");
    if (playerData->accessInfo.hasPerm(PlayerAccessInfo::pollBan))
      sendMessage(ServerPlayer, t, "    or /poll ban playername");
    if (playerData->accessInfo.hasPerm(PlayerAccessInfo::pollKick))
      sendMessage(ServerPlayer, t, "    or /poll kick playername");
    if (playerData->accessInfo.hasPerm(PlayerAccessInfo::pollKill))
      sendMessage(ServerPlayer, t, "    or /poll kill playername");
    if (playerData->accessInfo.hasPerm(PlayerAccessInfo::pollSet))
      sendMessage(ServerPlayer, t, "    or /poll set variable value");
    if (playerData->accessInfo.hasPerm(PlayerAccessInfo::pollFlagReset))
      sendMessage(ServerPlayer, t, "    or /poll flagreset");

  } /* end handling of poll subcommands */

  return;
}


static void handleViewReportsCmd(GameKeeper::Player *playerData, const char *)
{
  int t = playerData->getIndex();
  std::string line;
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::viewReports)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the viewreports command");
    return;
  }
  if (clOptions->reportFile.size() == 0 && clOptions->reportPipe.size() == 0) {
    line = "The /report command is disabled on this server or there are no reports filed.";
    sendMessage(ServerPlayer, t, line.c_str());
  }
  std::ifstream ifs(clOptions->reportFile.c_str(), std::ios::in);
  if (ifs.fail()) {
    sendMessage(ServerPlayer, t, "Error reading from report file.");
    return;
  }
  while (std::getline(ifs, line))
    sendMessage(ServerPlayer, t, line.c_str());
}


static void handleClientqueryCmd(GameKeeper::Player *playerData, const char * message)
{
  int t = playerData->getIndex();
  DEBUG2("Clientquery requested by %s [%d]\n",
	 playerData->player.getCallSign(), t);
  if (message[12] != '\0') {
    std::string name = message + 13; // assumes there is a space
    while (isspace(name[0]))
      name.erase(name.begin());
    GameKeeper::Player *target;
    int i;
    for (i = 0; i < curMaxPlayers;i++) {
      target = GameKeeper::Player::getPlayerByIndex(i);
      if (target && strcmp(target->player.getCallSign(), name.c_str()) == 0) {
	sendMessage(i, t, TextUtils::format("Version: %s",
		     target->player.getClientVersion()).c_str());
	return;
      }
    }
    sendMessage(ServerPlayer, t, "Player not found.");
    return;
  }
  sendMessage(ServerPlayer, AllPlayers, "[Sent version information per request]");
  // send server's own version string just for kicks
  sendMessage(ServerPlayer, t,
	      TextUtils::format("BZFS Version: %s", getAppVersion()).c_str());
  // send all players' version strings
  // is faking a message from the remote client rude?
  // did that so that /clientquery and CLIENTQUERY look about the same.
  GameKeeper::Player *otherData;
  for (int i = 0; i < curMaxPlayers;i++) {
    otherData = GameKeeper::Player::getPlayerByIndex(i);
    if (otherData && otherData->player.isPlaying()) {
      sendMessage(i, t, TextUtils::format
		  ("Version: %s",
		   otherData->player.getClientVersion()).c_str());
    }
  }
  return;
}


/** /record command
 *
 *  /record start	       # start buffering
 *  /record stop		# stop buffering (or saving to file)
 *  /record size <Mbytes>       # set the buffer size, and truncate
 *  /record rate <secs>	 # set the state capture rate
 *  /record stats	       # display buffer time and memory information
 *  /record file [filename]     # begin capturing straight to file, flush buffer
 *  /record save [filename]     # save buffer to file (or default filename)
 */
static void handleRecordCmd(GameKeeper::Player *playerData, const char * message)
{
  int t = playerData->getIndex();
  const char *buf = message + 8;
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::record)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the /record command");
    return;
  }
  while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

  if (strncasecmp (buf, "start", 5) == 0) {
    Record::start(t);
  }
  else if (strncasecmp (buf, "stop", 4) == 0) {
    Record::stop(t);
  }
  else if (strncasecmp (buf, "size", 4) == 0) {
    buf = buf + 4;
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Record::sendHelp (t);
      return;
    }
    int size = atoi (buf);
    Record::setSize (t, size);
  }
  else if (strncasecmp (buf, "rate", 4) == 0) {
    buf = buf + 4;
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Record::sendHelp (t);
      return;
    }
    int seconds = atoi (buf);
    Record::setRate (t, seconds);
  }
  else if (strncasecmp (buf, "stats", 5) == 0) {
    Record::sendStats(t);
  }
  else if (strncasecmp (buf, "list", 4) == 0) {
    Replay::sendFileList (t); // stolen from '/replay'
  }
  else if (strncasecmp (buf, "save", 4) == 0) {
    buf = buf + 4;
    char filename[MessageLen];

    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace
    if (*buf == '\0') {
      Record::sendHelp (t);
    }

    // get the filename
    sscanf (buf, "%s", filename);

    // FIXME - do this a little better? use quotations for strings?
    while ((*buf != '\0') && !isspace (*buf)) buf++; // eat filename
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Record::saveBuffer (t, filename, 0);
    }
    else {
      Record::saveBuffer (t, filename, atoi(buf));
    }
  }
  else if (strncasecmp (buf, "file", 4) == 0) {
    buf = buf + 4;
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Record::sendHelp (t);
    }
    else {
      Record::saveFile (t, buf);
    }
  }
  else {
    Record::sendHelp (t);
  }

  return;
}


/** /replay command
 *
 *  /replay list		# list available replay files
 *  /replay load [filename]     # set the replay file (or load the default)
 *  /replay play		# began playing
 *  /replay loop		# began playing in looped mode
 *  /replay stats		# report the current replay state
 *  /replay skip <secs>	 # fast foward or rewind in time
 */
static void handleReplayCmd(GameKeeper::Player *playerData, const char * message)
{
  int t = playerData->getIndex();
  const char *buf = message + 7;
  while ((*buf != '\0') && isspace (*buf)) { // eat whitespace
    buf++;
  }
  
  // everyone can use the replay stats command
  if (strncasecmp (buf, "stats", 4) == 0) {
    Replay::sendStats (t);
    return;
  }

  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::replay)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the /replay command");
    return;
  }

  if (strncasecmp (buf, "list", 4) == 0) {
    Replay::sendFileList (t);
  }
  else if (strncasecmp (buf, "load", 4) == 0) {
    buf = buf + 4;
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Replay::sendHelp (t);
    }
    else {
      Replay::loadFile (t, buf);
    }
  }
  else if (strncasecmp (buf, "play", 4) == 0) {
    Replay::play (t);
  }
  else if (strncasecmp (buf, "loop", 4) == 0) {
    Replay::loop (t);
  }
  else if (strncasecmp (buf, "skip", 4) == 0) {
    buf = buf + 4;
    while ((*buf != '\0') && isspace (*buf)) buf++; // eat whitespace

    if (*buf == '\0') {
      Replay::skip (t, 0);
    }
    else {
      int skip = atoi (buf);
      Replay::skip (t, skip);
    }
  }
  else if (strncasecmp (buf, "pause", 5) == 0) {
    Replay::pause (t);
  }
  else {
    Replay::sendHelp (t);
  }

  return;
}

static void handleSayCmd(GameKeeper::Player *playerData, const char * message)
{
  size_t messageStart = 0;
  int t = playerData->getIndex();

  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::say)) {
    char reply[MessageLen] = {0};
    snprintf(reply, MessageLen, "%s, you do not have permission to run the /say command", playerData->player.getCallSign());
    sendMessage(ServerPlayer, t, reply);
    return;
  }

  std::string messageText = &message[4];

  // skip any leading whitespace
  while ((messageStart < messageText.size()) &&
	 (isspace(messageText[messageStart]))) {
    messageStart++;
  }

  // make sure there was _some_ whitespace after /say
  if (messageStart == 0) {
    sendMessage(ServerPlayer, t, "Usage: /say some message");
    return;
  }

  // no anonymous messages
  messageText += " (";
  messageText += playerData->player.getCallSign();
  messageText += ")";

  // send the message
  sendMessage(ServerPlayer, AllPlayers, messageText.c_str() + messageStart );
  return;
}



static void handleDateCmd(GameKeeper::Player *playerData, const char * /*message*/)
{
  int t = playerData->getIndex();
  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::date)) {
    sendMessage(ServerPlayer, t, "You do not have permission to run the /date command");
    return;
  }
  time_t now = time(NULL);
  char* timeStr = ctime(&now);
  timeStr[24] = '\0';
  sendMessage(ServerPlayer, t, timeStr);
}


/** /masterban command
 *
 * /masterban flush	     # remove all master ban entries from this server
 * /masterban reload	    # reread and reload all master ban entries
 * /masterban list	      # output a list of who is banned
 */
static void handleMasterBanCmd(GameKeeper::Player *playerData, const char *message)
{
  int t = playerData->getIndex();
  std::string callsign = std::string(playerData->player.getCallSign());

  DEBUG2("\"%s\" has requested masterban: %s\n", callsign.c_str(), message);

  if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::masterBan)) {
    sendMessage(ServerPlayer, t, TextUtils::format("%s, you are presently not authorized to run /masterban", callsign.c_str()).c_str());
    return;
  }

  DEBUG3("Player has permission to run /masterban\n");

  if (!clOptions->publicizeServer) {
    sendMessage(ServerPlayer, t, "This is not a public server.  Private servers do not use the master ban list.");
  }
  if (clOptions->suppressMasterBanList) {
    sendMessage(ServerPlayer, t, "The master ban list is disabled on this server.");
  }

  std::string argument = &message[10]; /* skip "/masterban" */
  std::string cmd = "";

  // allow for arbitrary whitespace
  size_t start = 0;
  while ((start < argument.size()) &&
	 (isspace(argument[start]))) {
    start++;
  }

  size_t end = 0;
  while ((end < argument.size()) &&
	 (!isspace(argument[end]))) {
    end++;
  }

  // make sure the command is lower case for comparison simplicity/insensitivity
  cmd = argument.substr(start, end - start);
  std::transform(cmd.begin(), cmd.end(), cmd.begin(), tolower);

  if (cmd == "reload") {
    if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::ban) ||
	!playerData->accessInfo.hasPerm(PlayerAccessInfo::unban)) {
      sendMessage(ServerPlayer, t, "You do not have permission to reload the master ban list.");
      sendMessage(ServerPlayer, t, "Permission to ban and unban is required to reload the master ban list.");
      return;
    }

    if (clOptions->publicizeServer && !clOptions->suppressMasterBanList) {
      MasterBanList	banList;
      int               banCount;

      clOptions->acl.purgeMasters();
      sendMessage(ServerPlayer, t, "Previous master ban list entries have been flushed.");

      for (std::vector<std::string>::const_iterator i = clOptions->masterBanListURL.begin(); i != clOptions->masterBanListURL.end(); i++) {
	banCount = clOptions->acl.merge(banList.get(i->c_str()));
	std::string reloadmsg = TextUtils::format("Loaded %d master bans from %s", banCount, i->c_str());
	DEBUG1("%s\n", reloadmsg.c_str());
	sendMessage(ServerPlayer, t, reloadmsg.c_str());
      }

    } else {
      sendMessage(ServerPlayer, t, "No action taken.");
    }

  } else if (cmd == "flush") {
    if (!playerData->accessInfo.hasPerm(PlayerAccessInfo::unban)) {
      sendMessage(ServerPlayer, t, "You do not have permission to reload the master ban list.");
      sendMessage(ServerPlayer, t, "Permission to unban is required to flush the master ban list.");
      return;
    }

    clOptions->acl.purgeMasters();
    sendMessage(ServerPlayer, t, "The master ban list has been flushed.");

  } else if (cmd == "list") {
    std::vector<std::pair<std::string, std::string> > bans = clOptions->acl.listMasterBans();

    if (bans.size() > 20) {
      sendMessage(ServerPlayer, t, TextUtils::format("There are %d bans, only displaying the first 20", bans.size()).c_str());

    } else if (bans.size() == 0) {
      sendMessage(ServerPlayer, t, "There are no master bans loaded.");

    } else {
      // print out a list header
      std::string banmsg = TextUtils::format("Master Bans from %s:", DefaultMasterBanURL);
      sendMessage(ServerPlayer, t, banmsg.c_str());
      for (size_t i = 0; i < banmsg.size(); i++) {
	banmsg[i] = '-';
      }
      sendMessage(ServerPlayer, t, banmsg.c_str());
    }

    // print out the bans
    int counter = 0;
    for (std::vector<std::pair<std::string, std::string> >::const_iterator j = bans.begin(); j != bans.end() && counter < 20; j++, counter++) {
      sendMessage(ServerPlayer, t, TextUtils::format("%s: %s", (j->first).c_str(), (j->second).c_str()).c_str());
    }

  } else {
    if (cmd.size() > 0) {
      sendMessage(ServerPlayer, t, TextUtils::format("Unknown masterban command [%s]", cmd.c_str()).c_str());
    }
    sendMessage(ServerPlayer, t, TextUtils::format("Usage: /masterban list|reload|flush").c_str());
  }

  return;
}


// parse server comands
void parseServerCommand(const char *message, int t)
{
  if (!message) {
    std::cerr << "WARNING: parseCommand was given a null message?!" << std::endl;
    return;
  }

  GameKeeper::Player *playerData = GameKeeper::Player::getPlayerByIndex(t);
  if (!playerData)
    return;

  if (strncasecmp(message + 1, "msg", 3) == 0) {
    handleMsgCmd(playerData, message);

  } else if (strncasecmp(message + 1, "serverquery", 11) == 0) {
    handleServerQueryCmd(playerData, message);

  } else if (strncasecmp(message + 1, "part", 4) == 0) {
    handlePartCmd(playerData, message);

  } else if (strncasecmp(message + 1, "quit", 4) == 0) {
    handleQuitCmd(playerData, message);

  } else if (strncasecmp(message + 1, "uptime", 6) == 0) {
    handleUptimeCmd(playerData, message);

  } else if (strncasecmp(message + 1, "password", 8) == 0) {
    handlePasswordCmd(playerData, message);

  } else if (strncasecmp(message + 1, "set ", 4) == 0) {
    handleSetCmd(playerData, message);

  } else if (strncasecmp(message + 1, "reset", 5) == 0) {
    handleResetCmd(playerData, message);

  } else if (strncasecmp(message + 1, "shutdownserver", 8) == 0) {
    handleShutdownserverCmd(playerData, message);

  } else if (strncasecmp(message + 1, "superkill", 8) == 0) {
    handleSuperkillCmd(playerData, message);

  } else if (strncasecmp(message + 1, "gameover", 8) == 0) {
    handleGameoverCmd(playerData, message);

  } else if (strncasecmp(message + 1, "countdown", 9) == 0) {
    handleCountdownCmd(playerData, message);

  } else if (strncasecmp(message + 1, "flag ", 5) == 0) {
    handleFlagCmd(playerData,message);

  } else if (strncasecmp(message + 1, "kick", 4) == 0) {
    handleKickCmd(playerData, message);

  } else if (strncasecmp(message + 1, "kill", 4) == 0) {
    handleKillCmd(playerData, message);

  } else if (strncasecmp(message+1, "banlist", 7) == 0) {
    handleBanlistCmd(playerData, message);

  } else if (strncasecmp(message+1, "hostbanlist", 11) == 0) {
    handleHostBanlistCmd(playerData, message);

  } else if (strncasecmp(message+1, "ban", 3) == 0) {
    handleBanCmd(playerData, message);

  } else if (strncasecmp(message+1, "hostban", 7) == 0) {
    handleHostBanCmd(playerData, message);

  } else if (strncasecmp(message+1, "unban", 5) == 0) {
    handleUnbanCmd(playerData, message);

  } else if (strncasecmp(message+1, "hostunban", 9) == 0) {
    handleHostUnbanCmd(playerData, message);

  } else if (strncasecmp(message+1, "lagwarn",7) == 0) {
    handleLagwarnCmd(playerData, message);

  } else if (strncasecmp(message+1, "lagstats",8) == 0) {
    handleLagstatsCmd(playerData, message);

  } else if (strncasecmp(message+1, "idlestats",9) == 0) {
    handleIdlestatsCmd(playerData, message);

  } else if (strncasecmp(message+1, "flaghistory", 11 ) == 0) {
    handleFlaghistoryCmd(playerData, message); 

  } else if (strncasecmp(message+1, "mute", 4 ) == 0 ) {
    handleMuteCmd(playerData, message);

  } else if (strncasecmp(message+1, "unmute", 6 ) == 0 ) {
    handleUnmuteCmd(playerData, message);

  } else if (strncasecmp(message+1, "playerlist", 10) == 0) {
    handlePlayerlistCmd(playerData, message);

  } else if (strncasecmp(message+1, "report", 6) == 0) {
    handleReportCmd(playerData, message);

  } else if (strncasecmp(message+1, "help", 4) == 0) {
    handleHelpCmd(playerData, message);

  } else if (strncasecmp(message + 1, "identify", 8) == 0) {
    handleIdentifyCmd(playerData, message);

  } else if (strncasecmp(message + 1, "register", 8) == 0) {
    handleRegisterCmd(playerData, message);

  } else if (strncasecmp(message + 1, "ghost", 5) == 0) {
    handleGhostCmd(playerData, message);

  } else if (strncasecmp(message + 1, "deregister", 10) == 0) {
    handleDeregisterCmd(playerData, message);

  } else if (strncasecmp(message + 1, "setpass", 7) == 0) {
    handleSetpassCmd(playerData, message);

  } else if (strncasecmp(message + 1, "grouplist", 9) == 0) {
    handleGrouplistCmd(playerData, message);

  } else if (strncasecmp(message + 1, "showgroup", 9) == 0) {
    handleShowgroupCmd(playerData, message);

  } else if (strncasecmp(message + 1, "groupperms", 10) == 0) {
    handleGrouppermsCmd(playerData, message);

  } else if (strncasecmp(message + 1, "setgroup", 8) == 0) {
    handleSetgroupCmd(playerData, message);

  } else if (strncasecmp(message + 1, "removegroup", 11) == 0) {
    handleRemovegroupCmd(playerData, message);

  } else if (strncasecmp(message + 1, "reload", 6) == 0) {
    handleReloadCmd(playerData, message);

  } else if (strncasecmp(message + 1, "poll", 4) == 0) {
    handlePollCmd(playerData, message);

  } else if (strncasecmp(message + 1, "vote", 4) == 0) {
    handleVoteCmd(playerData, message);

  } else if (strncasecmp(message + 1, "veto", 4) == 0) {
    handleVetoCmd(playerData, message);

  } else if (strncasecmp(message + 1, "viewreports", 11) == 0) {
    handleViewReportsCmd(playerData, message);

  } else if (strncasecmp(message + 1, "clientquery", 11) == 0) {
    handleClientqueryCmd(playerData, message);

  } else if (strncasecmp(message + 1, "date", 4) == 0 || strncasecmp(message + 1, "time", 4) == 0) {
    handleDateCmd(playerData, message);

  } else if (strncasecmp(message + 1, "record", 6) == 0) {
    handleRecordCmd(playerData, message);

  } else if (strncasecmp(message + 1, "replay", 6) == 0) {
    handleReplayCmd(playerData, message);

  } else if (strncasecmp(message + 1, "say", 3) == 0) {
    handleSayCmd(playerData, message);

  } else if (strncasecmp(message + 1, "masterban", 9) == 0) {
    handleMasterBanCmd(playerData, message);
    
  //Start "Race to 7" by RPG
  } else if (strncasecmp(message + 1, "match start", 11) == 0) {
    //Start logging in the file
    FILE *f;
    f=fopen("match.txt","w");
    fprintf(f,"Match started at %s\n", TimeKeeper::timestamp());
    
    match_in_progress = true;
    fprintf(f,"match_in_progress set to true");
    sendMessage(ServerPlayer, AllPlayers, "A match has been started!");
    //Do a flagreset
    zapAllFlags();
    fprintf(f,"All flags reset");
    //Reset the team scores
    bz_resetTeamScore(RedTeam);
    bz_resetTeamScore(BlueTeam);
    fprintf(f,"Red and Blue team scores have been reset");
    
    fclose(f);
    
    } else if (strncasecmp(message + 1, "match end", 9) == 0) {
           
    if((bz_getTeamWins(RedTeam) == 7 || bz_getTeamWins(BlueTeam) == 7) && match_in_progress){
                               
    //Get player info
    std::string players;
    players = "\nBelow is a list of players:\n-----";
    for (int i = 0; i < curMaxPlayers; i++) {
       GameKeeper::Player *data;
       data = GameKeeper::Player::getPlayerByIndex(i);
       players += "\nCallsign: ";
       players += data->player.getCallSign();
       players += "\nE-mail: ";
       players += data->player.getEMail();
       players += "\nTeam: ";
       if(data->player.getTeam() == 0) players += "Rogue";
       if(data->player.getTeam() == 1) players += "Red";
       if(data->player.getTeam() == 2) players += "Green";
       if(data->player.getTeam() == 3) players += "Blue";
       if(data->player.getTeam() == 4) players += "Purple";
       if(data->player.getTeam() == 5) players += "Observer";
       players += "\n-----";
    }
    
    //Get team info
    //Red team
    players += "\n\nRed Team:\nScore: ";
    int RedTeaminfo = bz_getTeamScore(RedTeam);
    players += TextUtils::format ("%d",RedTeaminfo);
    players += "\nWins: ";
    RedTeaminfo = bz_getTeamWins(RedTeam);
    if(RedTeaminfo == 7) {players += "\nRED TEAM WINS!!!!!!!!!!!";}
    players += TextUtils::format ("%d",RedTeaminfo);
    players += "\nLosses: ";
    RedTeaminfo = bz_getTeamLosses(RedTeam);
    players += TextUtils::format ("%d",RedTeaminfo);
    //Blue team
    players += "\n\nBlue Team:\nScore: ";
    int BlueTeaminfo = bz_getTeamScore(BlueTeam);
    players += TextUtils::format ("%d",BlueTeaminfo);
    players += "\nWins: ";
    BlueTeaminfo = bz_getTeamWins (BlueTeam);
    if(BlueTeaminfo == 7) {players += "\nBLUE TEAM WINS!!!!!!!!!!!";}
    players += TextUtils::format ("%d",BlueTeaminfo);
    players += "\nLosses: ";
    BlueTeaminfo = bz_getTeamLosses (BlueTeam);
    players += TextUtils::format ("%d",BlueTeaminfo);
    players += "\n\n";
     
    //URL Encode it all
    //players = TextUtils::url_encode(players);
    
    //Write to file
    FILE *f;
    f=fopen("match.txt","a"); 
    fprintf(f,"%s",players.c_str());
    fprintf(f,"\nMatch over at %s", TimeKeeper::timestamp());
    sendMessage( ServerPlayer, AllPlayers, "Match Reported. You will all now lose your flags.");
    
    //DE-FLAG THE PLAYERS!
    zapAllFlags();
    fprintf(f,"\nAll flags reset");
    
    //Reset team scores
    bz_resetTeamScore(RedTeam);
    bz_resetTeamScore(BlueTeam);
    fprintf(f,"\nRed and Blue team scores reset");

    gameOver = true;
    if (clOptions->timeManualStart){
      countdownActive = false;
    }
    //There is no more match, I hope
    match_in_progress = false;
    fprintf(f,"\nmatch_in_progress set to false");
    fclose(f);
    }else{
         sendMessage( ServerPlayer, AllPlayers, "What do you think you're trying to do? Report the match before someone wins!");
         sendMessage( ServerPlayer, AllPlayers, "WHY are you so HELL BENT on screwing up the SYSTEM? HUH?");
    }
    //End "Race to 7" by RPG


  } else {
    // lets see if it is a custom command
    std::vector<std::string> params = TextUtils::tokenize(std::string(message+1),std::string(" "));

    if (params.size() == 0)
      return;
    
    tmCustomSlashCommandMap::iterator itr = customCommands.find(TextUtils::tolower(params[0]));
  
    bzApiString	command = params[0];
    bzApiString param;

    if (params.size()>1)
      param = params[1];
    else
      param = message;

    if (itr != customCommands.end()) {  // see if we have a registerd custom command and call it
      if (itr->second->handle(t, command, param))  // if it handles it, then we are good
        return;
    }
  
    // lets see if anyone wants to handle the unhandled event
    bz_UnknownSlashCommandEventData commandData;
    commandData.from = t;
    commandData.message = message;
    commandData.time = TimeKeeper::getCurrent().getSeconds();
  
    worldEventManager.callEvents(bz_eUnknownSlashCommand, -1, &commandData);
    if (commandData.handled) // did anyone do it?
      return;

    char reply[MessageLen];
    snprintf(reply, MessageLen, "Unknown command [%s]", message + 1);
    sendMessage(ServerPlayer, t, reply);
  }
}

void registerCustomSlashCommand(std::string command, bz_CustomSlashCommandHandler* handler)
{
  if (handler)
    customCommands[TextUtils::tolower(command)] = handler;
}

void removeCustomSlashCommand(std::string command)
{
  tmCustomSlashCommandMap::iterator itr = customCommands.find(TextUtils::tolower(command));
  if (itr != customCommands.end())
    customCommands.erase(itr);
}


// Local Variables: ***
// mode: C++ ***
// tab-width: 8 ***
// c-basic-offset: 2 ***
// indent-tabs-mode: t ***
// End: ***
// ex: shiftwidth=2 tabstop=8