File: compmod\system\codedom\compiler\CodeCompiler.cs
Project: ndp\fx\src\System.csproj (System)
//------------------------------------------------------------------------------
// <copyright file="CodeCompiler.cs" company="Microsoft">
// 
// <OWNER>Microsoft</OWNER>
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------
 
namespace System.CodeDom.Compiler {
    using System.Text;
 
    using System.Diagnostics;
    using System;
    using Microsoft.Win32;
    using Microsoft.Win32.SafeHandles;
    using System.IO;
    using System.Collections;
    using System.Security;
    using System.Security.Permissions;
    using System.Security.Policy;
    using System.Security.Principal;
    using System.Reflection;
    using System.CodeDom;
    using System.Globalization;
    using System.Runtime.Versioning;
 
    /// <devdoc>
    /// <para>Provides a
    /// base
    /// class for code compilers.</para>
    /// </devdoc>
    [PermissionSet(SecurityAction.LinkDemand, Name="FullTrust")]
    [PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust")]
    public abstract class CodeCompiler : CodeGenerator, ICodeCompiler {
 
        /// <internalonly/>
        CompilerResults ICodeCompiler.CompileAssemblyFromDom(CompilerParameters options, CodeCompileUnit e) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
 
            try {                
                return FromDom(options, e);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
 
        /// <internalonly/>
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        CompilerResults ICodeCompiler.CompileAssemblyFromFile(CompilerParameters options, string fileName) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
 
            try {
                return FromFile(options, fileName);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
 
        /// <internalonly/>
        CompilerResults ICodeCompiler.CompileAssemblyFromSource(CompilerParameters options, string source) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
 
            try {
                return FromSource(options, source);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
 
        /// <internalonly/>
        CompilerResults ICodeCompiler.CompileAssemblyFromSourceBatch(CompilerParameters options, string[] sources) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
 
            try {
                return FromSourceBatch(options, sources);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
        
        /// <internalonly/>
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        CompilerResults ICodeCompiler.CompileAssemblyFromFileBatch(CompilerParameters options, string[] fileNames) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            if (fileNames == null)
                throw new ArgumentNullException("fileNames");
 
            try {
                // Try opening the files to make sure they exists.  This will throw an exception
                // if it doesn't
                foreach (string fileName in fileNames) {
                    using (Stream str = File.OpenRead(fileName)) { }
                }
 
                return FromFileBatch(options, fileNames);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
 
        /// <internalonly/>
        CompilerResults ICodeCompiler.CompileAssemblyFromDomBatch(CompilerParameters options, CodeCompileUnit[] ea) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
 
            try {
                return FromDomBatch(options, ea);
            }
            finally {
                options.TempFiles.SafeDelete();
            }
        }
        
        /// <devdoc>
        /// <para>
        /// Gets
        /// or sets the file extension to use for source files.
        /// </para>
        /// </devdoc>
        protected abstract string FileExtension {
            get;
        }
 
        /// <devdoc>
        /// <para>Gets or
        /// sets the name of the compiler executable.</para>
        /// </devdoc>
        protected abstract string CompilerName {
            get;
        }
 
 
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        internal void Compile(CompilerParameters options, string compilerDirectory, string compilerExe, string arguments, ref string outputFile, ref int nativeReturnValue, string trueArgs) {
            string errorFile = null;
            outputFile = options.TempFiles.AddExtension("out");
            
            // We try to execute the compiler with a full path name.
            string fullname = Path.Combine(compilerDirectory, compilerExe);
            if (File.Exists(fullname)) {
                string trueCmdLine = null;
                if (trueArgs != null)
                    trueCmdLine = "\"" + fullname + "\" " + trueArgs;
                nativeReturnValue = Executor.ExecWaitWithCapture(options.SafeUserToken, "\"" + fullname + "\" " + arguments, Environment.CurrentDirectory, options.TempFiles, ref outputFile, ref errorFile, trueCmdLine);
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.CompilerNotFound, fullname));
            }
        }
 
        /// <devdoc>
        /// <para>
        /// Compiles the specified compile unit and options, and returns the results
        /// from the compilation.
        /// </para>
        /// </devdoc>
        protected virtual CompilerResults FromDom(CompilerParameters options, CodeCompileUnit e) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
                        
            CodeCompileUnit[] units = new CodeCompileUnit[1];
            units[0] = e;
            return FromDomBatch(options, units);
        }
 
        /// <devdoc>
        /// <para>
        /// Compiles the specified file using the specified options, and returns the
        /// results from the compilation.
        /// </para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        protected virtual CompilerResults FromFile(CompilerParameters options, string fileName) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            if (fileName == null)
                throw new ArgumentNullException("fileName");
 
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
            
            // Try opening the file to make sure it exists.  This will throw an exception
            // if it doesn't
            using (Stream str = File.OpenRead(fileName)) { }
 
            string[] filenames = new string[1];
            filenames[0] = fileName;
            return FromFileBatch(options, filenames);
        }
        
         /// <devdoc>
         /// <para>
         /// Compiles the specified source code using the specified options, and
         /// returns the results from the compilation.
         /// </para>
         /// </devdoc>
         protected virtual CompilerResults FromSource(CompilerParameters options, string source) {
             if( options == null) {
                 throw new ArgumentNullException("options");
             }
 
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
 
            string[] sources = new string[1];
            sources[0] = source;
 
            return FromSourceBatch(options, sources);
        }
        
        /// <devdoc>
        /// <para>
        /// Compiles the specified compile units and
        /// options, and returns the results from the compilation.
        /// </para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        protected virtual CompilerResults FromDomBatch(CompilerParameters options, CodeCompileUnit[] ea) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            if (ea == null)
                throw new ArgumentNullException("ea");
 
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
 
            string[] filenames = new string[ea.Length];
 
            CompilerResults results = null;
            
#if !FEATURE_PAL
            // the extra try-catch is here to mitigate exception filter injection attacks. 
            try {
                WindowsImpersonationContext impersonation = Executor.RevertImpersonation();
                try {
#endif // !FEATURE_PAL
                    for (int i = 0; i < ea.Length; i++) {
                        if (ea[i] == null)
                            continue;       // the other two batch methods just work if one element is null, so we'll match that. 
                        
                        ResolveReferencedAssemblies(options, ea[i]);
                        filenames[i] = options.TempFiles.AddExtension(i + FileExtension);
                        Stream temp = new FileStream(filenames[i], FileMode.Create, FileAccess.Write, FileShare.Read);
                        try {
                            using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)){
                                ((ICodeGenerator)this).GenerateCodeFromCompileUnit(ea[i], sw, Options);
                                sw.Flush();
                            }
                        }
                        finally {
                            temp.Close();
                        }
                    }
 
                    results = FromFileBatch(options, filenames);
#if !FEATURE_PAL
                }
                finally {
                    Executor.ReImpersonate(impersonation);
                }
            }
            catch {
                throw;
            }
#endif // !FEATURE_PAL
            return results;
        }
 
        /// <devdoc>
        ///    <para>
        ///       Because CodeCompileUnit and CompilerParameters both have a referenced assemblies 
        ///       property, they must be reconciled. However, because you can compile multiple
        ///       compile units with one set of options, it will simply merge them.
        ///    </para>
        /// </devdoc>
        private void ResolveReferencedAssemblies(CompilerParameters options, CodeCompileUnit e) {
            if (e.ReferencedAssemblies.Count > 0) {
                foreach(string assemblyName in e.ReferencedAssemblies) {
                    if (!options.ReferencedAssemblies.Contains(assemblyName)) {
                        options.ReferencedAssemblies.Add(assemblyName);
                    }
                }
            }
        }
 
        /// <devdoc>
        /// <para>
        /// Compiles the specified files using the specified options, and returns the
        /// results from the compilation.
        /// </para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        protected virtual CompilerResults FromFileBatch(CompilerParameters options, string[] fileNames) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            if (fileNames == null)
                throw new ArgumentNullException("fileNames");
 
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
 
            string outputFile = null;
            int retValue = 0;
 
            CompilerResults results = new CompilerResults(options.TempFiles);
            SecurityPermission perm1 = new SecurityPermission(SecurityPermissionFlag.ControlEvidence);
            perm1.Assert();
            try {
#pragma warning disable 618
               results.Evidence = options.Evidence;
#pragma warning restore 618
            }
            finally {
                 SecurityPermission.RevertAssert();
            }
            bool createdEmptyAssembly = false;
 
            if (options.OutputAssembly == null || options.OutputAssembly.Length == 0) {
                string extension = (options.GenerateExecutable) ? "exe" : "dll";
                options.OutputAssembly = results.TempFiles.AddExtension(extension, !options.GenerateInMemory);
 
                // Create an empty assembly.  This is so that the file will have permissions that
                // we can later access with our current credential.  If we don't do this, the compiler
                // could end up creating an assembly that we cannot open 
                new FileStream(options.OutputAssembly, FileMode.Create, FileAccess.ReadWrite).Close();
                createdEmptyAssembly = true;
            }
 
