[Closed] Problem with "custom" hiddenDosCommand

i don’t see any problem in the code. i think that the dos command itself doesn’t execute right on those machines for any reason. ask the person who reported the problem to executed the command directly using the command prompt window, and give you a result.

I ran into problems handling error output that was returned by the Perforce command line processor. I ran into the kinds of deadlock issue discussed here reading stderr

I eventually gave up on a pure MXS solution and started using asynchronous reads through a delegate in a C# snippet:

fn CreateDotNetProcessor = 
(
	if dotnet.GetType "DotNetProcessor" == undefined do
	(
		format "Constructing .NET Processor...
"
		-- If layout of this text looks ragged, press ctrl-F11 to switch to a monospaced font...
		sb = ""
		sb +="    using System;																			
"
		sb +="    using System.Text;																	
"
		sb +="    using System.Diagnostics;																
"
		sb +="																							
"
		sb +="    class DotNetProcessor																	
"
		sb +="    {																						
" 
		sb +="																							
"
		sb +="		private static StringBuilder stdOut = null;											
"
		sb +="		private static StringBuilder stdErr = null;											
"
		sb +="																							
"
		sb +="		public String Output() { return stdOut == null ? \"\" : stdOut.ToString(); }		
"
		sb +="		public String Errors() { return stdErr == null ? \"\" : stdErr.ToString(); }		
"
		sb +="																							
"
		sb +="		public void Execute(String filename, String args, String stdinbuff)					
"
		sb +="		{																					
"
		sb +="			Process p = new System.Diagnostics.Process();									
"
		sb +="																							
"
		sb +="			stdErr = new StringBuilder();													
"
		sb +="			stdOut = new StringBuilder();													
"
		sb +="			                               													
"
		sb +="			p.EnableRaisingEvents = true;													
"
		sb +="			p.StartInfo.FileName = filename;												
"
		sb +="			p.StartInfo.Arguments = args;													
"
		sb +="			p.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden	;		
"
		sb +="			p.StartInfo.UseShellExecute = false;											
"
		sb +="			p.StartInfo.RedirectStandardOutput = true;										
"
		sb +="			p.StartInfo.RedirectStandardError = true;										
"
		sb +="			p.StartInfo.RedirectStandardInput = stdinbuff.Length > 0;						
"
		sb +="																							
"
		sb +="			p.StartInfo.CreateNoWindow = true;												
"
		sb +="																							
"
		sb +="			p.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);			
"
		sb +="			p.ErrorDataReceived += new DataReceivedEventHandler(ErrorHandler);				
"
		sb +="																							
"
		sb +="			p.Start();																		
"
		sb +="																							
"
		sb +="			if (stdinbuff.Length > 0)														
" 
		sb +="			{																				
"
		sb +="				p.StandardInput.Write(stdinbuff);											
"
		sb +="				p.StandardInput.Close();													
"
		sb +="			}																				
"
		sb +="																							
"
		sb +="			stdErr = new StringBuilder();													
"
		sb +="			stdOut = new StringBuilder();													
"
		sb +="																							
"
		sb +="			p.BeginOutputReadLine();														
"
		sb +="			p.BeginErrorReadLine();															
"
		sb +="																							
"
		sb +="			p.WaitForExit();																
"
		sb +="			p.Close();																		
"	
		sb +="		}																					
"
		sb +="																							
"
		sb +="		private static void OutputHandler(object sendingProcess, DataReceivedEventArgs d)	
"
		sb +="		{																					
"
		sb +="			if (!String.IsNullOrEmpty(d.Data)) stdOut.Append(d.Data + \"\
\");				
"
		sb +="		}																					
"
		sb +="																							
"
		sb +="		private static void ErrorHandler(object sendingProcess, DataReceivedEventArgs d)	
"
		sb +="		{																					
"
		sb +="			if (!String.IsNullOrEmpty(d.Data)) stdErr.Append(d.Data + \"\
\");				
"
		sb +="		}																					
"
		sb +="   }																						
"

		csharpProvider = dotnetobject "Microsoft.CSharp.CSharpCodeProvider"
		compilerParams = dotnetobject "System.CodeDom.Compiler.CompilerParameters"
		
		compilerParams.ReferencedAssemblies.Add("System.dll");
		
		compilerParams.GenerateInMemory = true
		compilerResults = csharpProvider.CompileAssemblyFromSource compilerParams #(sb)
		
		if (compilerResults.Errors.Count > 0 ) then
		(
			errs = stringstream ""
			for i = 0 to (compilerResults.Errors.Count-1) do
			(
				err = compilerResults.Errors.Item[i]
				format "Error:% Line:% Column:% %
" err.ErrorNumber err.Line \                                              
													 err.Column err.ErrorText to:errs 
			)
			MessageBox (errs as string) title: "Errors encountered while compiling C# code"
			format "%
" errs
			return undefined
		)
	)
	dotnetobject "DotNetProcessor"	
)

