trunk/TSAdminTool/ProSupport.cs


using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Globalization;
using System.Data;
using System.Security.AccessControl;
using System.Security.Principal;
using System.IO;
using System.Management;
using System.Net;
using log4net;

// Support class for the AnywhereTS version. This file should only be included in the Pro version.
namespace AnywhereTS
{
    public static class ProSupport
    {
        // File names
        public const string strHostsFilename = "hosts"; // The name of the thin clients host file.
        public const string strNetworkConfigFilename = "network"; // Name of the Thinstation common config file in the TFTP root directory.
        public const string strDatabaseFilename = "ats.mdf"; // Name of the AnywhereTS SQL express database file.
        public const string strDatabaseFilename2 = "ats_log.ldf"; // Name of the AnywhereTS SQL express database log file.

        // Registry keys
        public const string strRegTFTP_root = "TFTP_root"; // Reg key for TFTP root directory in database
        public const string strRegDatabaseDir = "DatabaseDir"; // Reg key for database directory
        public const string strRegAnywhereTSServer = "ATSServer"; // Reg key for database server
        public const string strRegDatabaseServer = "DatabaseServer"; // Reg key for database server
        public const string strRegDatabaseInstance = "DatabaseInstance"; // Reg key for database server
        public const string strRegDestDir = "DestDir"; // Reg key for Destination directory, used in unmanged mode..

        // Database constants
        public const string DEFAULT_RECORD_MAC = "Default     "; // Phony MAC address (12 chars) used to identify the client record that contains the default settings for all new clients

        // Database variables
        public static atsDataSetTableAdapters.ClientTableAdapter clientTableAdapter; // The AnywhereTS application data adapter for the clients table. Only this adapter should be used.
        public static atsDataSetTableAdapters.TftpServerTableAdapter tftpServerTableAdapter; // The AnywhereTS application data adapter for the TFTP servers table. Only this adapter should be used.
        public static atsDataSetTableAdapters.TerminalServerTableAdapter terminalServerTableAdapter; // The AnywhereTS application data adapter for the terminal servers table. Only this adapter should be used.
        public static atsDataSetTableAdapters.AppInfoTableAdapter appInfoTableAdapter; // The AnywhereTS application data adapter for the AppInfo table. Only this adapter should be used.

        public static string strAnywhereTSServer; // If this computer does not contain the database server, this is the name of the database server that contains the ATS database. Used by the Control Panel
        public static string strDatabaseServer; // If this computer does not contain the database server, this is the name of the database server that contains the ATS database. Used by the Control Panel
        public static string strDatabaseInstance; // If this computer does not contain the database server, this is the name of the database server that contains the ATS database. Used by the Control Panel

        // Directories
        //public static string strDatabasePath; // The directory where the database file is located.
        public static string strDestDir; // Destination directory for client files in unmanaged mode.

        // Constructor Initializes the global variables
        static ProSupport()
        {
           //  Initiate variables from registry
            strAnywhereTSServer = ATSGlobals.GetATSRegValueString(strRegAnywhereTSServer);
            //strDatabasePath = ATSGlobals.GetATSRegValueString(strRegDatabaseDir);
            strDestDir = ATSGlobals.GetATSRegValueString(strRegDestDir);
            strDatabaseServer = ATSGlobals.GetATSRegValueString(strRegDatabaseServer);
            strDatabaseInstance = ATSGlobals.GetATSRegValueString(strRegDatabaseInstance);
        }

        // Loook up local IP for computer 
        public static void ThisComputerIp (System.Windows.Forms.ComboBox combo, bool bolServerName)            
        {                
            ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");
                
            ManagementObjectCollection queryCollection = query.Get();
            combo.Items.Clear();
            if (bolServerName == true) //Add computer name
            {
                combo.Items.Add(Dns.GetHostName());
            }
            foreach (ManagementObject mo in queryCollection)                
            {                    
                string[] addresses = (string[])mo["IPAddress"];                    
                foreach (string ipaddress in addresses)                    
                {
                    if (ipaddress !="0.0.0.0")
                        combo.Items.Add(ipaddress);

                }                
            }
        }