#if FEATURE_PAL
            results.TempFiles.AddExtension("ildb");
#else
            results.TempFiles.AddExtension("pdb");
#endif
 
            string args = CmdArgsFromParameters(options) + " " + JoinStringArray(fileNames, " ");
 
            // Use a response file if the compiler supports it
            string responseFileArgs = GetResponseFileCmdArgs(options, args);
            string trueArgs = null;
            if (responseFileArgs != null) {
                trueArgs = args;
                args = responseFileArgs;
            }
 
            Compile(options, Executor.GetRuntimeInstallDirectory(), CompilerName, args, ref outputFile, ref retValue, trueArgs);
 
            results.NativeCompilerReturnValue = retValue;
 
            // only look for errors/warnings if the compile failed or the caller set the warning level
            if (retValue != 0 || options.WarningLevel > 0) {
 
                FileStream outputStream = new FileStream(outputFile, FileMode.Open,
                    FileAccess.Read, FileShare.ReadWrite);
                try {
                    if (outputStream.Length > 0) {
                        // The output of the compiler is in UTF8
                        StreamReader sr = new StreamReader(outputStream, Encoding.UTF8);
                        string line;
                        do {
                            line = sr.ReadLine();
                            if (line != null) { 
                                results.Output.Add(line);
 
                                ProcessCompilerOutputLine(results, line);
                            }
                        } while (line != null);
                    }
                }
                finally {
                    outputStream.Close();
                }
 
                // Delete the empty assembly if we created one
                if (retValue != 0 && createdEmptyAssembly)
                    File.Delete(options.OutputAssembly);
            }
 
            if (!results.Errors.HasErrors && options.GenerateInMemory) {
                FileStream fs = new FileStream(options.OutputAssembly, FileMode.Open, FileAccess.Read, FileShare.Read);
                try {
                    int fileLen = (int)fs.Length;
                    byte[] b = new byte[fileLen];
                    fs.Read(b, 0, fileLen);
                    SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.ControlEvidence);
                    perm.Assert();
                    try {
                        if (!FileIntegrity.IsEnabled) {
#pragma warning disable 618 // Load with evidence is obsolete - this warning is passed on via the options parameter
                            results.CompiledAssembly = Assembly.Load(b, null, options.Evidence);
#pragma warning restore 618
                        }
                        else {
                            if (!FileIntegrity.IsTrusted(fs.SafeFileHandle))
                                throw new IOException(SR.GetString(SR.FileIntegrityCheckFailed, options.OutputAssembly));
 
                            results.CompiledAssembly = LoadImageSkipIntegrityCheck(b, null, options.Evidence); 
                        }
                    }
                    finally {
                       SecurityPermission.RevertAssert();
                    }
                }
                finally {
                    fs.Close();
                }
            }
            else {
                results.PathToAssembly = options.OutputAssembly;
            }
 
            return results;
        }
 
        /// <devdoc>
        /// <para>Processes the specified line from the specified <see cref='System.CodeDom.Compiler.CompilerResults'/> .</para>
        /// </devdoc>
        protected abstract void ProcessCompilerOutputLine(CompilerResults results, string line);
 
        /// <devdoc>
        /// <para>
        /// Gets the command arguments from the specified <see cref='System.CodeDom.Compiler.CompilerParameters'/>.
        /// </para>
        /// </devdoc>
        protected abstract string CmdArgsFromParameters(CompilerParameters options);
 
        /// <devdoc>
        /// <para>[To be supplied.]</para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        protected virtual string GetResponseFileCmdArgs(CompilerParameters options, string cmdArgs) {
 
            string responseFileName = options.TempFiles.AddExtension("cmdline");
 
            Stream temp = new FileStream(responseFileName, FileMode.Create, FileAccess.Write, FileShare.Read);
            try {
                using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) {
                    sw.Write(cmdArgs);
                    sw.Flush();
                }
            }
            finally {
                temp.Close();
            }
 
            return "@\"" + responseFileName + "\"";
        }
 
        /// <devdoc>
        /// <para>
        /// Compiles the specified source code strings using the specified options, and
        /// returns the results from the compilation.
        /// </para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        protected virtual CompilerResults FromSourceBatch(CompilerParameters options, string[] sources) {
            if( options == null) {
                throw new ArgumentNullException("options");
            }
            if (sources == null)
                throw new ArgumentNullException("sources");
 
            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
 
            string[] filenames = new string[sources.Length];
            FileStream[] fileStreams = new FileStream[sources.Length];
 
            CompilerResults results = null;