-- Tests
(
	dnp = CreateDotNetProcessor()
	
	-- Run a dir command
	dnp.execute "cmd.exe" "/K dir c:\\" ""
	format "output:
%" (dnp.output())
	format "errors:
%" (dnp.errors())
		
	-- Read from stdin
	dnp.execute "cmd.exe" "" "echo foo
echo fee
"
	format "output:
%" (dnp.output())
	format "errors:
%" (dnp.errors())
		
	-- Launch an app and wait for it to complete
	dnp.execute "calc.exe" "" ""
	format "output:
%" (dnp.output())
	format "errors:
%" (dnp.errors())	
		
	-- Do some ftp fiddling (using stdin)
	dnp.execute "ftp" "" "status
! echo \"Escape to the shell!
!dir c:\\\"
status
quit"
	format "output:
%" (dnp.output())
	format "errors:
%" (dnp.errors())	

	-- Query Perforce (if you have it)
	dnp.execute "p4" "info" ""
	format "output:
%" (dnp.output())
	format "errors:
%" (dnp.errors())	
)

It’s not pretty, but it stopped hanging…
.biddle

[edit: missing a semi-colon]

Mike Biddlecombe
                   Animation Programmer
                   United Front Games
           		         Vancouver,  		 		         Canada

I didn’t know you were in Vancouver these days Mike!

I think all you need to do is swap the ‘args’ that are passed to the executable and the ‘stdin’ input that will be sent to the program once it’s up and running (which is usually not required and can be left empty)

exe = "C:\md5.exe"
args = "-o\"C:\\md5hash.tmp\" \"C:\\TheFile.exe\""
input = ""

dp.execute exe args input

See if this works. Cheers!

fn HiddenDotNetCommand Command=
(
	Process = DotNetObject "System.Diagnostics.Process"
	Process.StartInfo.WindowStyle   =  (DotNetClass  "System.Diagnostics.ProcessWindowStyle").Hidden
	Process.StartInfo.FileName = "cmd.exe"
	Process.StartInfo.Arguments = "/C " + Command
	Process.Start()
)

How about if you remove the StartInfo ? Just run the Process.Start (“cmd.exe /C ” + Command) ?

Can’t you start the md5.exe process directly using Process.Start?
Or if you’re specifically after MD5, try this: http://msdn.microsoft.com/en-us/library/system.security.cryptography.md5.aspx

I need it for more than MD5 hash, but as a matter of fact, I tried this code by Kameleon and it seemed to work, except with 3dsMax 9, that’s why I switched to command line tool. (I can’t really remember what the error message was)

My guess is that you have something wrong when constructing the string, I saw that you have the file between “” and the arguments out which is correct but maybe debugging that whole string again might help to find a working solution.

About the md5 function in max 9 not working maybe it’s some conversion types that work differently in Max 9, I remember having those kind of problems.