Esempio n. 1
0
        public static bool XeClientPackerChecked(
            string BaseDir,
            string OriginalArchiveName,
            string OutputArchiveName
            )
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeClientPackerChecked(
                           BaseDir,
                           OriginalArchiveName,
                           OutputArchiveName
                           ));

            case Architecture.X64:
                return(Client64.XeClientPackerChecked(
                           BaseDir,
                           OriginalArchiveName,
                           OutputArchiveName
                           ));

            case Architecture.Arm64:
                return(ClientAarch64.XeClientPackerChecked(
                           BaseDir,
                           OriginalArchiveName,
                           OutputArchiveName
                           ));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 2
0
        public static bool XeRunServer(
            UnmanagedPointers.NotifyServerProgressChangedServer NotifyServerProgressChangedStub,
            UnmanagedPointers.NotifyServerLogOutputServer NotifyServerLogOutputStub,
            UnmanagedPointers.NotifyServerUIReadyServer NotifyServerUIReadyStub,
            UnmanagedPointers.NotifyServerMessageBoxServer NotifyServerMessageBoxStub,
            UnmanagedPointers.NotifyServerTaskStartAndDisableUIServer NotifyServerTaskStartAndDisableUIStub,
            UnmanagedPointers.NotifyServerTaskEndAndEnableUIServer NotifyServerTaskEndAndEnableUIStub,
            UnmanagedPointers.NotifyServerExitFromRemoteProcessServer NotifyServerExitFromRemoteProcessStub,
            UnmanagedPointers.NotifyServerRaiseErrorServer NotifyServerRaiseErrorStub
            )
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeRunServer(
                           NotifyServerProgressChangedStub,
                           NotifyServerLogOutputStub,
                           NotifyServerUIReadyStub,
                           NotifyServerMessageBoxStub,
                           NotifyServerTaskStartAndDisableUIStub,
                           NotifyServerTaskEndAndEnableUIStub,
                           NotifyServerExitFromRemoteProcessStub,
                           NotifyServerRaiseErrorStub
                           ));

            case Architecture.X64:
                return(Client64.XeRunServer(
                           NotifyServerProgressChangedStub,
                           NotifyServerLogOutputStub,
                           NotifyServerUIReadyStub,
                           NotifyServerMessageBoxStub,
                           NotifyServerTaskStartAndDisableUIStub,
                           NotifyServerTaskEndAndEnableUIStub,
                           NotifyServerExitFromRemoteProcessStub,
                           NotifyServerRaiseErrorStub
                           ));

            case Architecture.Arm64:
                return(ClientAarch64.XeRunServer(
                           NotifyServerProgressChangedStub,
                           NotifyServerLogOutputStub,
                           NotifyServerUIReadyStub,
                           NotifyServerMessageBoxStub,
                           NotifyServerTaskStartAndDisableUIStub,
                           NotifyServerTaskEndAndEnableUIStub,
                           NotifyServerExitFromRemoteProcessStub,
                           NotifyServerRaiseErrorStub
                           ));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 3
0
        public static bool XeClientTaskDumpStart(
            KrkrPsbMode PsbMode,
            KrkrTextMode TextMode,
            KrkrPngMode PngMode,
            KrkrTjs2Mode Tjs2Mode,
            KrkrTlgMode TlgMode,
            KrkrAmvMode AmvMode,
            KrkrPbdMode PdbMode,
            string File
            )
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeClientTaskDumpStart(
                           PsbMode,
                           TextMode,
                           PngMode,
                           Tjs2Mode,
                           TlgMode,
                           AmvMode,
                           PdbMode,
                           File
                           ));

            case Architecture.X64:
                return(Client64.XeClientTaskDumpStart(
                           PsbMode,
                           TextMode,
                           PngMode,
                           Tjs2Mode,
                           TlgMode,
                           AmvMode,
                           PdbMode,
                           File
                           ));

            case Architecture.Arm64:
                return(ClientAarch64.XeClientTaskDumpStart(
                           PsbMode,
                           TextMode,
                           PngMode,
                           Tjs2Mode,
                           TlgMode,
                           AmvMode,
                           PdbMode,
                           File
                           ));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 4
0
        public static IntPtr XeGetRemoteProcessHandle()
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeGetRemoteProcessHandle());

            case Architecture.X64:
                return(Client64.XeGetRemoteProcessHandle());

            case Architecture.Arm64:
                return(ClientAarch64.XeGetRemoteProcessHandle());

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 5
0
        public static bool XeClientTaskCloseWindow()
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeClientTaskCloseWindow());

            case Architecture.X64:
                return(Client64.XeClientTaskCloseWindow());

            case Architecture.Arm64:
                return(ClientAarch64.XeClientTaskCloseWindow());

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 6
0
        public static bool XeClientCommandEmitted(string Command)
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeClientCommandEmitted(Command));

            case Architecture.X64:
                return(Client64.XeClientCommandEmitted(Command));

            case Architecture.Arm64:
                return(ClientAarch64.XeClientCommandEmitted(Command));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 7
0
        public static bool XeClientUniversalPatchMakeChecked(bool Protect, bool Icon)
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeClientUniversalPatchMakeChecked(Protect, Icon));

            case Architecture.X64:
                return(Client64.XeClientUniversalPatchMakeChecked(Protect, Icon));

            case Architecture.Arm64:
                return(ClientAarch64.XeClientUniversalPatchMakeChecked(Protect, Icon));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }
Esempio n. 8
0
        public static bool XeCreateInstance(
            bool IsOfficialServer,
            uint Secret,
            uint HeartbeatTimeoutThreshold,
            uint HandshakeTimeoutThreshold
            )
        {
            switch (RuntimeInformation.ProcessArchitecture)
            {
            case Architecture.X86:
                return(Client32.XeCreateInstance(
                           IsOfficialServer,
                           Secret,
                           HeartbeatTimeoutThreshold,
                           HandshakeTimeoutThreshold
                           ));

            case Architecture.X64:
                return(Client64.XeCreateInstance(
                           IsOfficialServer,
                           Secret,
                           HeartbeatTimeoutThreshold,
                           HandshakeTimeoutThreshold
                           ));

            case Architecture.Arm64:
                return(ClientAarch64.XeCreateInstance(
                           IsOfficialServer,
                           Secret,
                           HeartbeatTimeoutThreshold,
                           HandshakeTimeoutThreshold
                           ));

            case Architecture.Arm:
                throw new NotImplementedException("Unsupported arch : Arm");
            }

            throw new NotImplementedException("Unsupported arch : Unknown");
        }