public object execute(IClient client, string command)
        {
            if (client != null)
            {
                string source = "";
                Match match = Regex.Match(command, "\"(.*)\"", RegexOptions.IgnoreCase);
                string[] args = command.Replace(" ", "").Split(',');
                if (match.Success)
                {
                    source = match.Groups[1].Value;
                }
                else
                {
                    source = args[2];
                }

                int fileRegister1;
                Int32.TryParse(args[1], out fileRegister1);
                string semantics = args[2];
                int fileRegister2;
                Int32.TryParse(args[3], out fileRegister2);
                string salt = source;

                client.Copy(fileRegister1, semantics, fileRegister2, salt);
            }
            return null;
        }

        public FileExplorerForm(IServerUIHandler UIHandler, IClient c)
        {
            Client = c;
            UIHost = UIHandler;
            InitializeComponent();

            Image uiFolder = UIHandler.GetImage("folder.png");
            Image uiFolder2 = UIHandler.GetImage("folder2.png");
            Image uiFile = UIHandler.GetImage("file.png");
            Image uiDrive = UIHandler.GetImage("drive.png");
            Image uiError = UIHandler.GetImage("error.png");

            if(uiFolder != null)
                images.Images.Add("Folder", uiFolder);
            if (uiFolder2 != null)
                images.Images.Add("Folder2", uiFolder2);
            if (uiFile!=null)
                images.Images.Add("File", uiFile);
            if(uiDrive!=null)
                images.Images.Add("Drive", uiDrive);
            if(uiError != null)
                images.Images.Add("Error", uiError);

            lvFileView.SmallImageList = images;
            lvFileBucket.SmallImageList = images;
            c.Send((byte)NetworkCommand.FileManager, (byte)FileManagerCommand.Update, string.Empty);
        }

        public bool InitRemotableObjekt(int pin_Port, string pin_URL)
        {
            try
            {
                // Creates a proxy for the well-known object
                // indicated by the specified type and URL.
                IDictionary prop = new Hashtable();
                prop["name"] = "tcppELSClient";
                prop["port"] = pin_Port.ToString();
                ChannelServices.RegisterChannel(new TcpChannel(prop, null, null));

                this._proxyClient
                    = (IClient)Activator.GetObject(
                    // type of object
                    typeof(IClient),
                    // specified URL
                    pin_URL);

                Console.WriteLine("Remoting initialized");

                return true;
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
                return false;

            }
        }

 public void Use(IClient iClient, string commandName, string[] tokens)
 {
     Client client = iClient as Client;
     client.SendMessage("Online Players: " + client.Owner.Server.Clients.Count);
     foreach (Client c in client.Owner.Server.GetAuthenticatedClients())
         client.SendMessage(c.Owner.EntityId + " : " + c.Owner.DisplayName);
 }

 public EditStopLimitOrderViewModel(IClient client, StopLimitOrderDto stopLimitOrder)
 {
     this.client = client;
     this.stopLimitOrder = stopLimitOrder;
     SetFields(stopLimitOrder);
     SetupCommandsAndBehaviour();
 }

 public void Show (IClient connectingClient)
 {
     if (!Visible) {
         client = connectingClient;
         Open ();
     }
 }

        protected override void DoInteraction(IClient iClient, IItemInventory item)
        {
            base.DoInteraction(iClient, item);

            Client client = iClient as Client;
            if (client == null)
                return;

            if (item != null && !ItemHelper.IsVoid(item))
            {
                if (item.Type == (short)BlockData.Items.Raw_Fish && !Data.IsTamed)
                {
                    FishUntilTamed--;
                    client.Owner.Inventory.RemoveItem(item.Slot); // consume the item

                    if (FishUntilTamed <= 0)
                    {
                        Data.IsTamed = true;
                        Data.TamedBy = client.Username;
                        Health = MaxHealth;
                        // TODO: begin following this.Data.TamedBy
                        SendMetadataUpdate();
                    }
                }
            }
        }

        public void ExecuteRequest(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:Storage:ExecuteRequest()");
            var request = bnet.protocol.storage.ExecuteRequest.ParseFrom(packetIn.Payload.ToArray());
            //Logger.Debug("request:\n{0}", request.ToString());
            
            bnet.protocol.storage.ExecuteResponse response = null;
            switch (request.QueryName)
            {
                case "GetGameAccountSettings":
                    response = GameAccountSettings(request);
                    break;
                case "LoadAccountDigest":
                    response = LoadAccountDigest(request);
                    break;
                case "GetHeroDigests":
                    response = GetHeroDigest(request);
                    break;
                case "GetToonSettings":
                    response = GetToonSettings(request);
                    break;
                default:
                    Logger.Warn("Unhandled ExecuteRequest: {0}", request.QueryName);
                    break;
            }                
            
            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

        public static void Identify(IClient client, CodedInputStream stream)
        {
            var header = new Header(stream);
            var payload = new byte[header.PayloadLength];
            payload = stream.ReadRawBytes((int)header.PayloadLength);

            var packet = new Packet(header, payload);
            var service = Service.GetByID(header.ServiceID);

            if (service == null)
            {
                Logger.Error("No service exists with id: 0x{0}", header.ServiceID.ToString("X2"));
                return;
            }

            var method = service.DescriptorForType.Methods[(int)header.MethodID - 1];
            var proto = service.GetRequestPrototype(method);
            var builder = proto.WeakCreateBuilderForType();

            try
            {
                var message = builder.WeakMergeFrom(CodedInputStream.CreateInstance(packet.Payload.ToArray())).WeakBuild();

                ((IServerService) service).Client = client;
                service.CallMethod(method, null, message, (msg => SendResponse(client, header.RequestID, msg)));
            }
            catch (NotImplementedException)
            {
                Logger.Debug(string.Format("Unimplemented service method: {0} {1}", service.GetType().Name, method.Name));
            }
            catch(Exception e)
            {
                Logger.DebugException(e,string.Empty);
            }
        }

        public void Use(IClient client, string commandName, string[] tokens)
        {
            if (tokens.Length < 1)
            {
                Help(client);
                return;
            }

            var toKick = client.GetServer().GetClients();


            if (toKick.Any() && tokens[0].ToLower() != "all")
            {
                foreach (var client1 in toKick.Where(client1 => !client1.GetOwner().CanUseCommand("chraft.kick.exempt")))
                {
                    client1.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
                    client.SendMessage("Kicked " + client1.GetOwner().Name);
                }
            }
            else
            {
                foreach (IClient t in toKick.Where(t => t.GetOwner().Name.ToLower() == tokens[0].ToLower()).Where(t => !t.GetOwner().CanUseCommand("chraft.kick.exempt")))
                {
                    t.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
                    client.SendMessage("Kicked " + t.GetOwner().Name);
                }
            }
        }

 public NotificationContainer(IClient client, bool status)
 {
     Value = status;
     Client = client;
     Type = NotificationType.StatusUpdate;
     TimeStamp = DateTime.Now;
 }

 public TabComplete(IClient client)
 {
     this.client = client;
     this.tabHandlers = new TypeList<ITabHandler>(
         TypeHelpers.ClassesForInterfaceInAssembly<ITabHandler>().ToList()
     );
 }

 public QpidResourceHolder(IClientFactory connectionFactory, IClient connection, IClientSession channel)
 {
     this.clientFactory = connectionFactory;
     AddConnection(connection);
     AddChannel(channel);
     this.frozen = true;
 }

        public static void HandleMessage(Packet packet, IClient client, bool fromQueue)
        {
            Packet reply = new Packet(PacketFamily.Welcome, PacketAction.Reply);

            client.EnterGame();
            client.Character.Map.Enter(client.Character, WarpAnimation.Admin);

            reply.AddShort((short)WelcomeReply.WorldInfo);
            reply.AddBreak();

            for (int i = 0; i < 9; ++i)
            {
                reply.AddBreakString("A");
            }

            reply.AddChar(client.Character.Weight); // Weight
            reply.AddChar(client.Character.MaxWeight); // Max Weight

            // Inventory
            foreach (ItemStack item in client.Character.Items)
            {
                reply.AddShort(item.Id);
                reply.AddInt(item.Amount);
            }
            reply.AddBreak();

            // Spells
            reply.AddBreak();

            IEnumerable<Character> characters = client.Character.GetInRange<Character>();
            IEnumerable<NPC> npcs = client.Character.GetInRange<NPC>();
            IEnumerable<MapItem> items = client.Character.GetInRange<MapItem>();

            reply.AddChar((byte)characters.Count());
            reply.AddBreak();

            // Characters
            // {
            foreach (Character character in characters)
            {
                character.InfoBuilder(ref reply);
                reply.AddBreak();
            }
            // }

            // NPCs
            foreach (NPC npc in npcs)
            {
                npc.InfoBuilder(ref reply);
            }
            reply.AddBreak();

            // Items
            foreach (MapItem item in items)
            {
                item.InfoBuilder(ref reply);
            }

            client.Send(reply);
        }

        public void Setup()
        {
            this.databaseName = "data";

            this.clientMock = new Mock<IClient>();
            this.client = this.clientMock.Object;
        }

        public AuthService(IClient client)
        {
            if (client == null)
                throw new ArgumentNullException(nameof(client));

            _client = client;
        }

        public bool Add(IClient client)
        {
            if (client == null)
                throw new ArgumentNullException("client");

            if (ClientCount >= MaxClients)
            {
                Log.Default.WriteLine(LogLevels.Warning, "Too many clients");
                return false;
            }

            if (_clients.ContainsKey(client.Callback))
            {
                Log.Default.WriteLine(LogLevels.Warning, "{0} already connected", client.Name);
                return false;
            }

            if (_clients.Any(x => x.Value.Name == client.Name))
            {
                Log.Default.WriteLine(LogLevels.Warning, "{0} already connected", client.Name);
                return false;
            }

            //
            _clients.Add(client.Callback, client);

            //
            return true;
        }

 private static bool IsOnline(IClient client)
 {
     foreach (IClient c in onlineUsers)
         if (c.ID == client.ID)
             return true;
     return false;
 }

 public Refunds(ILog logger, IClient client, 
                 string createAddress = Createrefundsaddress, 
                 string validateAddress = Validaterefundsaddress)
     : base(logger, client, createAddress)
 {
     _validateRefundAddress = validateAddress;
 }

 public CompleteCommand(TaskArgsConverter converter, TextWriter textWriter, IClient client)
 {
     this.converter = converter;
     this.textWriter = textWriter;
     this.client = client;
     Description = "Mark task by ID as completed.";
 }