        // Compate two DriveInfo arrays and return TRUE if they are equal.
        public static bool CompareDriveInfoArrays(List<DriveInfo> data1, List<DriveInfo> data2)
        {
            // If both are null, they're equal
            if (data1 == null && data2 == null)
            {
                return true;
            }
            // If either but not both are null, they're not equal
            if (data1 == null || data2 == null)
            {
                return false;
            }
            if (data1.Count != data2.Count)
            {
                return false;
            }
            for (int i = 0; i < data1.Count; i++)
            {
                if (data1[i].Name + data1[i].VolumeLabel != data2[i].Name + data2[i].VolumeLabel)
                {
                    return false;
                }
            }
            return true;
        }

        // Get an IP parameter (IP, netmask, gateway) from the local machine
        // Paramters:
        // Out: IP address in the format "x.x.x.x"
        // strNetworkConf = "IPAddress": Get IPAddress
        // strNetworkConf = "IPSubnet": Get netmask
        // strNetworkConf = "DefaultIPGateway": Get gateway
        // strNetworkConf = "Description": Get network card
        // strNetworkConf = "MACAddress": Get MAC address
        // strNetworkConf = "DNSServerSearchOrder": Get DNS
        public static string ThisComputerNetworkConf(string strNetworkConf)
        {
            ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");
            ManagementObjectCollection queryCollection = query.Get();
            foreach (ManagementObject mo in queryCollection)
            {
                string[] addresses = (string[])mo[strNetworkConf];
                return addresses[0];    
            }
            return ""; // No network adapter found.
        }

        // Initiate the database
        public static void InitDatabase()
        {
            //// Create and set the connection string
            //string dataServerName; // The name of the database server in the connection string
            //if (strDatabaseServer.Length != 0)
            //{   // We have a database server
            //    dataServerName = strDatabaseServer;
            //}
            //else
            //{   // We do not have an external, data server.
            //    dataServerName = ".";
            //}
            //Properties.Settings.Default["atsConnectionString"] = @"Data Source=" + dataServerName + @"\SQLEXPRESS;Database='AnywhereTS';Integrated Security=True;Connect Timeout=30;User Instance=False";
            //Properties.Settings.Default.Save();
            
            // Set up table adapters
            clientTableAdapter = new atsDataSetTableAdapters.ClientTableAdapter();
            tftpServerTableAdapter = new atsDataSetTableAdapters.TftpServerTableAdapter();
            terminalServerTableAdapter = new atsDataSetTableAdapters.TerminalServerTableAdapter();
            appInfoTableAdapter = new atsDataSetTableAdapters.AppInfoTableAdapter();
        }

