public static void TestPoint(Server server, ISender sender, ArgumentList args)
        {
            string param;
            Player player = server.GetPlayerByName(sender.Name);

            if (args.TryGetString(0, out param))
            {
                switch (param.ToUpper())
                {
                    case "LOBBY":
                        player.sendMessage("Teleporting to the lobby", Login.plugin.chatColor);
                        Login.plugin.TeleportPlayerToPoint(player, Login.LOBBY);
                        break;
                    case "VALIDATED":
                        player.sendMessage("Teleporting to the validated point", Login.plugin.chatColor);
                        Login.plugin.TeleportPlayerToPoint(player, Login.VALIDATED);
                        break;
                    default:
                        player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
                        break;
                }
            }
            else
                player.sendMessage("You must specify either lobby or validated", Login.plugin.chatColor);
        }

        /// <summary>
        /// De-OPs a given Player.
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="args">Arguments sent with command</param>
        public static void DeopPlayer(ISender sender, ArgumentList args)
        {
            var playerName = args.GetString(0);
            Player player;
            if (args.TryGetOnlinePlayer(0, out player))
            {
                playerName = player.Name;

                if (Player.isInOpList(playerName))
                {
                    player.sendMessage("You have been De-Opped!.", ChatColor.Green);
                }

                player.Op = false;
                if (player.HasClientMod)
                {
                    NetMessage.SendData(Packet.CLIENT_MOD, player.whoAmi);
                }
            }

            if (Player.isInOpList(playerName))
            {
                Server.notifyOps("De-Opping " + playerName + " {" + sender.Name + "}", true);
                Server.OpList.removeException(playerName + ":" + Player.GetPlayerPassword(playerName));
            }

            if (!Server.OpList.Save())
            {
                Server.notifyOps("OpList Failed to Save due. {" + sender.Name + "}", true);
                return;
            }
        }

 public void HandleData(MemBlock payload, ISender return_path, object state) {
   if(_sub != null) {
     MemBlock rest = null;
     PType.Parse(payload, out rest);
     _sub.Handle(rest, return_path);
   }
 }

 // Provides a method for local apps to add certificates to Brunet without
 // being loaded with Brunet.
 public void HandleRpc(ISender caller, string method, IList args, object rs)
 {
   object result = null;
   try {
     if(method.Equals("AddCertificate")) {
       ReqrepManager.ReplyState rqrs = caller as ReqrepManager.ReplyState;
       if(rqrs == null || !(rqrs.ReturnPath is Node)) {
         throw new Exception("Call must be made locally for security reasons!");
       }
       string path = (string) args[0];
       result = _ch.AddCertificate(path);
     } else if(method.Equals("GetState")) {
       if(args.Count != 1) {
         throw new Exception("Not enough arguments");
       } else if(!(args[0] is string)) {
         throw new Exception("Argument should be a string");
       }
       Address addr = AddressParser.Parse(args[0] as string);
       SecurityAssociation sa = CheckForSecureSender(addr);
       if(sa == null) {
         result = "No SA";
       } else {
         result = sa.ToString();
       }
     } else {
       result = new Exception("Invalid method");
     }
   } catch (Exception e) {
     result = e;
   }
   _node.Rpc.SendResult(rs, result);
 }

    /// <summary>Create a DtlsFilter.</summary>
    /// <param name="key">A CryptoKey initialized by the OpenSSL.NET library.</param>
    /// <param name="cert">The path to the certificate to use.</param>
    /// <param name="ca_cert">The path to the ca certificate to use.</param>
    /// <param name="client">Use client initialization parameters.</param>
    public DtlsAssociation(ISender sender, CertificateHandler ch, PType ptype,
        Ssl ssl, bool client) : base(sender, ch)
    {
      _ip = new IdentifierPair();
      PType = ptype;
      _ssl = ssl;
      _client = client;
      _ssl.SetReadAhead(1);
      // Buggy SSL versions have issue with compression and dtls
      _ssl.SetOptions((int) SslOptions.SSL_OP_NO_COMPRESSION);
      if(client) {
        _ssl.SetConnectState();
      } else {
        _ssl.SetAcceptState();
      }

      // The ssl object will take control
      _read = BIO.MemoryBuffer(false);
      _read.NonBlocking = true;
      _write = BIO.MemoryBuffer(false);
      _write.NonBlocking = true;

      _ssl.SetBIO(_read, _write);
      _ssl.DoHandshake();

      _buffer = new byte[Int16.MaxValue];
      _buffer_sync = new object();
      _fe_lock = 0;
    }

        /// <summary>
        /// Enables or disables NPC spawning
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="args">Arguments sent with command</param>
        public void NPCSpawning(ISender sender, ArgumentList args)
        {
            args.ParseNone();

            Core.StopNPCSpawning = !Core.StopNPCSpawning;
            sender.Message("NPC spawning is now " + (Core.StopNPCSpawning ? "off" : "on") + "!");
        }

 public InstructionPacketSetID(byte servoId, byte newId, ISender sender)
     : base(servoId, sender)
 {
     _instruction = 0x03;
     _lengthOfCommand = 0x04;
     _parameters.AddRange(new[] { (byte)0x03, newId });
 }

 /// <summary>
 /// Allows users to log in.
 /// </summary>
 /// <param name="sender">Sending player</param>
 /// <param name="password">Password for verification</param>
 public void Auth(ISender sender, string password)
 {
     if (sender is Player)
     {
         var player = sender as Player;
         if (Storage.IsAvailable)
         {
             var existing = Authentication.GetPlayer(sender.SenderName);
             if (existing != null)
             {
                 if (existing.ComparePassword(sender.SenderName, password))
                 {
                     Utils.NotifyAllOps(
                         String.Format("{0} successfully logged in.", player.name)
                     );
                     player.SendMessage("Successfully logged in.", Color.DarkGreen);
                     player.SetAuthentication(sender.SenderName, "tdsm");
                     player.SetOp(existing.Operator);
                 }
                 else
                 {
                     sender.Message("Login failed", Color.DarkRed);
                 }
             }
             else
             {
                 sender.Message("Login failed", Color.DarkRed);
             }
         }
         else
             sender.Message("This function is unavailable", Color.DarkRed);
     }
 }

 /// <summary>
 /// Bans a user from the server.
 /// </summary>
 /// <param name="sender">Sending entity</param>
 /// <param name="args">Arguments sent with command</param>
 public static void Ban(ISender sender, string player)
 {
     if (sender is ConsoleSender)
     {
         if (String.IsNullOrEmpty(player))
         {
             Tools.WriteLine("Usage: ban <player>");
         }
         else
         {
             bool found = false;
             var lowered = player.ToLower();
             for (int i = 0; i < 255; i++)
             {
                 if (Main.player[i].active && Main.player[i].name.ToLower() == lowered)
                 {
                     Callbacks.NetplayCallback.AddBan(i);
                     NetMessage.SendData(2, i, -1, "Banned from server.", 0, 0f, 0f, 0f, 0);
                     found = true;
                 }
             }
             if (!found) sender.Message("Failed to find a player by the name of {0}", player);
         }
     }
 }

 public void Subscribe(ISender sender)
 {
     sender.MessageAvailable += (o, args) =>
                                    {
                                        ReceivedMessage = args.Message;
                                    };
 }

        /// <summary>
        /// Prints a player list, Possibly readable by bots.
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="args">Arguments sent with command</param>
        public void List(ISender sender, ArgumentList args)
        {
            args.ParseNone();

            var players = from p in Terraria.Main.player
                                   where p.active && !p.IsOp()
                                   select p.name;
            var ops = from p in Terraria.Main.player
                               where p.active && p.IsOp()
                               select p.name;

            var pn = players.Count();
            var on = ops.Count();

            if (on + pn == 0)
            {
                sender.Message("No players online.");
                return;
            }

            string ps = String.Empty;
            string os = String.Empty;

            if (pn > 0)
                ps = (on > 0 ? " | Players: " : "Players: ") + String.Join(", ", players);

            if (on > 0)
                os = "Ops: " + String.Join(", ", ops);

            sender.SendMessage(string.Concat(os, ps, " (", on + pn, "/", Netplay.MaxConnections, ")"), 255, 255, 240, 20);
        }

        /// <summary>
        /// Teleports specified player to sending player's location.
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="args">Arguments sent with command</param>
        public void TeleportHere(ISender sender, ArgumentList args)
        {
            if (sender is Player)
            {
                Player player = ((Player)sender);
                Player subject;

                if (args.TryPopOne(out subject))
                {
                    if (subject == null)
                    {
                        sender.Message("Cannot find player");
                        return;
                    }

                    subject.Teleport(player);

                    Utils.NotifyAllOps("Teleported " + subject.name + " to " +
                        player.name + " [" + sender.SenderName + "]", true);
                }
            }
            else
            {
                throw new CommandError("This command is for players only");
            }
        }

        public RequestCommand(ISender sender)
        {
            if (sender == null)
                throw new ArgumentNullException("sender");

            this.sender = sender;
        }

        void ChangePassword(ISender sender, string password)
        {
            if (!Storage.IsAvailable)
                throw new CommandError("No permissions plugin or data plugin is attached");

            var player = sender as Player;
            if (player == null)
            {
                sender.SendMessage("This is a player command", G: 0, B: 0);
                return;
            }
            else if (!player.IsAuthenticated())
            {
                sender.SendMessage("You are not authenticated.", G: 0, B: 0);
                return;
            }
            else if (password == null || password.Trim().Length < MinPasswordLength)
            {
                sender.SendMessage("Please specify a password longer than 5 characters.", G: 0, B: 0);
                return;
            }

            var auth = player.GetAuthenticatedAs();

            if (Authentication.UpdatePlayer(auth, password))
            {
                sender.SendMessage("Your password is now updated.", R: 0, B: 0);
            }
            else
            {
                sender.SendMessage("Failed to update your password.", G: 0, B: 0);
            }
        }

        void PasswordCommand(ISender sender, ArgumentList args)
        {
            Player player = sender as Player;
                Protection temp = new Protection ();
                Pair<Action, Protection> pair = new Pair<Action, Protection> (Action.NOTHING, null);

                if (args.Count != 1) {
                    player.SendMessage ("Usage: /cpassword <password>", 255, 255, 0, 0);
                    return;
                }

                string Extra = args[0];

                temp = new Protection ();
                temp.Owner = player.Name;
                temp.Type = Protection.PASSWORD_PROTECTION;
                temp.Data = SHA1.Hash (Extra);

                char[] pass = Extra.ToCharArray ();
                for (int index = 0; index < pass.Length; index++) {
                    pass [index] = '*';
                }

                pair.First = Action.CREATE;
                pair.Second = temp;

                player.SendMessage ("Password: " + new string (pass), 255, 255, 0, 0);
                player.SendMessage ("Open the chest to protect it!", 255, 0, 255, 0);

            // cache the action if it's not null!
            if (pair.First != Action.NOTHING) {
                ResetActions (player);
                Cache.Actions.Add (player.Name, pair);
            }
        }

 //TODO sort commands in alphabetical order.
 /// <summary>
 /// Shuts down an exists.
 /// </summary>
 /// <param name="sender">Sending entity</param>
 /// <param name="args">Arguments sent with command</param>
 public static void Clear(ISender sender, ArgumentList args)
 {
     if (sender is ConsoleSender)
     {
         Console.Clear();
     }
 }

        private void WhoAmI(ISender sender, string args)
        {
            var player = sender as Player;
            if (player != null)
            {
                var sb = new StringBuilder();
                sb.Append("You are ");
                if (!player.IsAuthenticated()) sb.Append("not ");

                if (player.Op) sb.Append("an operator");
                else sb.Append("logged in");

                var groupName = String.Empty;
                if (Storage.IsAvailable)
                {
                    var grp = Storage.GetInheritedGroup(player);
                    if (grp != null) groupName = grp.Name;
                }

                if (!String.IsNullOrEmpty(groupName))
                {
                    sb.Append(" and are a part of the ");
                    sb.Append(groupName);
                    sb.Append(" group");
                }
                else sb.Append(" but not apart of any groups");

                sb.Append(".");
                sender.Message(sb.ToString(), Color.Orange);
            }
            else sender.Message("This command is for players only", Color.Red);
        }

        /// <summary>
        /// Heals one or all players.
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="message">Message to send</param>
        public void Heal(ISender sender, ArgumentList args)
        {
            Player subject;

            if (args.TryPopOne(out subject))
            {
                subject = sender as Player;
                if (subject == null)
                {
                    sender.Message("Need a heal target");
                    return;
                }

                NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, subject.whoAmI, (float)subject.statLifeMax);
                subject.Message("You have been healed!", Color.Green);
            }
            else if (args.TryPop("-all"))
            {
                foreach (var plr in Main.player)
                {
                    if (plr.active)
                    {
                        NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, plr.whoAmI, (float)plr.statLifeMax);
                        plr.Message("You have been healed!", Color.Green);
                    }
                }
            }
            else if (sender is Player)
            {
                var plr = sender as Player;
                NetMessage.SendData((int)Packet.HEAL_PLAYER, -1, -1, String.Empty, plr.whoAmI, (float)plr.statLifeMax);
                plr.Message("You have been healed!", Color.Green);
            }
            else throw new CommandError("Nobody specified to heal");
        }

    public void HandleData(MemBlock packet, ISender from, object node)
    {
      _message_count++;

      long stop_time, rt_ticks = -10000;

      if ( !from.Equals(node)) {
        if (packet[0] == 0) {
        //log.Debug("Echo Response:");
	  stop_time = System.DateTime.Now.Ticks;
	  int received_uid = NumberSerializer.ReadInt(packet, 1);
          if(uid_starttime.ContainsKey(received_uid)){
		rt_ticks = stop_time - (long)EchoTester.uid_starttime[received_uid];
	  }
	  double rt_ms = (double) rt_ticks/10000.0;
	  uid_brunetpingtime.Add(received_uid, rt_ms);
	  Console.WriteLine("Packet ID = {0}, Round-trip = {1}", received_uid, rt_ms); 	  
        }
        else {
        //log.Debug("Echo Request:");
        }

        //log.Debug(packet.ToString());

        //System.Console.WriteLine("{0}", packet.ToString());

        if (packet[0] > 0) {
          //Send a reply back, this is a request  
	  byte[] new_payload = new byte[ packet.Length ];
	  packet.CopyTo(new_payload, 0);
          new_payload[0] = (byte) 0;
          from.Send(new CopyList(PType.Protocol.Echo, MemBlock.Reference(new_payload)));
        }
      }
    }

        /// <summary>
        /// Refreshes a players area
        /// </summary>
        /// <param name="sender">Sending player</param>
        /// <param name="args">Arguments sent with command</param>
        public void Refresh(ISender sender, ArgumentList args)
        {
            args.ParseNone();

            var player = sender as Player;

            if (player == null)
            {
                sender.Message(255, "This is a player command");
                return;
            }

            if (player.whoAmI < 0)
                return;

            if (!player.Op)
            {
                var diff = DateTime.Now - player.GetLastCostlyCommand();

                if (diff < TimeSpan.FromSeconds(30))
                {
                    sender.Message(255, "You must wait {0:0} more seconds before using this command.", 30.0 - diff.TotalSeconds);
                    return;
                }

                player.SetLastCostlyCommand(DateTime.Now);
            }

            NetMessage.SendTileSquare(player.whoAmI, (int)(player.position.X / 16), (int)(player.position.Y / 16), 32);
        }