/////////////////////////////////////////////////////////////////////// private ReturnCode MaybeUnloadModule( IModule module, ref Result error ) { lock (syncRoot) /* TRANSACTIONAL */ { if (this.module == null) { return(ReturnCode.Ok); } if (Object.ReferenceEquals(module, this.module)) { return(ReturnCode.Ok); } if (moduleLoaded > 0) { if (RuntimeOps.UnloadNativeModule( this.module, ref moduleLoaded, ref error) != ReturnCode.Ok) { return(ReturnCode.Error); } } this.module = null; } return(ReturnCode.Ok); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if ((arguments.Count == 1) || (arguments.Count == 2)) { if (arguments.Count == 2) { string channelId = arguments[1]; Channel channel = interpreter.GetChannel(channelId, ref result); if (channel != null) { // // STUB: This does not actually work. // result = String.Empty; code = ReturnCode.Ok; } else { code = ReturnCode.Error; } } else { result = RuntimeOps.GetCurrentProcessId(); code = ReturnCode.Ok; } } else { result = "wrong # args: should be \"pid ?channelId?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////// #region Private Methods // // NOTE: This method assumes the lock is held. // private ReturnCode UnloadModule( ref int loaded, ref Result error ) { return(RuntimeOps.UnloadNativeModule( module, ref loaded, ref error)); }
/////////////////////////////////////////////////////////////////////// #region Callback Methods private ReturnCode InterruptCallback( Interpreter interpreter, /* NOTE: Parent interpreter. */ InterruptType interruptType, IClientData clientData, ref Result error ) /* throw */ { // // NOTE: If the are no callback arguments configured, just skip it // and return success. // StringList arguments = CallbackArguments; if (arguments == null) /* NOTE: Disabled? */ { return(ReturnCode.Ok); } Interpreter debugInterpreter = this.interpreter; if (debugInterpreter == null) { error = "debugger interpreter not available"; return(ReturnCode.Error); } // // NOTE: *WARNING* This is a cross-interpreter call, do NOT dispose // the parent interpreter because we do not own it. This is // guaranteed by using the NoDispose object flag (indirectly) // here. // ICallback callback = CommandCallback.Create( MarshalFlags.Default, CallbackFlags.Default, ObjectFlags.Callback, ByRefArgumentFlags.None, debugInterpreter, clientData, null, new StringList( arguments), ref error); if (callback == null) { return(ReturnCode.Error); } try { callback.FireEventHandler(this, RuntimeOps.GetInterruptEventArgs(interpreter, interruptType, clientData) as EventArgs); return(ReturnCode.Ok); } catch (Exception e) { error = e; } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { return(RuntimeOps.GetVersion(ref result)); }
/////////////////////////////////////////////////////////////////////// /* System.Threading.ThreadStart */ public void ThreadStart() { CheckDisposed(); try { #if NATIVE && WINDOWS RuntimeOps.RefreshNativeStackPointers(); #endif if (threadStart != null) { threadStart(); } else if (parameterizedThreadStart != null) { parameterizedThreadStart(null); } else { TraceOps.DebugTrace( "ThreadStart: no delegates available", typeof(EngineThread).Name, TracePriority.ThreadError); } } catch (ThreadAbortException e) { Thread.ResetAbort(); TraceOps.DebugTrace( e, typeof(EngineThread).Name, TracePriority.ThreadError); } catch (ThreadInterruptedException e) { TraceOps.DebugTrace( e, typeof(EngineThread).Name, TracePriority.ThreadError); } catch (Exception e) { TraceOps.DebugTrace( e, typeof(EngineThread).Name, TracePriority.ThreadError); } finally { if (interpreter != null) { interpreter.MaybeDisposeThread(); } } }
/////////////////////////////////////////////////////////////////////// private static void UnsetNativeDelegates() { lock (syncRoot) /* TRANSACTIONAL */ { nativeGetVersion = null; nativeAllocateMemory = null; nativeFreeMemory = null; nativeFreeElements = null; nativeSplitList = null; nativeJoinList = null; RuntimeOps.UnsetNativeDelegates(nativeDelegates, null); } }
/////////////////////////////////////////////////////////////////////// public static ReturnCode SelectRandomValue( Interpreter interpreter, /* in: may be NULL. */ Array array, /* in */ ref object value, /* out */ ref Result error /* out */ ) { if (array == null) { error = "invalid array"; return(ReturnCode.Error); } if (array.Rank != 1) { error = "array must be one-dimensional"; return(ReturnCode.Error); } if (array.Length == 0) { error = "array cannot be empty"; return(ReturnCode.Error); } try { ulong randomNumber; if (interpreter != null) { randomNumber = interpreter.GetRandomNumber(); /* throw */ } else { randomNumber = RuntimeOps.GetRandomNumber(); /* throw */ } int index = ConversionOps.ToInt(randomNumber % ConversionOps.ToULong(array.LongLength)); value = array.GetValue(index); /* throw */ return(ReturnCode.Ok); } catch (Exception e) { error = e; } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// public bool MaybeAddOrReplace( FindFlags flags, /* in */ string key, /* in */ TclBuild value, /* in */ ref Result error /* out */ ) { if (key == null) { error = String.Format( "can't add Tcl build file {0}: invalid key", FormatOps.TclBuildFileName(value)); return(false); } if (FlagOps.HasFlags(flags, FindFlags.TrustedOnly, true) && ((value == null) || !RuntimeOps.IsFileTrusted(value.FileName, IntPtr.Zero))) { error = String.Format( "can't add Tcl build file {0}: not trusted", FormatOps.TclBuildFileName(value)); return(false); } if (!this.ContainsKey(key)) { this.Add(key, value); return(true); } if (FlagOps.HasFlags( flags, FindFlags.OverwriteBuilds, true)) { this[key] = value; return(true); } error = String.Format( "can't add Tcl build file {0}: already present", FormatOps.TclBuildFileName(value)); return(false); }
/////////////////////////////////////////////////////////////////////// private static bool SetNativeDelegates( ref Result error ) { lock (syncRoot) /* TRANSACTIONAL */ { if ((RuntimeOps.SetNativeDelegates( "utility API", nativeModule, nativeDelegates, null, ref error) == ReturnCode.Ok) && (nativeDelegates != null)) { try { nativeGetVersion = (Eagle_GetVersion) nativeDelegates[typeof(Eagle_GetVersion)]; nativeAllocateMemory = (Eagle_AllocateMemory) nativeDelegates[typeof(Eagle_AllocateMemory)]; nativeFreeMemory = (Eagle_FreeMemory) nativeDelegates[typeof(Eagle_FreeMemory)]; nativeFreeElements = (Eagle_FreeElements) nativeDelegates[typeof(Eagle_FreeElements)]; nativeSplitList = (Eagle_SplitList) nativeDelegates[typeof(Eagle_SplitList)]; nativeJoinList = (Eagle_JoinList) nativeDelegates[typeof(Eagle_JoinList)]; return(true); } catch (Exception e) { error = e; } } } return(false); }
/////////////////////////////////////////////////////////////////////// public void ExitLock( ref bool locked ) { if (RuntimeOps.ShouldCheckDisposedOnExitLock(locked)) /* EXEMPT */ { CheckDisposed(); } if (syncRoot == null) { return; } if (locked) { Monitor.Exit(syncRoot); locked = false; } }
/////////////////////////////////////////////////////////////////////// public static IntPtr GetOutputHandle( ref Result error ) { bool isMono = CommonOps.Runtime.IsMono(); Type type = isMono ? MonoIoType : ConsoleType; if (type == null) { error = "invalid system console type"; return(IntPtr.Zero); } // // HACK: Because the System.Console object in the .NET Framework // provides no means to query the underlying input/output // handles, we must do it here by force. // try { IntPtr handle = (IntPtr)type.InvokeMember( isMono ? "ConsoleOutput" : "ConsoleOutputHandle", isMono ? MarshalOps.PublicStaticGetPropertyBindingFlags : MarshalOps.PrivateStaticGetPropertyBindingFlags, null, null, null); if (!RuntimeOps.IsValidHandle(handle)) { error = "invalid console output handle"; } return(handle); } catch (Exception e) { error = e; } return(IntPtr.Zero); }
/////////////////////////////////////////////////////////////////////// private static string GetNativeLibraryFileName( Interpreter interpreter /* NOT USED */ ) { string path = CommonOps.Environment.GetVariable( EnvVars.UtilityPath); if (!String.IsNullOrEmpty(path)) { if (File.Exists(path)) { return(path); } if (Directory.Exists(path)) { string fileName = PathOps.CombinePath( null, path, DllName.Utility); if (File.Exists(fileName)) { return(fileName); } // // TODO: Is this strictly necessary here? It is known // at this point that this file does not exist. // Setting the path here only controls the result // returned in non-strict mode (below). // path = fileName; } // // NOTE: If the environment variable was set and the utility // library could not be found, force an invalid result // to be returned. This ends up skipping the standard // automatic utility library detection logic. // lock (syncRoot) { return(strictPath ? null : path); } } // // HACK: If the processor architecture ends up being "AMD64", we // want it to be "x64" instead, to match the platform name // used by the native utility library project itself. // string processorName = PlatformOps.GetAlternateProcessorName( RuntimeOps.GetProcessorArchitecture(), true, false); if (processorName != null) { path = PathOps.CombinePath( null, GlobalState.GetAssemblyPath(), processorName, DllName.Utility); if (File.Exists(path)) { return(path); } } path = PathOps.CombinePath( null, GlobalState.GetAssemblyPath(), DllName.Utility); if (File.Exists(path)) { return(path); } lock (syncRoot) { return(strictPath ? null : path); } }
public static object Int32ToObject(int value) { return(RuntimeOps.Int32ToObject(value)); }
/// <summary> /// This is the constructor used by the core library to create an /// instance of the plugin, passing the necessary data to be used /// for initializing the plugin. /// </summary> /// /// <param name="pluginData"> /// An instance of the plugin data component used to hold the data /// necessary to fully initialize the plugin instance. This /// parameter may be null. Derived plugins are free to override /// this constructor; however, they are very strongly encouraged to /// call this constructor (i.e. the base class constructor) in that /// case. /// </param> public Default( IPluginData pluginData ) { kind = IdentifierKind.Plugin; // // VIRTUAL: Id of the deepest derived class. // id = AttributeOps.GetObjectId(this); // // VIRTUAL: Group of the deepest derived class. // group = AttributeOps.GetObjectGroup(this); // // NOTE: Is the supplied plugin data valid? // if (pluginData != null) { EntityOps.MaybeSetGroup( this, pluginData.Group); name = pluginData.Name; description = pluginData.Description; flags = pluginData.Flags; clientData = pluginData.ClientData; version = pluginData.Version; uri = pluginData.Uri; appDomain = pluginData.AppDomain; assembly = pluginData.Assembly; assemblyName = pluginData.AssemblyName; fileName = pluginData.FileName; typeName = pluginData.TypeName; } // // NOTE: Are we going to use their command list or create an // entirely new list? // if ((pluginData != null) && (pluginData.Commands != null)) { commands = pluginData.Commands; } else { commands = new CommandDataList(); } // // NOTE: Are we going to use their policy list or create an // entirely new list? // if ((pluginData != null) && (pluginData.Policies != null)) { policies = pluginData.Policies; } else { policies = new PolicyDataList(); } // // NOTE: Are we going to use their command tokens or create an // entirely new list? // if ((pluginData != null) && (pluginData.CommandTokens != null)) { commandTokens = pluginData.CommandTokens; } else { commandTokens = new LongList(); } // // NOTE: Are we going to use their command tokens or create an // entirely new list? // if ((pluginData != null) && (pluginData.FunctionTokens != null)) { functionTokens = pluginData.FunctionTokens; } else { functionTokens = new LongList(); } // // NOTE: Are we going to use their policy tokens or create an // entirely new list? // if ((pluginData != null) && (pluginData.PolicyTokens != null)) { policyTokens = pluginData.PolicyTokens; } else { policyTokens = new LongList(); } // // NOTE: Are we going to use their trace tokens or create an // entirely new list? // if ((pluginData != null) && (pluginData.TraceTokens != null)) { traceTokens = pluginData.TraceTokens; } else { traceTokens = new LongList(); } // // NOTE: Are we going to use the resource manager they specified or // create a new one based on the plugin name and assembly? // if ((pluginData != null) && (pluginData.ResourceManager != null)) { resourceManager = pluginData.ResourceManager; } else { // // NOTE: If the assembly is null we are probably loaded into an // isolated application domain. Therefore, in that case, // and only in that case, since we are executing in the // target application domain, load the assembly based on // the assembly name and then use that to create the // resource manager. However, do not simply set the // assembly field of this plugin to any non-null value // because we do not want to cause issues with the // interpreter plugin manager later. Also, skip attempts // to create a resource manager if the NoResources flag // has been set on the plugin. // if (!FlagOps.HasFlags(flags, PluginFlags.NoResources, true)) { if (assembly != null) { resourceManager = RuntimeOps.NewResourceManager( assembly); } else if (assemblyName != null) { resourceManager = RuntimeOps.NewResourceManager( assemblyName); } } } // // NOTE: Are we going to use the auxiliary data they specified or // create a new one? // if ((pluginData != null) && (pluginData.AuxiliaryData != null)) { auxiliaryData = pluginData.AuxiliaryData; } else { if (!FlagOps.HasFlags( flags, PluginFlags.NoAuxiliaryData, true)) { auxiliaryData = new ObjectDictionary(); } } // // NOTE: Also store the plugin token (which may be zero at this // point). // if (pluginData != null) { token = pluginData.Token; } }
/////////////////////////////////////////////////////////////////////// private static bool LoadNativeLibrary( Interpreter interpreter ) { lock (syncRoot) /* TRANSACTIONAL */ { if (nativeModule != IntPtr.Zero) { return(true); } try { string fileName = GetNativeLibraryFileName(interpreter); if (!String.IsNullOrEmpty(fileName)) { TraceOps.DebugTrace(String.Format( "LoadNativeLibrary: using file name {0}", FormatOps.WrapOrNull(fileName)), typeof(NativeUtility).Name, TracePriority.NativeDebug); } else { TraceOps.DebugTrace(String.Format( "LoadNativeLibrary: file name {0} is invalid", FormatOps.WrapOrNull(fileName)), typeof(NativeUtility).Name, TracePriority.NativeError); return(false); } // // NOTE: Check if the native library file name actually // exists. If not, do nothing and return failure // after tracing the issue. // if (!File.Exists(fileName)) { TraceOps.DebugTrace(String.Format( "LoadNativeLibrary: file name {0} does not exist", FormatOps.WrapOrNull(fileName)), typeof(NativeUtility).Name, TracePriority.NativeError); return(false); } // // BUGFIX: Stop loading "untrusted" native libraries // when running with a "trusted" core library. // if (!RuntimeOps.ShouldLoadNativeLibrary(fileName)) { TraceOps.DebugTrace(String.Format( "LoadNativeLibrary: file name {0} is untrusted", FormatOps.WrapOrNull(fileName)), typeof(NativeUtility).Name, TracePriority.NativeError); return(false); } int lastError; nativeModule = NativeOps.LoadLibrary( fileName, out lastError); /* throw */ if (nativeModule != IntPtr.Zero) { InitializeNativeDelegates(true); Result error = null; if (SetNativeDelegates(ref error)) { nativeFileName = fileName; TraceOps.DebugTrace( "LoadNativeLibrary: successfully loaded", typeof(NativeUtility).Name, TracePriority.NativeDebug); return(true); } else { TraceOps.DebugTrace(String.Format( "LoadNativeLibrary: file name {0} delegate " + "setup error: {1}", FormatOps.WrapOrNull(fileName), error), typeof(NativeUtility).Name, TracePriority.NativeError); /* IGNORED */ UnloadNativeLibrary(interpreter); } } else { TraceOps.DebugTrace(String.Format( "LoadLibrary({1}) failed with error {0}: {2}", lastError, FormatOps.WrapOrNull(fileName), NativeOps.GetDynamicLoadingError(lastError).Trim()), typeof(NativeUtility).Name, TracePriority.NativeError); } } catch (Exception e) { TraceOps.DebugTrace( e, typeof(NativeUtility).Name, TracePriority.NativeError); } return(false); } }
public object ToObject() { // Check the simple case upfront if (IsEmpty) { return(null); } switch (VariantType) { case VarEnum.VT_NULL: return(DBNull.Value); #region Generated Variant ToObject // *** BEGIN GENERATED CODE *** // generated by function: gen_ToObject from: generate_comdispatch.py case VarEnum.VT_I1: return(AsI1); case VarEnum.VT_I2: return(AsI2); case VarEnum.VT_I4: return(RuntimeOps.Int32ToObject(AsI4)); case VarEnum.VT_I8: return(AsI8); case VarEnum.VT_UI1: return(AsUi1); case VarEnum.VT_UI2: return(AsUi2); case VarEnum.VT_UI4: return(AsUi4); case VarEnum.VT_UI8: return(AsUi8); case VarEnum.VT_INT: return(AsInt); case VarEnum.VT_UINT: return(AsUint); case VarEnum.VT_BOOL: return(AsBool ? RuntimeOps.True : RuntimeOps.False); case VarEnum.VT_ERROR: return(AsError); case VarEnum.VT_R4: return(AsR4); case VarEnum.VT_R8: return(AsR8); case VarEnum.VT_DECIMAL: return(AsDecimal); case VarEnum.VT_CY: return(AsCy); case VarEnum.VT_DATE: return(AsDate); case VarEnum.VT_BSTR: return(AsBstr); case VarEnum.VT_UNKNOWN: return(AsUnknown); case VarEnum.VT_DISPATCH: return(AsDispatch); case VarEnum.VT_VARIANT: return(AsVariant); // *** END GENERATED CODE *** #endregion default: return(AsVariant); } }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count >= 2) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-debug", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-commandline", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-dequote", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-quoteall", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-unicode", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-ignorestderr", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-killonerror", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-keepnewline", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-noexitcode", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocapture", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-shell", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocarriagereturns", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-trimall", null), // simple switch new Option(typeof(ExitCode), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-success", null), // success exit code new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-domainname", null), new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-username", null), new Option(null, OptionFlags.MustHaveSecureStringValue, Index.Invalid, Index.Invalid, "-password", null), new Option(null, OptionFlags.MustHaveListValue, Index.Invalid, Index.Invalid, "-preprocessarguments", null), // command new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-directory", null), // directory name new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-processid", null), // varName for processId new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-exitcode", null), // varName for exitCode new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stdin", null), // varName for StdIn input new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stdout", null), // varName for StdOut output new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stderr", null), // varName for StdErr output new Option(typeof(EventFlags), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-eventflags", new Variant(interpreter.EngineEventFlags)), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, true, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if (argumentIndex != Index.Invalid) { bool debug = false; if (options.IsPresent("-debug")) { debug = true; } bool commandLine = false; if (options.IsPresent("-commandline")) { commandLine = true; } bool dequote = false; if (options.IsPresent("-dequote")) { dequote = true; } bool quoteAll = false; if (options.IsPresent("-quoteall")) { quoteAll = true; } bool captureExitCode = true; if (options.IsPresent("-noexitcode")) { captureExitCode = false; } bool captureInput = true; bool captureOutput = true; if (options.IsPresent("-nocapture")) { captureInput = false; captureOutput = false; } bool useUnicode = false; if (options.IsPresent("-unicode")) { useUnicode = true; } bool ignoreStdErr = false; if (options.IsPresent("-ignorestderr")) { ignoreStdErr = true; } bool killOnError = false; if (options.IsPresent("-killonerror")) { killOnError = true; } bool keepNewLine = false; if (options.IsPresent("-keepnewline")) { keepNewLine = true; } bool carriageReturns = true; if (options.IsPresent("-nocarriagereturns")) { carriageReturns = false; } bool trimAll = false; if (options.IsPresent("-trimall")) { trimAll = true; } bool useShellExecute = false; if (options.IsPresent("-shell")) { useShellExecute = true; } Variant value = null; ExitCode?successExitCode = null; if (options.IsPresent("-success", ref value)) { successExitCode = (ExitCode)value.Value; } string domainName = null; if (options.IsPresent("-domainname", ref value)) { domainName = value.ToString(); } string userName = null; if (options.IsPresent("-username", ref value)) { userName = value.ToString(); } SecureString password = null; if (options.IsPresent("-password", ref value)) { password = (SecureString)value.Value; } string directory = null; if (options.IsPresent("-directory", ref value)) { directory = value.ToString(); } string processIdVarName = null; if (options.IsPresent("-processid", ref value)) { processIdVarName = value.ToString(); } string exitCodeVarName = null; if (options.IsPresent("-exitcode", ref value)) { exitCodeVarName = value.ToString(); } string stdInVarName = null; if (options.IsPresent("-stdin", ref value)) { stdInVarName = value.ToString(); } string stdOutVarName = null; if (options.IsPresent("-stdout", ref value)) { stdOutVarName = value.ToString(); } string stdErrVarName = null; if (options.IsPresent("-stderr", ref value)) { stdErrVarName = value.ToString(); } EventFlags eventFlags = interpreter.EngineEventFlags; if (options.IsPresent("-eventflags", ref value)) { eventFlags = (EventFlags)value.Value; } StringList list = null; if (options.IsPresent("-preprocessarguments", ref value)) { list = (StringList)value.Value; } int argumentStopIndex = arguments.Count - 1; bool background = false; if (arguments[arguments.Count - 1] == Characters.Ampersand.ToString()) { argumentStopIndex--; background = true; } string execFileName = arguments[argumentIndex]; if (!PathOps.IsRemoteUri(execFileName)) { execFileName = PathOps.GetNativePath(execFileName); } string execArguments = null; if ((argumentIndex + 1) < arguments.Count) { if (commandLine) { execArguments = RuntimeOps.BuildCommandLine( ArgumentList.GetRangeAsStringList(arguments, argumentIndex + 1, argumentStopIndex, dequote), quoteAll); } else { execArguments = ListOps.Concat(arguments, argumentIndex + 1, argumentStopIndex); } } Result input = null; if ((code == ReturnCode.Ok) && !useShellExecute && captureInput && (stdInVarName != null)) { code = interpreter.GetVariableValue(VariableFlags.None, stdInVarName, ref input, ref result); } if (debug) { TraceOps.DebugTrace(String.Format( "Execute: interpreter = {0}, domainName = {1}, userName = {2}, " + "password = {3}, execFileName = {4}, execArguments = {5}, " + "directory = {6}, input = {7}, eventFlags = {8}, debug = {9}, " + "commandLine = {10}, dequote = {11}, quoteAll = {12}, " + "useShellExecute = {13}, captureExitCode = {14}, " + "captureInput = {15}, captureOutput = {16}, useUnicode = {17}, " + "ignoreStdErr = {18}, killOnError = {19}, keepNewLine = {20}, " + "carriageReturns = {21}, trimAll = {22}, background = {23}, " + "successExitCode = {24}, processIdVarName = {25}, exitCodeVarName = {26}, " + "stdInVarName = {27}, stdOutVarName = {28}, stdErrVarName = {29}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(domainName), FormatOps.WrapOrNull(userName), FormatOps.WrapOrNull(password), FormatOps.WrapOrNull(execFileName), FormatOps.WrapOrNull(execArguments), FormatOps.WrapOrNull(directory), FormatOps.WrapOrNull(input), FormatOps.WrapOrNull(eventFlags), debug, commandLine, dequote, quoteAll, useShellExecute, captureExitCode, captureInput, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, carriageReturns, trimAll, background, FormatOps.WrapOrNull(successExitCode), FormatOps.WrapOrNull(processIdVarName), FormatOps.WrapOrNull(exitCodeVarName), FormatOps.WrapOrNull(stdInVarName), FormatOps.WrapOrNull(stdOutVarName), FormatOps.WrapOrNull(stdErrVarName)), typeof(Exec).Name, TracePriority.Command); } int processId = 0; ExitCode exitCode = ResultOps.SuccessExitCode(); Result error = null; if (code == ReturnCode.Ok) { if (list != null) { list.Add(execFileName); list.Add(directory); list.Add(execArguments); code = interpreter.EvaluateScript(list.ToString(), ref result); if (code == ReturnCode.Return) { execArguments = result; code = ReturnCode.Ok; } else if (code == ReturnCode.Continue) { code = ReturnCode.Ok; goto done; } } if (code == ReturnCode.Ok) { code = ProcessOps.ExecuteProcess( interpreter, domainName, userName, password, execFileName, execArguments, directory, input, eventFlags, useShellExecute, captureExitCode, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, background, !background, ref processId, ref exitCode, ref result, ref error); } } done: if (debug) { TraceOps.DebugTrace(String.Format( "Execute: interpreter = {0}, domainName = {1}, userName = {2}, " + "password = {3}, execFileName = {4}, execArguments = {5}, " + "directory = {6}, input = {7}, eventFlags = {8}, debug = {9}, " + "commandLine = {10}, dequote = {11}, quoteAll = {12}, " + "useShellExecute = {13}, captureExitCode = {14}, " + "captureInput = {15}, captureOutput = {16}, useUnicode = {17}, " + "ignoreStdErr = {18}, killOnError = {19}, keepNewLine = {20}, " + "carriageReturns = {21}, trimAll = {22}, background = {23}, " + "successExitCode = {24}, processIdVarName = {25}, exitCodeVarName = {26}, " + "stdInVarName = {27}, stdOutVarName = {28}, stdErrVarName = {29}, " + "processId = {30}, exitCode = {31}, result = {32}, error = {33}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(domainName), FormatOps.WrapOrNull(userName), FormatOps.WrapOrNull(password), FormatOps.WrapOrNull(execFileName), FormatOps.WrapOrNull(execArguments), FormatOps.WrapOrNull(directory), FormatOps.WrapOrNull(input), FormatOps.WrapOrNull(eventFlags), debug, commandLine, dequote, quoteAll, useShellExecute, captureExitCode, captureInput, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, carriageReturns, trimAll, background, FormatOps.WrapOrNull(successExitCode), FormatOps.WrapOrNull(processIdVarName), FormatOps.WrapOrNull(exitCodeVarName), FormatOps.WrapOrNull(stdInVarName), FormatOps.WrapOrNull(stdOutVarName), FormatOps.WrapOrNull(stdErrVarName), processId, exitCode, FormatOps.WrapOrNull(true, true, result), FormatOps.WrapOrNull(true, true, error)), typeof(Exec).Name, TracePriority.Command); } // // NOTE: Even upon failure, always set the variable to contain // process Id, if applicable. // if (processIdVarName != null) { /* IGNORED */ interpreter.SetVariableValue( /* EXEMPT */ VariableFlags.NoReady, processIdVarName, processId.ToString(), null); } if (code == ReturnCode.Ok) { // // NOTE: Remove all carriage returns from output (leaving // only line feeds as line separators)? // if (!carriageReturns) { if (!String.IsNullOrEmpty(result)) { result = result.Replace( Characters.CarriageReturnString, String.Empty); } if (!String.IsNullOrEmpty(error)) { error = error.Replace( Characters.CarriageReturnString, String.Empty); } } // // NOTE: Remove all surrounding whitespace from the output? // if (trimAll) { if (!String.IsNullOrEmpty(result)) { result = result.Trim(); } if (!String.IsNullOrEmpty(error)) { error = error.Trim(); } } // // NOTE: Now, "result" contains any StdOut output and "error" // contains any StdErr output. // if ((code == ReturnCode.Ok) && !background && captureExitCode && (exitCodeVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, exitCodeVarName, exitCode.ToString(), null, ref error); } if ((code == ReturnCode.Ok) && !useShellExecute && !background && captureOutput && (stdOutVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, stdOutVarName, result, null, ref error); } if ((code == ReturnCode.Ok) && !useShellExecute && !background && captureOutput && (stdErrVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, stdErrVarName, error, null, ref error); } // // NOTE: If they specified a "success" exit code, make sure // that is the same as the exit code we actually got // from the process. // if ((code == ReturnCode.Ok) && !background && captureExitCode && (successExitCode != null) && (exitCode != successExitCode)) { /* IGNORED */ interpreter.SetVariableValue( /* EXEMPT */ Engine.ErrorCodeVariableFlags, TclVars.ErrorCode, StringList.MakeList( "CHILDSTATUS", processId, exitCode), null); Engine.SetErrorCodeSet(interpreter, true); error = "child process exited abnormally"; code = ReturnCode.Error; } if (code != ReturnCode.Ok) { // // NOTE: Transfer error to command result. // result = error; } } else { // // NOTE: Transfer error to command result. // result = error; } } else { result = "wrong # args: should be \"exec ?options? arg ?arg ...?\""; code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"exec ?options? arg ?arg ...?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { if (interpreter == null) { result = "invalid interpreter"; return(ReturnCode.Error); } if (arguments == null) { result = "invalid argument list"; return(ReturnCode.Error); } if (arguments.Count < 2) { result = "wrong # args: should be \"hash option ?arg ...?\""; return(ReturnCode.Error); } ReturnCode code; string subCommand = arguments[1]; bool tried = false; code = ScriptOps.TryExecuteSubCommandFromEnsemble( interpreter, this, clientData, arguments, true, false, ref subCommand, ref tried, ref result); if ((code != ReturnCode.Ok) || tried) { return(code); } // // NOTE: These algorithms are known to be supported by the // framework. // // Normal: MD5, RIPEMD160, SHA, SHA1, SHA256, SHA384, SHA512 // // Keyed: MACTripleDES // // HMAC: HMACMD5, HMACRIPEMD160, HMACSHA1, HMACSHA256, // HMACSHA384, HMACSHA512 // switch (subCommand) { case "keyed": { if (arguments.Count >= 4) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-raw", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-filename", null), /* COMPAT: Tcllib. */ new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions( options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) <= arguments.Count) && ((argumentIndex + 3) >= arguments.Count)) { Variant value = null; bool raw = false; if (options.IsPresent("-raw")) { raw = true; } bool isFileName = false; if (options.IsPresent("-filename", ref value)) { isFileName = true; } Encoding encoding = null; if (options.IsPresent("-encoding", ref value)) { encoding = (Encoding)value.Value; } if (code == ReturnCode.Ok) { try { using (KeyedHashAlgorithm algorithm = KeyedHashAlgorithm.Create( arguments[argumentIndex])) { if (algorithm != null) { algorithm.Initialize(); if ((argumentIndex + 3) == arguments.Count) { byte[] bytes = null; code = StringOps.GetBytes( encoding, arguments[argumentIndex + 2], EncodingType.Binary, ref bytes, ref result); if (code == ReturnCode.Ok) { algorithm.Key = bytes; } } if (code == ReturnCode.Ok) { if (isFileName) { Stream stream = null; try { code = RuntimeOps.NewStream( interpreter, arguments[argumentIndex + 1], FileMode.Open, FileAccess.Read, ref stream, ref result); if (code == ReturnCode.Ok) { if (raw) { result = new ByteList( algorithm.ComputeHash(stream)); } else { result = FormatOps.Hash( algorithm.ComputeHash(stream)); } } } finally { if (stream != null) { stream.Close(); stream = null; } } } else { byte[] bytes = null; code = StringOps.GetBytes( encoding, arguments[argumentIndex + 1], EncodingType.Binary, ref bytes, ref result); if (raw) { result = new ByteList( algorithm.ComputeHash(bytes)); } else { result = FormatOps.Hash( algorithm.ComputeHash(bytes)); } } } } else { result = String.Format( "unsupported keyed hash algorithm \"{0}\"", arguments[argumentIndex]); code = ReturnCode.Error; } } } catch (Exception e) { Engine.SetExceptionErrorCode(interpreter, e); result = e; code = ReturnCode.Error; } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption( options, arguments[argumentIndex]); } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string ?key?\"", this.Name, subCommand); } code = ReturnCode.Error; } } } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string ?key?\"", this.Name, subCommand); code = ReturnCode.Error; } break; } case "list": { if ((arguments.Count == 2) || (arguments.Count == 3)) { string type = null; if (arguments.Count == 3) { type = arguments[2]; } switch (type) { case null: case "all": { StringList list = new StringList(); lock (syncRoot) { if (defaultAlgorithms != null) { list.AddRange(defaultAlgorithms); } } if (keyedHashAlgorithmNames != null) { foreach (string hashAlgorithmName in keyedHashAlgorithmNames) { list.Add(StringList.MakeList("keyed", hashAlgorithmName)); } } if (macHashAlgorithmNames != null) { foreach (string hashAlgorithmName in macHashAlgorithmNames) { list.Add(StringList.MakeList("mac", hashAlgorithmName)); } } if (normalHashAlgorithmNames != null) { foreach (string hashAlgorithmName in normalHashAlgorithmNames) { list.Add(StringList.MakeList("normal", hashAlgorithmName)); } } result = list; break; } case "default": { lock (syncRoot) { result = (defaultAlgorithms != null) ? new StringList(defaultAlgorithms) : null; } break; } case "keyed": { result = (keyedHashAlgorithmNames != null) ? new StringList(keyedHashAlgorithmNames) : null; break; } case "mac": { result = (macHashAlgorithmNames != null) ? new StringList(macHashAlgorithmNames) : null; break; } case "normal": { result = (normalHashAlgorithmNames != null) ? new StringList(normalHashAlgorithmNames) : null; break; } default: { result = "unknown algorithm list, must be: all, default, keyed, mac, or normal"; code = ReturnCode.Error; break; } } } else { result = String.Format( "wrong # args: should be \"{0} {1} ?type?\"", this.Name, subCommand); code = ReturnCode.Error; } break; } case "mac": { if (arguments.Count >= 4) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-raw", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-filename", null), /* COMPAT: Tcllib. */ new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions( options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) <= arguments.Count) && ((argumentIndex + 3) >= arguments.Count)) { Variant value = null; bool raw = false; if (options.IsPresent("-raw")) { raw = true; } bool isFileName = false; if (options.IsPresent("-filename", ref value)) { isFileName = true; } Encoding encoding = null; if (options.IsPresent("-encoding", ref value)) { encoding = (Encoding)value.Value; } if (code == ReturnCode.Ok) { try { using (HMAC algorithm = HMAC.Create( arguments[argumentIndex])) { if (algorithm != null) { algorithm.Initialize(); if ((argumentIndex + 3) == arguments.Count) { byte[] bytes = null; code = StringOps.GetBytes( encoding, arguments[argumentIndex + 2], EncodingType.Binary, ref bytes, ref result); if (code == ReturnCode.Ok) { algorithm.Key = bytes; } } if (code == ReturnCode.Ok) { if (isFileName) { Stream stream = null; try { code = RuntimeOps.NewStream( interpreter, arguments[argumentIndex + 1], FileMode.Open, FileAccess.Read, ref stream, ref result); if (code == ReturnCode.Ok) { if (raw) { result = new ByteList( algorithm.ComputeHash(stream)); } else { result = FormatOps.Hash( algorithm.ComputeHash(stream)); } } } finally { if (stream != null) { stream.Close(); stream = null; } } } else { byte[] bytes = null; code = StringOps.GetBytes( encoding, arguments[argumentIndex + 1], EncodingType.Binary, ref bytes, ref result); if (raw) { result = new ByteList( algorithm.ComputeHash(bytes)); } else { result = FormatOps.Hash( algorithm.ComputeHash(bytes)); } } } } else { result = String.Format( "unsupported hmac algorithm \"{0}\"", arguments[argumentIndex]); code = ReturnCode.Error; } } } catch (Exception e) { Engine.SetExceptionErrorCode(interpreter, e); result = e; code = ReturnCode.Error; } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption( options, arguments[argumentIndex]); } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string ?key?\"", this.Name, subCommand); } code = ReturnCode.Error; } } } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string ?key?\"", this.Name, subCommand); code = ReturnCode.Error; } break; } case "normal": { if (arguments.Count >= 4) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-raw", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-filename", null), /* COMPAT: Tcllib. */ new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions( options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) == arguments.Count)) { Variant value = null; bool raw = false; if (options.IsPresent("-raw")) { raw = true; } bool isFileName = false; if (options.IsPresent("-filename", ref value)) { isFileName = true; } Encoding encoding = null; if (options.IsPresent("-encoding", ref value)) { encoding = (Encoding)value.Value; } if (code == ReturnCode.Ok) { try { using (HashAlgorithm algorithm = HashAlgorithm.Create( arguments[argumentIndex])) { if (algorithm != null) { algorithm.Initialize(); if (isFileName) { Stream stream = null; try { code = RuntimeOps.NewStream( interpreter, arguments[argumentIndex + 1], FileMode.Open, FileAccess.Read, ref stream, ref result); if (code == ReturnCode.Ok) { if (raw) { result = new ByteList( algorithm.ComputeHash(stream)); } else { result = FormatOps.Hash( algorithm.ComputeHash(stream)); } } } finally { if (stream != null) { stream.Close(); stream = null; } } } else { byte[] bytes = null; code = StringOps.GetBytes( encoding, arguments[argumentIndex + 1], EncodingType.Binary, ref bytes, ref result); if (code == ReturnCode.Ok) { if (raw) { result = new ByteList( algorithm.ComputeHash(bytes)); } else { result = FormatOps.Hash( algorithm.ComputeHash(bytes)); } } } } else { result = String.Format( "unsupported hash algorithm \"{0}\"", arguments[argumentIndex]); code = ReturnCode.Error; } } } catch (Exception e) { Engine.SetExceptionErrorCode(interpreter, e); result = e; code = ReturnCode.Error; } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption( options, arguments[argumentIndex]); } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string\"", this.Name, subCommand); } code = ReturnCode.Error; } } } else { result = String.Format( "wrong # args: should be \"{0} {1} ?options? algorithm string\"", this.Name, subCommand); code = ReturnCode.Error; } break; } default: { result = ScriptOps.BadSubCommand( interpreter, null, null, subCommand, this, null, null); code = ReturnCode.Error; break; } } return(code); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count == 4) { string name = arguments[1]; StringList list = null; code = Parser.SplitList( interpreter, arguments[2], 0, Length.Invalid, true, ref list, ref result); if (code == ReturnCode.Ok) { StringPairList list2 = new StringPairList(); for (int argumentIndex = 0; argumentIndex < list.Count; argumentIndex++) { StringList list3 = null; code = Parser.SplitList( interpreter, list[argumentIndex], 0, Length.Invalid, true, ref list3, ref result); if (code != ReturnCode.Ok) { break; } if (list3.Count > 2) { result = String.Format( "too many fields in argument specifier \"{0}\"", list[argumentIndex]); code = ReturnCode.Error; break; } else if ((list3.Count == 0) || String.IsNullOrEmpty(list3[0])) { result = "argument with no name"; code = ReturnCode.Error; break; } else if (!Parser.IsSimpleScalarVariableName(list3[0], String.Format(Interpreter.ArgumentNotSimpleError, list3[0]), String.Format(Interpreter.ArgumentNotScalarError, list3[0]), ref result)) { code = ReturnCode.Error; break; } string argName = list3[0]; string argDefault = (list3.Count >= 2) ? list3[1] : null; list2.Add(new StringPair(argName, argDefault)); } if (code == ReturnCode.Ok) { lock (interpreter.SyncRoot) /* TRANSACTIONAL */ { ProcedureFlags procedureFlags = interpreter.ProcedureFlags; IProcedure procedure = RuntimeOps.NewCoreProcedure( interpreter, interpreter.AreNamespacesEnabled() ? NamespaceOps.MakeQualifiedName(interpreter, name) : ScriptOps.MakeCommandName(name), null, null, procedureFlags, new ArgumentList(list2, ArgumentFlags.NameOnly), arguments[3], ScriptLocation.Create(arguments[3]), clientData); code = interpreter.AddOrUpdateProcedureWithReplace( procedure, clientData, ref result); if (code == ReturnCode.Ok) { result = String.Empty; } } } } if (code == ReturnCode.Error) { Engine.AddErrorInformation(interpreter, result, String.Format("{0} (creating proc \"{1}\")", Environment.NewLine, name)); } } else { result = "wrong # args: should be \"proc name args body\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
private static bool IsSupported( Type type ) { if (type == null) { return(false); } if (type == typeof(bool)) { return(true); } else if (type == typeof(byte)) { return(true); } else if (type == typeof(char)) { return(true); } else if (type == typeof(int)) { return(true); } else if (type == typeof(long)) { return(true); } else if (type == typeof(double)) { return(true); } else if (type == typeof(decimal)) { return(true); } else if (type == typeof(string)) { return(true); } else if (type == typeof(DateTime)) { return(true); } else if (type == typeof(TimeSpan)) { return(true); } else if (type == typeof(Guid)) { return(true); } else if (type == typeof(Uri)) { return(true); } else if (type == typeof(Version)) { return(true); } else if (type == typeof(StringBuilder)) { return(true); } else if (type == typeof(CommandBuilder)) { return(true); } else if (type == typeof(Interpreter)) { return(true); } else if (type == typeof(Argument)) { return(true); } else if (type == typeof(ByteList)) { return(true); } else if (type == typeof(ResultList)) { return(true); } else if (type.IsEnum) { return(true); } else if (RuntimeOps.DoesClassTypeSupportInterface( type, typeof(IStringList))) { return(true); } else if (RuntimeOps.IsClassTypeEqualOrSubClass( type, typeof(Exception), true)) { return(true); } return(false); }