        // Adds an ACL entry for RW access on the specified file for Remote desktop users.
        [Obsolete("GrantRWaccessForRemoteDesktopUsers has been deprecated - define user access rights via SQL Server")]
        public static void GrantRWaccessForRemoteDesktopUsers(string fileName)
        {
            // Get a FileSecurity object that represents the current security settings.
            FileSecurity fSecurity = File.GetAccessControl(fileName);

            // Add FileSystemAccessRule:s to the security settings.
            // Remote desktop users can read and write, but not delete
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.Read, AccessControlType.Allow));
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.Write, AccessControlType.Allow));

            // Set the new access settings.
            File.SetAccessControl(fileName, fSecurity);
        }

        // Adds an ACL entry for ReadWriteModify access on the specified file for Remote desktop users.
        [Obsolete("GrantRWMaccessForRemoteDesktopUsers has been deprecated - define user access rights via SQL Server")]
        public static void GrantRWMaccessForRemoteDesktopUsers(string fileName)
        {
            // Get a FileSecurity object that represents the current security settings.
            FileSecurity fSecurity = File.GetAccessControl(fileName);

            // Add FileSystemAccessRule:s to the security settings.
            // Remote desktop users can read and write, but not delete
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.Read, AccessControlType.Allow));
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.Write, AccessControlType.Allow));
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.Modify, AccessControlType.Allow));

            // Set the new access settings.
            File.SetAccessControl(fileName, fSecurity);
        }

        // (obsolete)
        // Adds an ACL entry for to deny modify access on the specified file for all users.
        [Obsolete("DenyAccessRightModifyForUsers has been deprecated - define user access rights via SQL Server")]
        public static void DenyAccessRightModifyForUsers(string fileName)
        {
            // Get a FileSecurity object that represents the current security settings.
            FileSecurity fSecurity = File.GetAccessControl(fileName);

            // Add FileSystemAccessRule:s to the security settings.
            // Remote desktop users can read and write, but not delete
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.Write, AccessControlType.Deny));
            fSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.Modify, AccessControlType.Deny));

            // Set the new access settings.
            File.SetAccessControl(fileName, fSecurity);
        }


        // Writes config files to all of the TFTP directories definied in registry and database,
        // and set rights.
        public static void WriteConfigFiles(ATSImageRuntimeConfig config, string fileName, bool setRights)
        {   // config: The config that should be written to disk
            // fileName: Name of the config file to write
            // setRights: True = Set access rights on the file, so that all remote desktop users can delete the file.
            // Write client config file

            if (ATSGlobals.tftpConfig == 0)
            { // Use ATS TFTP
                WriteConfigFile(config, ATSGlobals.strTFTPdir + @"\" + fileName, setRights);
            }
            else if (ATSGlobals.tftpConfig == 1)
            { // External TFTP
                // Write the config file to all TFTP directories
                atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
                atsDataSetTableAdapters.TftpServerTableAdapter tftpServerTableAdapter; // The AnywhereTS application data adapter for the TFTP servers table. Only this adapter should be used.

                tftpServerTableAdapter = new AnywhereTS.atsDataSetTableAdapters.TftpServerTableAdapter();
                datatableTFTP = new atsDataSet.TftpServerDataTable();

                tftpServerTableAdapter.Fill(datatableTFTP);
                foreach (DataRow row in datatableTFTP.Rows)
                {
                    WriteConfigFile(config, GetTftpPath(row) + @"\" + fileName, setRights);
                }
            }
            else
            {
                string error = "Error: Unknown TFTP Config mode (28158)";
                using (log4net.NDC.Push(string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)))
                {
                    Logging.ATSAdminLog.Error(error);
                }
                MessageBox.Show(string.Format("{0} -> {1}", error, string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)));
                return;
            }
        }

        // Copy image file to all external tftp directories/servers
        public static void CopyImageFile(string path, string sourceFileName, string destFileName)
        {
            atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
            datatableTFTP = new atsDataSet.TftpServerDataTable();
            atsDataSetTableAdapters.TftpServerTableAdapter tftpServerTableAdapter; // The AnywhereTS application data adapter for the TFTP servers table. Only this adapter should be used.
            tftpServerTableAdapter = new AnywhereTS.atsDataSetTableAdapters.TftpServerTableAdapter();

            tftpServerTableAdapter.Fill(datatableTFTP);
            foreach (DataRow row in datatableTFTP.Rows)
            {
                // Copy to the TFTP server
                try
                {
                    File.Copy(path + @"\" + sourceFileName, GetTftpPath(row) + @"\" + destFileName, true);
                }
                catch (Exception e)
                {
                    MessageBox.Show("Could not update TFTP server '" + GetTftpPath(row) + "' (22181). Error: " + e.Message);
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                    {
                        using (log4net.NDC.Push(string.Format("tftpPath={0}", GetTftpPath(row))))
                        {
                            Logging.ATSAdminLog.Error("Could not update TFTP server");
                        }
                    }
                }
            
                // Try to set rights for image the image file
                // (not implemented)
                /*
                try
                {
                    DenyAccessRightModifyForUsers(row["Path"].ToString() + @"\" + file);
                }    
                catch (Exception e)
                {
                    MessageBox.Show("Could not set rights for image file on TFTP server '" + row["Path"].ToString() + "' (22183). Error: " + e.Message);
                } */
            }
        }

        // Create subdirectory in all external tftp directories/servers
        public static void CreateDirectoryOnTFTP_servers(string directoryName)
        {
            atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
            datatableTFTP = new atsDataSet.TftpServerDataTable();
            atsDataSetTableAdapters.TftpServerTableAdapter tftpServerTableAdapter; // The AnywhereTS application data adapter for the TFTP servers table. Only this adapter should be used.
            tftpServerTableAdapter = new AnywhereTS.atsDataSetTableAdapters.TftpServerTableAdapter();

            tftpServerTableAdapter.Fill(datatableTFTP);
            foreach (DataRow row in datatableTFTP.Rows)
            {
                // Create the Directory on the TFTP server
                try
                {
                    Directory.CreateDirectory(GetTftpPath(row) + @"\" + directoryName);
                }
                catch (Exception e)
                {
                    MessageBox.Show("Could not update TFTP server '" + GetTftpPath(row) + "' (22381). Error: " + e.Message);
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                    {
                        using (log4net.NDC.Push(string.Format("tftpPath={0}", GetTftpPath(row))))
                        {
                            Logging.ATSAdminLog.Error("Could not update TFTP server");
                        }
                    }
                }
            }
        }

        public static void WriteConfigFile(ATSImageRuntimeConfig config, string path, bool setRights)
        {
            config.WriteConfigFile(path);

            if (setRights)
            {
                // Set access rights for the config file.
                try
                {
                    // Add an access control entry to the config file.
                    ProSupport.GrantRWMaccessForRemoteDesktopUsers(path);
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Cannot set access rights for client configuration. Application will abort. Error: " + ex.Message);
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", ex.Message, System.Environment.NewLine, ex.ToString())))
                    {
                        Logging.ATSAdminLog.Error("Cannot set access rights for client configuration");
                    }
                    Application.Exit();
                    return;
                }
            }
        }


        // Writes host files to all of the TFTP directories definied in registry and database.
        public static void WriteHostsFiles()
        {
            if (ATSGlobals.tftpConfig == 0)
            { // Use ATS TFTP
                WriteHostsFile(ATSGlobals.strTFTPdir + @"\" + strHostsFilename);
            }
            else if (ATSGlobals.tftpConfig == 1)
            { // External TFTP
                // Write the config file to all TFTP directories
                atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
                datatableTFTP = new atsDataSet.TftpServerDataTable();
                tftpServerTableAdapter.Fill(datatableTFTP);
                foreach (DataRow row in datatableTFTP.Rows)
                {
                    WriteHostsFile(GetTftpPath(row) + @"\" + strHostsFilename);
                }
            }
            else
            {
                string error = "Error: Unknown TFTP Config mode (48158)";
                using (log4net.NDC.Push(string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)))
                {
                    Logging.ATSAdminLog.Error(error);
                }
                MessageBox.Show(string.Format("{0} -> {1}", error, string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)));
                return;
            }
        }


        // Create a (new) encrypted hosts file from data in the database.
        private static void WriteHostsFile(string path)
        {
            atsDataSet datasetClient = new atsDataSet();
            ProSupport.clientTableAdapter.FillClients(datasetClient.Client);

            // System.IO.StreamWriter writer = null;
            CryptStream writer = null;

            // Delete old hosts file
            if (System.IO.File.Exists(path))
            {
                System.IO.File.Delete(path);
            }
            
            // Write a new hosts file.
            try
            {
                //writer = new System.IO.StreamWriter(path);
                writer = new CryptStream(path);
                writer.NewLine = "\n"; // Unix style line terminators
                writer.WriteLine("# This is a hosts file generated by AnywhereTS. Do not change.");
                foreach (DataRow row in datasetClient.Client.Rows)
                {
                    writer.WriteLine(row["ClientName"].ToString() + "  " + row["MacAddress"].ToString());
                }
                writer.WriteLine("# Detta e slutet."); // Termination string to avoid decryptation bug.
            }
            catch (Exception e)
            {
                //improve autoretry
                MessageBox.Show("Error: Could not write configuration data to disk. Possibly the data is being accessed by another component right now or you do not have the sufficient rights. Please retry this operation later (52044). Error details: " + e.Message);
                using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                {
                    using (log4net.NDC.Push(string.Format("path={0}", path)))
                    {
                        Logging.ATSAdminLog.Error("Could not write configuration data to disk");
                    }
                }
            }

            finally
            {
                if (writer != null)
                    writer.Close();
            }

            // DenyAccessRightModifyForUsers(path); // Prevent users from deleting or modifying the hosts file.
        }


        // Check if user is administrator
        // Returns true if user is administrator
        public static bool IsAnAdministrator()
        {
            WindowsIdentity identity =
               WindowsIdentity.GetCurrent();
            WindowsPrincipal principal =
               new WindowsPrincipal(identity);
            return principal.IsInRole
               (WindowsBuiltInRole.Administrator);
        }

        public static string GetMacAddressFromNameAndDatabase(string strName)
        {
            string macAddress;
            // Try to extract MAC address from client name.
            macAddress = ATSGlobals.GetMacFromATSname(strName);
            if (macAddress.Length == 0)
            {    // MAC not in name, try to lookup client name in database
                atsDataSet datasetClientName = new atsDataSet();
                // Update dataset with the client row matching the name
                try
                {
                    ProSupport.clientTableAdapter.FillOnName(datasetClientName.Client, strName);
                }
                catch 
                {   // Error when accessing database
                    return "";
                }
                if (datasetClientName.Client.Rows.Count > 0)
                {   // Client row found in database
                    macAddress = datasetClientName.Client.Rows[0]["MacAddress"].ToString();
                }
                else
                {   // Name not found
                    macAddress = "";
                }
            }
            return macAddress;
        }

        // Re-writes all config files, so that they will be containing new parameters.
        // Also creates config files if they have been deleted, i.e by an expired beta.
        public static void RecreateConfigFiles()
        {
            // Re-create all config files
            if (ATSGlobals.tftpConfig == 0)
            { // Use ATS TFTP
                WriteConfigFiles(ATSGlobals.strTFTPdir);
            }
            else if (ATSGlobals.tftpConfig == 1)
            { // External TFTP
                // Write the config file to all TFTP directories
                atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
                datatableTFTP = new atsDataSet.TftpServerDataTable();
                tftpServerTableAdapter.Fill(datatableTFTP);
                foreach (DataRow row in datatableTFTP.Rows)
                {
                    // Write to TFTP path
                    WriteConfigFiles(GetTftpPath(row));
                }
            }
            else
            {
                string error = "Error: Unknown TFTP Config mode (88158)";
                using (log4net.NDC.Push(string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)))
                {
                    Logging.ATSAdminLog.Error(error);
                }
                MessageBox.Show(string.Format("{0} -> {1}", error, string.Format("tftpConfig={0}", ATSGlobals.tftpConfig)));
                return;
            }

            WriteHostsFiles();
            ATSImageRuntimeConfig currentConfig = new ATSImageRuntimeConfig();
            currentConfig.ReadDefaultFromDatabase();
            ProSupport.WriteConfigFiles(currentConfig, ProSupport.strNetworkConfigFilename, false);
        }


        static void WriteConfigFiles(string strDirectory)
        {
            ATSImageRuntimeConfig currentConfig = new ATSImageRuntimeConfig();
            atsDataSet datasetClient = new atsDataSet();
            ProSupport.clientTableAdapter.FillClients(datasetClient.Client);
            string strFilePath;
            foreach (DataRow row in datasetClient.Client.Rows)
            {
                // Write the config file corresponding to the client
                currentConfig.ReadFromDatabase(row);
                strFilePath = strDirectory + @"\" + row["MacAddress"];
                currentConfig.WriteConfigFile(strFilePath);
            }
        }

        // Return a local or UNC path for TFTP server, depending on what it best.
        public static string GetTftpPath(DataRow tftpRow)
        {
            // Extract computer name from UNC Path
            string uncPath = tftpRow["Path"].ToString();
            string uncComputer = uncPath.Substring(2, uncPath.IndexOf(@"\", 2) - 2);
            if (uncComputer.ToUpper() == Environment.MachineName)
            {   // The UNC path resides on this computer, use a local path if it is available
                if (tftpRow["LocalPath"].ToString().Length > 0)
                { // We have a local path
                    return tftpRow["LocalPath"].ToString();
                }
                else
                {   // No local path, we have to go with the UNC path referring to the local machine.
                    return tftpRow["Path"].ToString();
                }
            }
            else
            {   // The UNC path does not reside on this computer, use it as it is.
                return tftpRow["Path"].ToString();
            }
        }


        // Sub routines used by wizard for screen resolution
        //-----------------------------------------------------

        public static void UpdateScreenResolutionControls(int x, int y, TextBox txtScreenResX, TextBox txtScreenResY, TrackBar tbrScreenResolution)
        {
            txtScreenResX.Text = x.ToString();
            txtScreenResY.Text = y.ToString();

            for (int i = 0; i < ATSGlobals.ScreenResolutions.GetLength(0); i++)
            {
                if (x == ATSGlobals.ScreenResolutions[i, 0] && y == ATSGlobals.ScreenResolutions[i, 1])
                {
                    tbrScreenResolution.Value = i + 1;
                    return;
                }

            }
            // Values could not be expressed using the track bar. Set it at default.
            tbrScreenResolution.Value = 4;
        }

        public static void GetScreenResolutionFromTrackbar(TrackBar tbr, out int x, out int y)
        {
            x = ATSGlobals.ScreenResolutions[tbr.Value - 1, 0];
            y = ATSGlobals.ScreenResolutions[tbr.Value - 1, 1];
        }

        public static void UpdateResolutionTrackbar(TextBox txtScreenResX, TextBox txtScreenResY, TrackBar tbrScreenResolution)
        { // Try to convert x, y values to trackbar.
            int x, y;
            try
            {
                x = Int32.Parse(txtScreenResX.Text.Trim());
            }
            catch (Exception)
            {
                x = 0;
            }

            try
            {
                y = Int32.Parse(txtScreenResY.Text.Trim());
            }
            catch (Exception)
            {
                y = 0;
            }

            UpdateScreenResolutionControls(x, y, txtScreenResX, txtScreenResY, tbrScreenResolution);
        }


            public static void copyDirectory(string Src,string Dst)
            {
            String[] Files;

            if(Dst[Dst.Length-1]!=Path.DirectorySeparatorChar) 
                Dst+=Path.DirectorySeparatorChar;
            if(!Directory.Exists(Dst)) Directory.CreateDirectory(Dst);
            Files=Directory.GetFileSystemEntries(Src);
            foreach(string Element in Files){
                // Sub directories

                if(Directory.Exists(Element)) 
                    copyDirectory(Element,Dst+Path.GetFileName(Element));
                // Files in directory

                else 
                    File.Copy(Element,Dst+Path.GetFileName(Element), true);
                }
            }

        
    } // end class Prosupport


    public class CryptStream : StreamWriter
    {
        BinaryWriter outStream;

        const byte offset1 = 36;
        const byte offset2 = 0xab;
        const byte key = 0x36;
        byte value;

        public CryptStream(string s)
            : base(s)
        {
            // Base constructor has created a stream. Steal it.
            outStream = new BinaryWriter(base.BaseStream);
            WriteHeader();
        }


        public CryptStream(Stream s)
            : base(s)
        {
            outStream = new BinaryWriter(s);
            WriteHeader();
        }


        private void WriteHeader()
        {
            outStream.Write((byte)0x41);
            outStream.Write((byte)0x54);
            outStream.Write((byte)0x53);
            outStream.Write((byte)0x78);
            value = key;
        }


        private byte Crypt(byte ch1)
        {
            byte ch2 = (byte)((ch1 + offset1) & 0xFF);
            byte ch3 = (byte)((ch2 ^ value) & 0xFF);
            value = (byte)((value + offset2) & 0xFF);
            return ch3;
        }

        public override void Write(string s)
        {
            for (int i = 0; i < s.Length; i++)
                outStream.Write(Crypt((byte)s[i]));
        }


        public override void WriteLine(string s)
        {
            Write(s);
            Write("\n");
        }
    }

} //end namespace
Revision:	123
Committed:	Sat Jul 14 11:14:09 2012 UTC (10 years, 10 months ago) by william
File size:	31794 byte(s)
Log Message:	+ bulk commit -- add SQLSerer SMO support for executing TSQL commands