96 }

97

98 bool WidgetDelegate::ExecuteWindowsCommand(int command_id) {

99 return false;

100 }

73 } // namespace

74

75 bool NativeWindowViews::ExecuteWindowsCommand(int command_id) {

76 std::string command = AppCommandToString(command_id);

77 NotifyWindowExecuteWindowsCommand(command);

55 try {

56 // Launch the process

57 return 0 == launcher.launch().cmds(FilePathUtil.isUnix(pwd) ? args : args.toWindowsCommand())

58 .envs(environment).stdout(listener).pwd(pwd).join();

59 } catch (IOException e) {

84 // Execute a command in the window's controller. Returns true if the command

85 // was handled, false if it was not.

86 virtual bool ExecuteWindowsCommand(int command_id) { return false; }

87

88 // Returns the window's name identifier. Used to identify this window for

87 }

88

89 static public String escapeWindowsCommand(String command) {

90 String res = command.replaceAll("\"", "\\\"");

91 return res;

37 List<String> remainingArgs = new JavaCompilerArgumentsBuilder(spec).includeSourceFiles(true).build();

38 Iterable<String> allArgs = Iterables.concat(launcherOptions, remainingArgs);

39 if (exceedsWindowsCommandLineLengthLimit(allArgs)) {

40 return Iterables.concat(launcherOptions, shortenArgs(spec.getTempDir(), remainingArgs));

41 }

43 }

44

45 private boolean exceedsWindowsCommandLineLengthLimit(Iterable<String> args) {

46 int length = 0;

47 for (String arg : args) {

149 #if defined(_WIN32)

150

151 class WindowsCommandLine {

152 char** _argv;

153

154 public:

155 WindowsCommandLine( int argc, wchar_t* argvW[] );

156 ~WindowsCommandLine();

86 * dictates that Windows should install mongo as a service.

87 *

88 * The result is suitable for passing to mongo::constructUtf8WindowsCommandLine() to construct

89 * a properly quoted command line string.

90 */

95 // Execute a command in the window's controller. Returns true if the command

96 // was handled, false if it was not.

97 virtual bool ExecuteWindowsCommand(int command_id);

98

99 // Returns the window's name identifier. Used to identify this window for

8 import * as component from '../../../common/component';

9 import { cleanupUnitTest, prepareUnitTest } from '../../../common/utils';

10 import { WindowsCommands } from '../extends/windowsCommands';

11

12

13 describe('Unit Test for Windows Commands', () => {

14

15 let windowsCommands: WindowsCommands

16

17 before(() => {

26

27 beforeEach(() => {

28 windowsCommands = component.get(WindowsCommands);

29 });

30

41 rtc::ThreadManager::Instance()->SetCurrentThread(&w32_thread);

42

43 rtc::WindowsCommandLineArguments win_args;

44 int argc = win_args.argc();

45 char **argv = win_args.argv();

52 }

53

54 TEST(WindowsCommandLineConstruction, EmptyCommandLine) {

55 ASSERT_EQUALS("", constructUtf8WindowsCommandLine(svec(NULL)));

56 }

57

58 TEST(WindowsCommandLineConstruction, NothingToQuote) {

59 ASSERT_EQUALS("abc d \"\" e", constructUtf8WindowsCommandLine(svec("abc", "d", "", "e", NULL)));

60 }

61

62 TEST(WindowsCommandLineConstruction, ThingsToQuote) {

63 ASSERT_EQUALS("a\\\\\\b \"de fg\" h",

64 constructUtf8WindowsCommandLine(svec("a\\\\\\b", "de fg", "h", NULL)));

65 ASSERT_EQUALS("\"a\\\\b c\" d e",

66 constructUtf8WindowsCommandLine(svec("a\\\\b c", "d", "e", NULL)));

67 ASSERT_EQUALS("\"a \\\\\" \\", constructUtf8WindowsCommandLine(svec("a \\", "\\", NULL)));

41 cmd = stk.nextToken();

42

43 CLICommands.WindowsCommands wcmd = CLICommands.WindowsCommands

44 .value(cmd);

45

61

62 if(!launcher.isUnix()) {

63 args = args.toWindowsCommand();

64 }

65

127

128 if(!launcher.isUnix()) {

129 args = args.toWindowsCommand();

130 }

131

79 else // if(mode == ModeWindows)

80 {

81 cmSystemTools::ParseWindowsCommandLine(command.c_str(), vec);

82 }

83

12 public class ArgumentFlagsTests

13 {

14 [ArgumentSet(Style = ArgumentSetStyle.WindowsCommandLine)]

15 public class RequiredArguments<T>

16 {

19 }

20

21 [ArgumentSet(Style = ArgumentSetStyle.WindowsCommandLine)]

22 public class AtMostOnceArguments<T>

23 {

26 }

27

28 [ArgumentSet(Style = ArgumentSetStyle.WindowsCommandLine)]

29 public class AtLeastOnceArguments<T>

30 {

91 ArgumentListBuilder args = new ArgumentListBuilder(executable, script.getRemote());

92 // Check if on UNIX to return the right command

93 return isUnix ? args : args.toWindowsCommand();

94 }

95 }

39 }

40

41 TEST(WindowsCommandLineConstruction, EmptyCommandLine) {

42 ASSERT_EQUALS("", constructUtf8WindowsCommandLine(svec(NULL)));

43 }

44

45 TEST(WindowsCommandLineConstruction, NothingToQuote) {

46 ASSERT_EQUALS("abc d \"\" e",

47 constructUtf8WindowsCommandLine(svec("abc", "d", "", "e", NULL)));

48 }

49

50 TEST(WindowsCommandLineConstruction, ThingsToQuote) {

51 ASSERT_EQUALS("a\\\\\\b \"de fg\" h",

52 constructUtf8WindowsCommandLine(svec("a\\\\\\b", "de fg", "h", NULL)));

53 ASSERT_EQUALS("\"a\\\\b c\" d e",

54 constructUtf8WindowsCommandLine(svec("a\\\\b c", "d" , "e", NULL)));

55 ASSERT_EQUALS("\"a \\\\\" \\",

56 constructUtf8WindowsCommandLine(svec("a \\", "\\", NULL)));

13 NuGet.NuGetPushParams.Create()

14 |> NuGet.toPushCliArgs

15 |> Args.toWindowsCommandLine

16

17 Expect.isEmpty cli "Empty push args."

33 param

34 |> NuGet.toPushCliArgs

35 |> Args.toWindowsCommandLine

36

37 let expected = "-ApiKey abc123 -DisableBuffering -NoSymbols -NoServiceEndpoint -Source MyNuGetSource -SymbolApiKey MySymbolApiKey -SymbolSource MySymbolSource -Timeout 360"

243 // Create the right command depending of the OS and the conversion flag

244 return (isUnix ? new UnixCommand(command, ignoreExitCode, convert)

245 : new WindowsCommand(command, ignoreExitCode, convert));

246 }

247 }

98 // service command line.

99 ASSERT_EQUALS(expectedServiceCommandLine,

100 constructUtf8WindowsCommandLine(ntservice::constructServiceArgv(inputArgvUtf8)));

101 }

102

93 # endif

94

95 class WindowsCommandLine {

96 MONGO_DISALLOW_COPYING(WindowsCommandLine);

99

100 public:

101 WindowsCommandLine(int argc, wchar_t* argvW[], wchar_t* envpW[]);

102 ~WindowsCommandLine();

114 * http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx

115 */

116 std::string constructUtf8WindowsCommandLine(const std::vector<std::string>& argv);

117

118 } // namespace mongo

25 }

26

27 function getWindowsCommand(command) {

28 var fullCommand;

29 var extension;

63 // Windows workaround for .bat and .cmd files, see #626

64 if (isWin) {

65 command = getWindowsCommand(command);

66 }

67

106 #endif

107

108 WindowsCommandLine::WindowsCommandLine( int argc, wchar_t* argvW[] ) {

109 vector < string > utf8args;

110 vector < size_t > utf8argLength;

125 }

126

127 WindowsCommandLine::~WindowsCommandLine() {

128 free( _argv );

129 }

71 }

72

73 func TestParseWindowsCommand(t *testing.T) {

74 tests := []struct {

75 input string

152 errorSuffix := fmt.Sprintf(" Command to parse: [%s]", test.input)

153

154 actual := parseWindowsCommand(test.input)

155 if len(actual) != len(test.expected) {

156 t.Errorf(errorPrefix+"Expected %d parts, got %d: %#v."+errorSuffix, len(test.expected), len(actual), actual)

27 import hudson.util.ArgumentListBuilder;

28

29 public class WindowsCommand extends ShellCommand {

30

31 /**

44 * Convert shell to batch

45 */

46 protected WindowsCommand(String command, boolean ignoreExitCode, boolean convert) {

47 super(command, ignoreExitCode, convert);

48 }

59 bool CanMaximize() const override;

60 bool CanMinimize() const override;

61 bool ExecuteWindowsCommand(int command_id) override;

62 base::string16 GetWindowTitle() const override;

63 gfx::ImageSkia GetWindowIcon() override;

68 * dictates that Windows should install mongo as a service.

69 *

70 * The result is suitable for passing to mongo::constructUtf8WindowsCommandLine() to construct

71 * a properly quoted command line string.

72 */

66 // - mangles the output of `cmd.exe /c echo ...`

67 //

68 // If either of these becomes an issue, please refer to [util] CommandLineUtil.addToWindowsCommandLine() for a possible implementation.

69 public Process createProcess() throws IOException {

70 if (myParameters.size() < 1) {

44

45

46 protected String executeWindowsCommand(final String[] command){

47

48 try {

91 var err error

92 if runtime.GOOS == "windows" {

93 command, arguments, err = parseWindowsCommand(expandedCommand, args)

94 } else {

95 command, arguments, err = parseCommand(expandedCommand, args)

191 }

192

193 func parseWindowsCommand(command string, extraArgs []string) (string, []string, error) {

194 executable, arguments, err := parseCommand(command, extraArgs)

195 if err != nil {

75

76 String cbCommand = ((CommandBuilderProActive) commandBuilder).buildCommand(hostInfo, gcma, false);

77 //cbCommand = Helpers.escapeWindowsCommand(cbCommand);

78 cbCommand += " -c 1 ";

79

98 default:

99 if (this.platform.isWindows) {

100 return this.getWindowsCommands(condaEnv);

101 } else {

102 return this.getUnixCommands(condaEnv, await this.condaService.getCondaFile());

120 }

121

122 public async getWindowsCommands(condaEnv: string): Promise<string[] | undefined> {

123 const activate = await this.getWindowsActivateCommand();

124 return [`${activate} ${condaEnv.toCommandArgument()}`];

60 // views::DialogDelegateView:

61 views::View* GetInitiallyFocusedView() override;

62 bool ExecuteWindowsCommand(int command_id) override;

63 ui::ImageModel GetWindowIcon() override;

64 std::string GetWindowName() const override;

29 #pylint: disable-msg=C0111

30

31 class AbstractWindowsCommand(commands.Command):

32 @staticmethod

33 def is_valid_profile(profile):

360 }

361

362 export class GetCurrentWindowsCommand extends CommandBase {

363 constructor (obj, testRun) {

364 super(obj, testRun, TYPE.getCurrentWindows);

14 def createCommand(): Command = {

15 val command: Command = OperatingSystem.locate match {

16 case Windows => createWindowsCommand()

17 case Unix => createUnixCommand()

18 }

21 }

22

23 protected def createWindowsCommand(): Command

24

25 protected def createUnixCommand(): Command

107

108 @Test

109 public void testToWindowsCommand() {

110 ArgumentListBuilder builder = new ArgumentListBuilder(

111 "ant.bat", "-Dfoo1=abc", // nothing special, no quotes

121 + " \"-Dfoo8=% %\"Q\"ED% %\"c\"omspec% %-%(%.%\""

122 + " -Dfoo9=%'''%%@% && exit %%ERRORLEVEL%%\"" },

123 builder.toWindowsCommand().toCommandArray());

124 }

125 }

19 DotNet.NuGetPushOptions.Create().PushParams

20 |> DotNet.buildNugetPushArgs

21 |> Args.toWindowsCommandLine

22

23 Expect.isEmpty cli "Empty push args."

39 param

40 |> DotNet.buildNugetPushArgs

41 |> Args.toWindowsCommandLine

42

43 let expected = "--disable-buffering --api-key abc123 --no-symbols --no-service-endpoint --source MyNuGetSource --symbol-api-key MySymbolApiKey --symbol-source MySymbolSource --timeout 300"

52 param

53 |> DotNet.buildPublishArgs

54 |> Args.toWindowsCommandLine

55

56 let expected = "--configuration Release --self-contained=false"

44 // In Windows, wmain() is an alternate entry point for main(), and receives the same parameters

45 // as main() but encoded in Windows Unicode (UTF-16); "wide" 16-bit wchar_t characters. The

46 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent

47 // and makes them available through the argv() and envp() members. This enables dbtestsMain()

48 // to process UTF-8 encoded arguments and environment variables without regard to platform.

49 int wmain(int argc, wchar_t* argvW[], wchar_t* envpW[]) {

50 WindowsCommandLine wcl(argc, argvW, envpW);

51 int exitCode = dbtestsMain(argc, wcl.argv(), wcl.envp());

52 ::_exit(exitCode);

98 #endif

99

100 class WindowsCommandLine {

101 MONGO_DISALLOW_COPYING(WindowsCommandLine);

104

105 public:

106 WindowsCommandLine(int argc, wchar_t* argvW[], wchar_t* envpW[]);

107 ~WindowsCommandLine();

123 * http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx

124 */

125 std::string constructUtf8WindowsCommandLine(const std::vector<std::string>& argv);

126

127 } // namespace mongo

56

57 final String[] params = isWindows()

58 ? createWindowsCommand(ADM_STARTUP_COMMAND, startOpts)

59 : createUnixCommand(ADM_STARTUP_COMMAND, startOpts);

60

55 MenuRenderCommandType,

56 MenuViewCommandType,

57 MenuWindowsCommandType,

58 MenuHelpCommandType,

59 PlaybackCommandType,

15 import org.voisen.crayon.view.editor.EditorWindow;

16

17 public class CreateWindowsCommandTest

18 {

19 //--------------------------------------------------------------------------

23 //--------------------------------------------------------------------------

24

25 protected var command:CreateWindowsCommand;

26

27 //--------------------------------------------------------------------------

34 public function setUp():void

35 {

36 command = new CreateWindowsCommand();

37

38 Async.proceedOnEvent(this, prepare(MediatorMap), Event.COMPLETE);

64 llvm::cl::ExpandResponseFiles(saver,

65 #ifdef _WIN32

66 llvm::cl::TokenizeWindowsCommandLine

67 #else

68 llvm::cl::TokenizeGNUCommandLine

60 // views::DialogDelegateView:

61 views::View* GetInitiallyFocusedView() override;

62 bool ExecuteWindowsCommand(int command_id) override;

63 gfx::ImageSkia GetWindowIcon() override;

64 std::string GetWindowName() const override;

13 }

14

15 TEST(Escape, WindowsCommand) {

16 EscapeOptions opts;

17 opts.mode = ESCAPE_NINJA_COMMAND;

12

13

14 class Pypykatz(common.WindowsCommandPlugin):

15 """Extract and decrypt passwords from the LSA Security Service."""

16 """

23 import org.apache.reef.runtime.azbatch.util.command.CommandBuilder;

24 import org.apache.reef.runtime.azbatch.util.command.LinuxCommandBuilder;

25 import org.apache.reef.runtime.azbatch.util.command.WindowsCommandBuilder;

26 import org.apache.reef.tang.formats.ConfigurationModule;

27 import org.apache.reef.tang.formats.ConfigurationModuleBuilder;

52

53 if (isWindows) {

54 builder = builder.bindImplementation(CommandBuilder.class, WindowsCommandBuilder.class);

55 } else {

56 builder = builder.bindImplementation(CommandBuilder.class, LinuxCommandBuilder.class);

40 }

41

42 protected override def createWindowsCommand(): Command = {

43 new Command("\"" + new File(".").getAbsolutePath + "\\external\\faac.exe\"")

44 }

94 class WindowsCommandLine {

95 WindowsCommandLine(const WindowsCommandLine&) = delete;

96 WindowsCommandLine& operator=(const WindowsCommandLine&) = delete;

99

100 public:

101 WindowsCommandLine(int argc, wchar_t* argvW[], wchar_t* envpW[]);

102 ~WindowsCommandLine();

118 * http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx

119 */

120 std::string constructUtf8WindowsCommandLine(const std::vector<std::string>& argv);

121

122 } // namespace mongo

63

64 // Called on Windows when App Commands arrive (WM_APPCOMMAND)

65 virtual void OnExecuteWindowsCommand(const std::string& command_name) {}

66 };

67

24 import junit.framework.TestCase;

25

26 public class TestWindowsCommand extends TestCase {

27

28 public void testConvertCommand() throws Exception {

29 WindowsCommand command = new WindowsCommand("Hello ${Who} and $Who!\nls toto/tutu", true, true);

30 assertEquals("Hello %Who% and %Who%!\nls toto\\tutu\r\nexit %ERRORLEVEL%", command.getContents());

31 }

33 public void testDoNotConvertCommand() throws Exception {

34 String contents = "Hello ${Who} and $Who2!\nls toto/tutu";

35 WindowsCommand command = new WindowsCommand(contents, true, false);

36 assertEquals(contents + "\r\nexit %ERRORLEVEL%", command.getContents());

37 }

69 }

70

71 static public void WindowsCommandShell(string log)

72 {

73 string currentPath = AppDomain.CurrentDomain.BaseDirectory;

40 let target = sshParams |> getTarget

41 let privateKey = sshParams.PrivateKeyPath |> getPrivateKey

42 $"%s{privateKey} %s{target} %s{Args.toWindowsCommandLine [command]}" |> String.trim

43

44 /// Performs a command via SSH.

8 /// Provides shared helper functionality for working with Windows process command-lines.

9 /// </summary>

10 public static class CWindowsCommandLineHelper

11 {

12 /// <summary>

19 [OutputType(new[]{ typeof(object) })]

20 // disabled in the current release

21 internal class GetUIAWindowsCommand : GetWindowCmdletBase

22 {

23 #region Constructor

24 public GetUIAWindowsCommand()

25 {

26 ProcessName = String.Empty;

48 fs.mkdirSync(subfolder)

49

50 writeWindowsCommandFile(command)

51

52 const childProcess = new ChildProcess(command)

207 fs.mkdirSync(subfolder)

208

209 writeWindowsCommandFile(command)

210

211 const childProcess = new ChildProcess(command)

415 }

416

417 function writeWindowsCommandFile(filename: string): void {

418 fs.writeFileSync(filename, `@echo OFF${os.EOL}echo hi`)

419 }

45 List<String> remainingArgs = new JavaCompilerArgumentsBuilder(spec).includeSourceFiles(true).build();

46 Iterable<String> allArgs = Iterables.concat(launcherOptions, remainingArgs);

47 if (exceedsWindowsCommandLineLengthLimit(allArgs)) {

48 return Iterables.concat(launcherOptions, shortenArgs(remainingArgs));

49 }

51 }

52

53 private boolean exceedsWindowsCommandLineLengthLimit(Iterable<String> args) {

54 int length = 0;

55 for (String arg : args) {

61 int argc;

62 char **argv;

63 vtksys::SystemTools::ConvertWindowsCommandLineToUnixArguments( lpCmdLine, &argc, &argv );

64 int ret = slicer3_main ( argc, argv );

65 for (int i = 0; i < argc; i++) { delete [] argv[i]; }

10 /// Command handler

11 /// </summary>

12 internal sealed class OtherWindowsCommand

13 {

14 /// <summary>

28

29 /// <summary>

30 /// Initializes a new instance of the <see cref="OtherWindowsCommand"/> class.

31 /// Adds our command handlers for menu (commands must exist in the command table file)

32 /// </summary>

33 /// <param name="package">Owner package, not null.</param>

34 private OtherWindowsCommand(Package package)

35 {

36 if (package == null)

16

17 [ArgumentSet(

18 Style = ArgumentSetStyle.WindowsCommandLine,

19 AnswerFileArgumentPrefix = "@")]

20 class Arguments

28

29 [ArgumentSet(

30 Style = ArgumentSetStyle.WindowsCommandLine,

31 AnswerFileArgumentPrefix = "#!")]

32 class AlternateSyntaxArguments

27

28 path = path.replace("/", "\\"); // Convert to windows path separators

29 return executeWindowsCommand(new String[] {"C:\\Windows\\explorer.exe", path});

30

31 } else {

68

69 // Enqueue a command to unlock the draw buffer after all windows have been drawn

70 ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER( SlateBeginDrawingWindowsCommand,

71 FSlateUpdatableInstanceBuffer&, Self, *this,

72 int32, BufferIndex, FreeBufferIndex,

37 // In Windows, wmain() is an alternate entry point for main(), and receives the same parameters

38 // as main() but encoded in Windows Unicode (UTF-16); "wide" 16-bit wchar_t characters. The

39 // WindowsCommandLine object converts these wide character strings to a UTF-8 coded equivalent

40 // and makes them available through the argv() and envp() members. This enables mongoDbMain()

41 // to process UTF-8 encoded arguments and environment variables without regard to platform.

42 int wmain(int argc, wchar_t* argvW[]) {

43 mongo::quickExit(mongo::mongod_main(argc, mongo::WindowsCommandLine(argc, argvW).argv()));

44 }

45 #else

18

19

20 # Runs the command, assigns the status, and returns the WindowsCommand object.

21 sub run_command {

22 my %args = @_;

28 import volatility.win32.tasks as tasks

29

30 class HibInfo(common.AbstractWindowsCommand):

31 """Dump hibernation file information"""

32

30 private const string activityName = "activity";

31

32 private GetAzureDataFactoryActivityWindowsCommand cmdlet;

33

34 private List<PSActivityWindow> expectedDf;

83 public void CanListDataFactoryActivityWindows()

84 {

85 cmdlet = new GetAzureDataFactoryActivityWindowsCommand()

86 {

87 CommandRuntime = commandRuntimeMock.Object,

115 public void CanListPipelineActivityWindows()

116 {

117 cmdlet = new GetAzureDataFactoryActivityWindowsCommand()

118 {

119 CommandRuntime = commandRuntimeMock.Object,

27 import org.voisen.crayon.view.editor.EditorWindow;

28

29 public class CreateWindowsCommand extends SignalCommand

30 {

31 //--------------------------------------------------------------------------

44 //--------------------------------------------------------------------------

45

46 public function CreateWindowsCommand()

47 {

48 }

149 } from "../commands/DescribeMaintenanceWindowTasksCommand";

150 import {

151 DescribeMaintenanceWindowsCommandInput,

152 DescribeMaintenanceWindowsCommandOutput,

153 } from "../commands/DescribeMaintenanceWindowsCommand";

154 import {

155 DescribeMaintenanceWindowsForTargetCommandInput,

149 } from "./commands/DescribeMaintenanceWindowTasksCommand";

150 import {

151 DescribeMaintenanceWindowsCommandInput,

152 DescribeMaintenanceWindowsCommandOutput,

153 } from "./commands/DescribeMaintenanceWindowsCommand";

154 import {

155 DescribeMaintenanceWindowsForTargetCommandInput,

467 | DescribeMaintenanceWindowTargetsCommandInput

468 | DescribeMaintenanceWindowTasksCommandInput

469 | DescribeMaintenanceWindowsCommandInput

470 | DescribeMaintenanceWindowsForTargetCommandInput

471 | DescribeOpsItemsCommandInput

591 | DescribeMaintenanceWindowTargetsCommandOutput

592 | DescribeMaintenanceWindowTasksCommandOutput

593 | DescribeMaintenanceWindowsCommandOutput

594 | DescribeMaintenanceWindowsForTargetCommandOutput

595 | DescribeOpsItemsCommandOutput

236 } from "./commands/DescribeMaintenanceWindowTasksCommand";

237 import {

238 DescribeMaintenanceWindowsCommand,

239 DescribeMaintenanceWindowsCommandInput,

240 DescribeMaintenanceWindowsCommandOutput,

241 } from "./commands/DescribeMaintenanceWindowsCommand";

6 import { CreateLocationEfsCommandInput, CreateLocationEfsCommandOutput } from "../commands/CreateLocationEfsCommand";

7 import {

8 CreateLocationFsxWindowsCommandInput,

9 CreateLocationFsxWindowsCommandOutput,

10 } from "../commands/CreateLocationFsxWindowsCommand";

11 import { CreateLocationNfsCommandInput, CreateLocationNfsCommandOutput } from "../commands/CreateLocationNfsCommand";

12 import {

26 } from "../commands/DescribeLocationEfsCommand";

27 import {

28 DescribeLocationFsxWindowsCommandInput,

29 DescribeLocationFsxWindowsCommandOutput,

30 } from "../commands/DescribeLocationFsxWindowsCommand";

31 import {

32 DescribeLocationNfsCommandInput,

12 } from "./commands/CreateLocationEfsCommand";

13 import {

14 CreateLocationFsxWindowsCommand,

15 CreateLocationFsxWindowsCommandInput,

16 CreateLocationFsxWindowsCommandOutput,

17 } from "./commands/CreateLocationFsxWindowsCommand";

55 } from "./commands/DescribeLocationEfsCommand";

56 import {

57 DescribeLocationFsxWindowsCommand,

58 DescribeLocationFsxWindowsCommandInput,

59 DescribeLocationFsxWindowsCommandOutput,

60 } from "./commands/DescribeLocationFsxWindowsCommand";

246 */

247 public createLocationFsxWindows(

248 args: CreateLocationFsxWindowsCommandInput,

249 options?: __HttpHandlerOptions

250 ): Promise<CreateLocationFsxWindowsCommandOutput>;

74 let! (result : ProcessResults<unit>) =

75 (sprintf "plugin inspect %s " pluginInfo.ImageName)

76 |> Arguments.OfWindowsCommandLine

77 |> DockerWrapper.createProcess

78 |> wrapProcess

82 do!

83 (sprintf "plugin disable --force %s" pluginInfo.ImageName)

84 |> Arguments.OfWindowsCommandLine

85 |> DockerWrapper.createProcess

86 |> CreateProcess.ensureExitCode

91 (sprintf "plugin set %s %s"

92 pluginInfo.ImageName settingsCmdLine)

93 |> Arguments.OfWindowsCommandLine

94 |> DockerWrapper.createProcess

95 |> CreateProcess.ensureExitCode

28 *

29 */

30 public class WindowsCommandRetriever {

31 /**

32 *

37 */

38 @Private

39 public class WindowsCommandBuilder extends AbstractCommandBuilder {

40

41 private static final Class LAUNCHER_CLASS = REEFLauncher.class;

52

53 @Inject

54 WindowsCommandBuilder(

55 final ClasspathProvider classpathProvider,

56 final RuntimePathProvider runtimePathProvider,

102 }

103

104 // output: output, error: error, command: actualCommand, unixCommand: unixCommand, windowsCommand: windowsCommand

105 project.doAssert(projectDir, result)

106 }

77

78 // windows special hidden sub-command (only added on windows)

79 reexec := newReExecWindowsCommand(flags, args, streams)

80 if reexec != nil {

81 cmd.AddCommand(reexec)

28 import volatility.utils as utils

29

30 class Modules(common.AbstractWindowsCommand):

31 """Print list of loaded modules"""

32 def __init__(self, config, *args, **kwargs):

33 common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)

34 config.add_option("PHYSICAL-OFFSET", short_option = 'P', default = False,

35 cache_invalidator = False, help = "Physical Offset", action = "store_true")

66 return result

67

68 class UnloadedModules(common.AbstractWindowsCommand):

69 """Print list of unloaded modules"""

70

1 package org.voisen.crayon

2 {

3 import org.voisen.crayon.command.startup.CreateWindowsCommandTest;

4 import org.voisen.crayon.view.editor.EditorWindowTest;

5

14 //--------------------------------------------------------------------------

15

16 public var createWindowsCommandTest:CreateWindowsCommandTest;

17

18 //--------------------------------------------------------------------------

49

50 /**

51 * Perform this action. Uses the <TT>CloseAllSQLResultWindowsCommand</TT>.

52 *

53 * @param evt The current event.

66 // Can't work with ISessionAction because if a result window is on top

67 // the session in a ISessionAction is null.

68 new CloseAllSQLResultWindowsCommand(activeSession.getSQLPanelAPIOfActiveSessionWindow()).execute();

69 }

70 }

29 import volatility.protos as protos

30

31 class Sockets(common.AbstractWindowsCommand):

32 """Print list of open sockets"""

33 def __init__(self, config, *args, **kwargs):

34 common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)

35 config.add_option("PHYSICAL-OFFSET", short_option = 'P', default = False,

36 cache_invalidator = False,

28 import volatility.debug as debug

29

30 class BiosKbd(common.AbstractWindowsCommand):

31 """Reads the keyboard buffer from Real Mode memory"""

32 BASE = 0x400

29 * @author <A HREF="mailto:colbell@users.sourceforge.net">Colin Bell</A>

30 */

31 public class CloseAllSQLResultWindowsCommand implements ICommand

32 {

33 private final ISQLPanelAPI _api;

41 * Thrown if a <TT>null</TT> <TT>ISession</TT> passed.

42 */

43 public CloseAllSQLResultWindowsCommand(ISQLPanelAPI api)

44 {

45 super();

9 * has ourMirrorClass initialized by the Bootstrap class; it calls the main instance of itself via reflection.

10 */

11 public final class WindowsCommandLineProcessor {

12 // The MainRunner class which is loaded in the main IDEA (non-bootstrap) classloader.

13 public static Class<?> ourMainRunnerClass;

13 val fileList: File = createFileList()

14

15 protected def createWindowsCommand(): Command = {

16 new Command("\"" + new File(".").getAbsolutePath + "\\external\\ffmpeg.exe\"")

17 }

46

47 def __init__(self, config, *args, **kwargs):

48 common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)

49

50 # Filter specific processes

6 import java.io.File;

7

8 public class DoubleQuotedArgumentsOnWindowsCommandLine extends CommandLine {

9

10 public DoubleQuotedArgumentsOnWindowsCommandLine(String executable) {

12 }

13

14 public DoubleQuotedArgumentsOnWindowsCommandLine(File executable) {

15 super(executable);

16 }

17

18 public DoubleQuotedArgumentsOnWindowsCommandLine(CommandLine other) {

19 super(other);

20 }

47 addCommand(MapModelsCommand);

48 //TODO - check for updates

49 addCommand(CreateWindowsCommand);

50

51 super.execute();

80 const acutalMac = Injector.getOpenUrlWithDefaultBrowserCommand(mac, testUrl);

81

82 expect(actualWin).toBe(OpenUrlWithDefaultBrowserCommandBuilder.buildWindowsCommand(testUrl));

83 expect(acutalMac).toBe(OpenUrlWithDefaultBrowserCommandBuilder.buildMacCommand(testUrl));

84 });

17

18 if runtimeGoos == "windows" {

19 parts = parseWindowsCommand(command) // parse it Windows-style

20 } else {

21 parts, err = parseUnixCommand(command) // parse it Unix-style

45 }

46

47 // parseWindowsCommand parses windows command lines and

48 // returns the command and the arguments as an array. It

49 // should be able to parse commonly used command lines.

59 // of the shlex package because this function treats backslash

60 // characters properly.

61 func parseWindowsCommand(cmd string) []string {

62 const backslash = '\\'

63 const quote = '"'

18

19 /// A command to build a windows desktop target through a build shell script.

20 class BuildWindowsCommand extends BuildSubCommand {

21 BuildWindowsCommand({ bool verboseHelp = false }) {

47 export * from "./commands/DescribeMaintenanceWindowExecutionTaskInvocationsCommand";

48 export * from "./commands/DescribeMaintenanceWindowExecutionTasksCommand";

49 export * from "./commands/DescribeMaintenanceWindowsCommand";

50 export * from "./commands/DescribeMaintenanceWindowScheduleCommand";

51 export * from "./commands/DescribeMaintenanceWindowsForTargetCommand";

3 use strict;

4

5 use NOCpulse::Probe::DataSource::WindowsCommand;

6

7 sub run {

65 return obj.NoneObject("Cannot locate a session")

66

67 class Sessions(common.AbstractWindowsCommand, SessionsMixin):

68 """List details on _MM_SESSION_SPACE (user logon sessions)"""

69

20

21 if (isWindows()) {

22 return executeWindowsCommand(new String[] {"C:\\Program Files\\PuTTY\\putty.exe",

23 "-ssh", "-P", port, hostname, "-l", username});

24

19

20 if (isWindows()) {

21 return executeWindowsCommand(new String[] {"C:\\Program Files\\Common Files\\VMware\\VMware VMRC Plug-in\\Internet Explorer\\vmware-vmrc.exe",

22 "-h", hostname, vm});

23

37 import struct

38

39 class ShutdownTime(common.AbstractWindowsCommand):

40 "Print ShutdownTime of machine from registry"

41

42 def __init__(self, config, *args, **kwargs):

43 common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)

44 config.add_option('HIVE-OFFSET', short_option = 'o',

45 help = 'Hive offset (virtual)', type = 'int')

13

14 import {autoLinkCommand} from './runWindows/utils/autolink';

15 import {runWindowsCommand} from './runWindows/runWindows';

16 import {dependencyConfigWindows} from './config/dependencyConfig';

17 import {projectConfigWindows} from './config/projectConfig';

89 assertStableInterface;

90

91 export const commands = [autoLinkCommand, runWindowsCommand];

92 export const dependencyConfig = dependencyConfigWindows;

93 export const projectConfig = projectConfigWindows;

106 // Cash help.

107 let windowsHelpFlag = false;

108 const windowsCommandReject = 'is not recognized as an internal or external command';

109

110 /* istanbul ignore next */

116 proc.stderr.on('data', function (data) {

117 const str = data.toString('utf8');

118 if (windows && str.indexOf(windowsCommandReject) > -1) {

119 windowsHelpFlag = true;

120 return;