#if !FEATURE_PAL
            // the extra try-catch is here to mitigate exception filter injection attacks. 
            try {
                WindowsImpersonationContext impersonation = Executor.RevertImpersonation();
                try {      
#endif // !FEATURE_PAL
                    try {
                        bool isFileIntegrityEnabled = FileIntegrity.IsEnabled;
                        for (int i = 0; i < sources.Length; i++) {
                            string name = options.TempFiles.AddExtension(i + FileExtension);
                            FileStream fileStream = new FileStream(name, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
                            fileStreams[i] = fileStream;
                            using (StreamWriter sw = new StreamWriter(fileStream, Encoding.UTF8)) {
                                sw.Write(sources[i]);
                                sw.Flush();
                                if (isFileIntegrityEnabled)
                                    FileIntegrity.MarkAsTrusted(fileStream.SafeFileHandle);
                            }
                            filenames[i] = name;
                        }
 
                        results = FromFileBatch(options, filenames);
                    }
                    finally {
                        for (int i = 0; i < fileStreams.Length && fileStreams[i] != null; i++)
                            fileStreams[i].Close();
                    }
#if !FEATURE_PAL
                }
                finally {
                    Executor.ReImpersonate(impersonation);
                }
            }   
            catch {
                throw;
            }
#endif // !FEATURE_PAL
 
            return results;
        }
 
        /// <devdoc>
        /// <para>Joins the specified string arrays.</para>
        /// </devdoc>
        protected static string JoinStringArray(string[] sa, string separator) {
            if (sa == null || sa.Length == 0)
                return String.Empty;
 
            if (sa.Length == 1) {
                return "\"" + sa[0] + "\"";
            }
 
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < sa.Length - 1; i++) {
                sb.Append("\"");
                sb.Append(sa[i]);
                sb.Append("\"");
                sb.Append(separator);
            }
            sb.Append("\"");
            sb.Append(sa[sa.Length - 1]);
            sb.Append("\"");
 
            return sb.ToString();
        }
 
        internal static Assembly LoadImageSkipIntegrityCheck(byte[] rawAssembly, byte[] rawSymbolStore, Evidence securityEvidence) {
            // Using reflection to avoid the need for a new public API.
            MethodInfo methodInfo = typeof(Assembly).GetMethod("LoadImageSkipIntegrityCheck", BindingFlags.NonPublic | BindingFlags.Static);
 
            // If running against old versions without the internal method, fallback to an older version that does not perform
            // the integrity check.
            Assembly result = methodInfo != null ?
                (Assembly)methodInfo.Invoke(null, new object[] { rawAssembly, rawSymbolStore, securityEvidence }) :
#pragma warning disable 618 // Load with evidence is obsolete - this warning is passed on via the options parameter
                Assembly.Load(rawAssembly, rawSymbolStore, securityEvidence);
#pragma warning restore 618
 
            return result;
        }
    }
}