trunk/TSAdminTool/frmConfigServices.cs

#define DISALLOW_SETTING_OF_TFTP_FOLDER_ACLS // when defined will not allow RDP only acl to be placed on TFTP folder
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Threading;

namespace AnywhereTS
{

    public partial class frmConfigServices : Form
    {
        public frmConfigServices()
        {
            InitializeComponent();
        }

        private atsDataSet.TftpServerDataTable datatableTFTP; // TFTP server directories
        private atsDataSet.TerminalServerDataTable datatableTerminalServer; // terminal servers
        const string strATSshareName = @"AnywhereTS$"; // The name of the AnywhereTS Win32 file share for the local TFTP server.
        const string strShareDesc = @"Used by AnywhereTS";
        private List<string> tftpUncPaths; // List with the corresponding UNC paths for items in lstTFTP.

        private void frmConfigureMode_Load(object sender, EventArgs e)
        {
            //this.Cursor = Cursors.WaitCursor;
            
            tftpUncPaths = new List<string>(); // Create a list for the TFTP UNC paths.

            // Setup database
            if (ProSupport.tftpServerTableAdapter == null || ProSupport.terminalServerTableAdapter == null) // Is database initiated?
            {
                // Databases is not initiated, do it now
                ProSupport.InitDatabase();
            }
            
            datatableTFTP = new atsDataSet.TftpServerDataTable();
            ProSupport.tftpServerTableAdapter.Fill(datatableTFTP);
            datatableTerminalServer = new atsDataSet.TerminalServerDataTable();
            ProSupport.terminalServerTableAdapter.Fill(datatableTerminalServer);

            if (ATSGlobals.configured == 0)
            {  // ATS not configured yet
                RadTSthisComputer.Checked = true;
                txtTFTPpath.Text = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + @"\AnywhereTS\TFTP";
                radTFTPinternal.Checked = true;
            }
            else 
            {   // ATS already configured.
                txtTFTPpath.Text = ATSGlobals.strTFTPdir;
                radTFTPinternal.Checked = (ATSGlobals.tftpConfig == 0);
                radTFTPexternal.Checked = (ATSGlobals.tftpConfig == 1);
                if (ATSGlobals.terminalServerConfig == 0)
                {   // This computer is terminal server

                    //if (datatableTerminalServer.Rows.Count == 0) //Any other terminal servers?
                    //{ // No other terminal servers
                    //    RadTSthisComputer.Checked = true;
                    //}
                    //else
                    //{   // At least one other
                    //    radTSboth.Checked = true;
                    //}
                    RadTSthisComputer.Checked = true;
                    radTSboth.Checked = false;
                    radTSother.Checked = false;
                }
                else if (ATSGlobals.terminalServerConfig == 1)
                {
                    RadTSthisComputer.Checked = false;
                    radTSboth.Checked = true;
                    radTSother.Checked = false;
                }
                else if (ATSGlobals.terminalServerConfig == 2)
                {
                    RadTSthisComputer.Checked = false;
                    radTSboth.Checked = false;
                    radTSother.Checked = true;
                }
                else
                {
                    string error = "Error: Undefined terminal servers config (42002)";
                    using (log4net.NDC.Push(string.Format("terminalServerConfig={0}", ATSGlobals.terminalServerConfig)))
                    {
                        Logging.ATSAdminLog.Error(error);
                    }
                    MessageBox.Show(string.Format("{0} -> {1}", error, string.Format("terminalServerConfig={0}", ATSGlobals.terminalServerConfig)));
                    return;
                }

            }


            // Update terminal server list
            UpdateTerminalServerList();

            // Update TFTP server directories list
            if (ATSGlobals.tftpConfig == 1)
            {
                UpdateTftpList();
            }

            helpProvider.HelpNamespace = ATSGlobals.strHelpFilePath;  // Initiate helpProvider

            UpdateControls();
            
            this.Cursor = Cursors.Default;
        }

      
        private void btnOK_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;
            
            if (RadTSthisComputer.Checked)
                ATSGlobals.terminalServerConfig = 0;
            else if (radTSboth.Checked)
                ATSGlobals.terminalServerConfig = 1;
            else if (radTSother.Checked)
                ATSGlobals.terminalServerConfig = 2;
            else
            {
                string error = "Error: Undefined terminal servers config (42001)";
                using (log4net.NDC.Push(string.Format("terminalServerConfig={0}", ATSGlobals.terminalServerConfig)))
                {
                    Logging.ATSAdminLog.Error(error);
                }
                MessageBox.Show(string.Format("{0} -> {1}", error, string.Format("terminalServerConfig={0}", ATSGlobals.terminalServerConfig)));
                return;
            }
            ATSGlobals.SetATSRegValue(ATSGlobals.strRegTerminalServer, ATSGlobals.terminalServerConfig);

           
            string strPath; // The TFTP path
            strPath = txtTFTPpath.Text.Trim();

            if (radTFTPinternal.Checked)
            {   // We are using the internal TFTP
                ATSGlobals.tftpConfig = 0; // Use ATS TFTP
                // Validate TFTP directory
                if (strPath.Length == 0)
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("You must specifiy a directory for the AnywhereTS shared network files.");
                    txtTFTPpath.Focus();
                    return;
                }

                if (strPath.StartsWith(".") || strPath.StartsWith(@"\"))
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("Invalid path for the AnywhereTS shared network files.");
                    using (log4net.NDC.Push(string.Format("path={0}", strPath)))
                    {
                        Logging.ATSAdminLog.Error("Invalid path for the AnywhereTS shared network files.");
                    }
                    txtTFTPpath.Focus();
                    return;
                }

                // Create TFTP directory
                try
                {
                    Directory.CreateDirectory(strPath);
                }
                catch (Exception ex)
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("Could not create directory '" + strPath + "'. Error: " + ex.Message);
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", ex.Message, System.Environment.NewLine, ex.ToString())))
                    {
                        using (log4net.NDC.Push(string.Format("directory={0}", strPath)))
                        {
                            Logging.ATSAdminLog.Error("Could not create directory.");
                        }
                    }
                    txtTFTPpath.Select();
                    return;
                }

                // Check that the directory is local
                ShareUtil shUtil = new ShareUtil(); // Create a util class
                if (shUtil.IsNetworkPath(strPath))
                {   // The path is a network path
                    MessageBox.Show("A network path cannot be used for the local TFTP server. Please enter a local path.");
                    txtTFTPpath.Select();
                    return;
                }
                // Save the TFTP directory to registry
                ATSGlobals.strTFTPdir = strPath; // Set the C# version of TFTP dir
                Globals.strTFTPdir = strPath; // Set the VB version of TFTP dir
                ATSGlobals.SetATSRegValue(ATSGlobals.strRegTFTP_root, ATSGlobals.strTFTPdir);

                // Delete all TFTP roots from database
                foreach (DataRow row in datatableTFTP.Rows)
                {
                    row.Delete();
                }
                ProSupport.tftpServerTableAdapter.Update(datatableTFTP);

                if (!RadTSthisComputer.Checked)
                {   // There are external terminal servers.

                    // Create a share, save the UNC path to the database, add rights to TFTP directory
                    AddTFTPpath(ATSGlobals.strTFTPdir);
                }
                else
                {   // We are only using this computer as terminal server
                    SetTFTPrights(ATSGlobals.strTFTPdir);
                }
            }
            else
            {
                // Use other TFTP
                ATSGlobals.tftpConfig = 1; // Use other TFTP

                if (lstTFTP.Items.Count == 0)
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("You must choose at least one TFTP server root directory, where AnywhereTS can place client images and configurations.");
                    btnAddTFTPpath.Focus();
                    return;
                }
            }

            // Check if we are using external terminal servers
            if (RadTSthisComputer.Checked)
            {   // Only this computer is a terminal server. Delete all other terminal servers.
                foreach (DataRow row in datatableTerminalServer.Rows)
                {
                    row.Delete();
                }
                ProSupport.terminalServerTableAdapter.Update(datatableTerminalServer);
            }
            else
            {   // We have external terminal servers
                if (lstTerminalServer.Items.Count == 0)
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("You must specify at least one Terminal Server!");
                    btnAddTerminalServer.Focus();
                    return;
                }

                // Close database connections
                datatableTFTP.Dispose();
                datatableTerminalServer.Dispose();
                ProSupport.clientTableAdapter.Connection.Close();
                ProSupport.terminalServerTableAdapter.Connection.Close();
                ProSupport.clientTableAdapter.Dispose();
                ProSupport.terminalServerTableAdapter.Dispose();

                // Configure SQL browser service (needed for the control panel to be able to access the database).

                bool sqlServerRestarted = DatabaseSupport.EnableNamedPipes(); // Enable named pipes in the SQL server
                DatabaseSupport.AutostartSQLbrowserService(); // Configure the SQL Browser service to autostart.
                DatabaseSupport.StartSQLbrowserService(); // Start the SQL Browser service

                if (sqlServerRestarted)
                {
                    // SQL server was restarted. Try to reconnect to database in order to repair the database connectivity
                    ProSupport.InitDatabase();

                    try
                    {
                        datatableTFTP = new atsDataSet.TftpServerDataTable();
                        ProSupport.tftpServerTableAdapter.Fill(datatableTFTP); // This operation causes an error and forces the connectivity to recover.
                    }
                    catch
                    {   // Do nothing, just catch the error that will most likely occur here.
                    }
                    finally
                    {
                        System.Threading.Thread.Sleep(5000); // Wait for the SQL connection to recover.
                    }
                }
            }

            // Save DHCP options
            if (radAtsDhcp.Checked)
            {
                ATSGlobals.dhcpConfig = 0; // Use the internal DCHP server
            }
            else
            {
                ATSGlobals.dhcpConfig = 1; // Use the other DCHP server          
            }

            // Save TFTP configuration to registry
            ATSGlobals.SetATSRegValue(ATSGlobals.strRegTFTPconfig,ATSGlobals.tftpConfig);

            // Save DCHP configuration to registry
            ATSGlobals.SetATSRegValue(ATSGlobals.strRegDHCPconfig, ATSGlobals.dhcpConfig);

            // Terminate window
            this.Cursor = Cursors.Default;
            DialogResult = DialogResult.OK;
        }


        private void AddTFTPpath(string strPath)
        {
            string uncPath; // The path in UNC format
            string strLocalPath = ""; // Local path to save in database for display purposes. Only set if path is local

            ShareUtil shUtil = new ShareUtil(); // Create a util class

            // Check if path is a network path
            if (shUtil.IsNetworkPath(strPath))
            {   // The path is a network path
                if (strPath.StartsWith("\\"))
                {   // The network path is a UNC path, no need to convert it                  
                    uncPath = strPath;
                }
                else
                {   // The network path is not a UNC path, convert it                  
                    uncPath = UNCconverter.ConvertLocalPathToUnc(strPath);
                }
            }
            else
            {   // User is adding a local path
                strLocalPath = strPath;
                string strThisComputer = Environment.MachineName; // The name of this computer
                // Compile the UNC path
                uncPath = @"\\" + strThisComputer + @"\" + strATSshareName;

                // Delete ATS share if it exists
                shUtil.DeleteShare(strATSshareName);

                // Delete share from database if it exists
                ProSupport.tftpServerTableAdapter.Fill(datatableTFTP); // Refresh data table
                DataRow rowToDelete;
                rowToDelete = datatableTFTP.Rows.Find(uncPath);
                if (rowToDelete != null)
                {   // The local TFTP path exists in database, delete it
                    rowToDelete.Delete();
                    ProSupport.tftpServerTableAdapter.Update(datatableTFTP);
                }

                // Create network share
                
                uint nRetVal;
                nRetVal = shUtil.CreateShare(strShareDesc, strATSshareName, strPath);
                if (nRetVal == 0)
                {
                    // Share created
                }
                else
                {
                    // Error
                    MessageBox.Show("Could not create a share for the AnywereTS TFTP data. Do you have sufficient rights? (25322)");
                    return;
                }

            }

            // Add the remote or local directory path to the database
            if (uncPath.Length <= 255)
            {   // The path will fit in the database
                atsDataSet.TftpServerRow row = (atsDataSet.TftpServerRow)datatableTFTP.NewRow();
                row["Path"] = uncPath;
                row["LocalPath"] = strLocalPath;

                try
                {
                    datatableTFTP.AddTftpServerRow(row);
                }
                catch (ConstraintException)
                {
                    MessageBox.Show("'" + uncPath + "' is already in the list.");
                    return;
                }

                ProSupport.tftpServerTableAdapter.Update(datatableTFTP);

                // Ask if we are going to add righs to the TFTP root directory, set rights.
                SetTFTPrights(row["Path"].ToString());
                UpdateTftpList(); // Update the list box
                lstTFTP.Select();
            }
            else
            {   // Path is too long
                MessageBox.Show("The directory path is too long, please use a path that is max 255 character");
            }
        
        }

        private void radAtsDhcp_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls(); // Set text "Next >" or "Finish" on the Ok button
        }

        private void radExternalDhcp_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls(); // Set text "Next >" or "Finish" on the Ok button
        }

        private void UpdateControls()
        {
            if (RadTSthisComputer.Checked)
            { // Only this computer as terminal server
                lblTerminalServers.Enabled = false;
                lstTerminalServer.Enabled = false;
                btnAddTerminalServer.Enabled = false;
                btnDeleteTerminalServer.Enabled = false;
            }
            else
            {   // Other terminal servers
                lblTerminalServers.Enabled = true;
                lstTerminalServer.Enabled = true;
                btnAddTerminalServer.Enabled = true;
                if (lstTerminalServer.SelectedIndex == -1)
                    btnDeleteTerminalServer.Enabled = false;
                else
                    btnDeleteTerminalServer.Enabled = true;
            }

            if (radTFTPinternal.Checked)
            {
                lblTFTPpath.Enabled = true;
                txtTFTPpath.Enabled = true;
                btnBrowseTFTP.Enabled = true;
                lblTFTPdirectories.Enabled = false;
                lstTFTP.Enabled = false;
                btnAddTFTPpath.Enabled = false;
                btnDeleteTFTP.Enabled = false;
                radAtsDhcp.Enabled = true;
                lstTFTP.SelectedIndex = -1;
                btnOK.Text = "Next >";
            }
            else
            {
                lblTFTPdirectories.Enabled = true;
                lstTFTP.Enabled = true;
                btnAddTFTPpath.Enabled = true;
                if (lstTFTP.SelectedIndex == -1)
                    btnDeleteTFTP.Enabled = false;
                else
                    btnDeleteTFTP.Enabled = true;
                lblTFTPpath.Enabled = false;
                txtTFTPpath.Enabled = false;
                btnBrowseTFTP.Enabled = false;
                btnOK.Text = "Finish";
                radAtsDhcp.Enabled = false;
                radExternalDhcp.Checked = true;
            }
        }

        private void radTFTPinternal_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls();
        }

        private void radTFTPexternal_CheckedChanged(object sender, EventArgs e)
        {
            if (radTFTPexternal.Checked && ATSGlobals.tftpConfig == 0)
            {   // We have just de-selected internal TFTP server

                // Delete all TFTP roots from database
                foreach (DataRow row in datatableTFTP.Rows)
                {
                    row.Delete();
                }
                ProSupport.tftpServerTableAdapter.Update(datatableTFTP);
                UpdateTftpList();

                // Delete the file share for the internal TFTP directory if it exists.
                ShareUtil shUtil = new ShareUtil(); // Create a util class
                shUtil.DeleteShare("AnywhereTS$");

                // ATS is now in a non configured state
                ATSGlobals.configured = 0;
                ATSGlobals.SetATSRegValue(ATSGlobals.strRegConfigured, ATSGlobals.configured);
            }
            UpdateControls();
        }

        // Update the list with TFTP directories from database.
        private void UpdateTftpList()
        {
            lstTFTP.Items.Clear();
            tftpUncPaths.Clear();
            ProSupport.tftpServerTableAdapter.Fill(datatableTFTP); 
            foreach (DataRow row in datatableTFTP.Rows)
            {   // Display local path if possible
                
                
                lstTFTP.Items.Add(ProSupport.GetTftpPath(row));
                //string gg = row["Path"].ToString();
                //tftpUncPaths.Add(gg);
                tftpUncPaths.Add(row["Path"].ToString()); // Add the UNC path to the list.
            }
            btnDeleteTFTP.Enabled = false;
        }

        // Update the list with terminal servers from database.
        private void UpdateTerminalServerList()
        {
            lstTerminalServer.Items.Clear();
            foreach (DataRow row in datatableTerminalServer.Rows)
            {
                lstTerminalServer.Items.Add(row["Path"].ToString());
            }
            btnDeleteTerminalServer.Enabled = false;
        }

        private void lstTFTP_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lstTFTP.SelectedIndex == -1)
            {   // No item selcted in the TFTP directory list
                btnDeleteTFTP.Enabled = false;
            }
            else
            {   // User has selcted an item in the list
                btnDeleteTFTP.Enabled = true;
            }
        }

        // Delete the row selected in the TFTP directory list box.
        private void btnDeleteTFTP_Click(object sender, EventArgs e)
        {
            DataRow rowToDelete;
            rowToDelete = datatableTFTP.Rows.Find(tftpUncPaths[lstTFTP.SelectedIndex]);
            rowToDelete.Delete();
            ProSupport.tftpServerTableAdapter.Update(datatableTFTP);
            UpdateTftpList(); // Update the list box

            if (datatableTFTP.Rows.Count == 0)
            { // Last row deleted
                // ATS is now in a non configured state
                ATSGlobals.configured = 0;
                ATSGlobals.SetATSRegValue(ATSGlobals.strRegConfigured, ATSGlobals.configured);
            }
        }

         // Set user rights to TFTP directory, all remote desktop users should be able to write files.
        void SetTFTPrights(string path)
        {
#if DISALLOW_SETTING_OF_TFTP_FOLDER_ACLS
            return;
#else
            // Ask if we are going to add righs to the TFTP root directory
            DialogResult resultRights;
            resultRights = MessageBox.Show(this, "In order for users to use the AnywhereTS control panel, they need rights to write in the TFTP root directory. Do you want AnywhereTS to add these rights now?", "AnywhereTS", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
            if (resultRights == DialogResult.Yes)
            {
                try
                {
                    // Create a new DirectoryInfo object.
                    DirectoryInfo dInfo = new DirectoryInfo(path);
                    // Get a DirectorySecurity object that represents the 
                    // current security settings.
                    DirectorySecurity dSecurity = dInfo.GetAccessControl();
                    // Add a FileSystemAccessRule to the security settings, to allow write.
                    // No general rights to delete files. These rights are set on the individual files.
                    dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinRemoteDesktopUsersSid, null), FileSystemRights.WriteData, AccessControlType.Allow));
                    // Set the new access settings.
                    dInfo.SetAccessControl(dSecurity);
                }
                catch (Exception ex)
                {
                    this.Cursor = Cursors.Default;
                    MessageBox.Show("Could not set user access rights for TFTP directory. Do you have sufficient right? (29991). 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("Could not set user access rights for TFTP directory.");                      
                    }
                    return;
                }
            }
#endif
        }

        private void btnDeleteTerminalServer_Click(object sender, EventArgs e)
        {
            DataRow rowToDelete;
            rowToDelete = datatableTerminalServer.Rows.Find(lstTerminalServer.SelectedItem);
            rowToDelete.Delete();
            ProSupport.terminalServerTableAdapter.Update(datatableTerminalServer);
            UpdateTerminalServerList(); // Update the list box
        }

        private void btnAddTerminalServer_Click(object sender, EventArgs e)
        {
            // Show dialog
            frmAddTerminalServer addTSdialog = new frmAddTerminalServer();
            DialogResult result = addTSdialog.ShowDialog();
            if (result == DialogResult.OK)
            {
                // Add the server to the database
                if (addTSdialog.inputstring.Trim().Length <= 255)
                {   // The path will fit in the database
                    atsDataSet.TerminalServerRow row = (atsDataSet.TerminalServerRow)datatableTerminalServer.NewRow();
                    row["Path"] = addTSdialog.inputstring.Trim();
                    try
                    {
                        datatableTerminalServer.AddTerminalServerRow(row);
                    }
                    catch (ConstraintException)
                    {
                        MessageBox.Show("'" + row["Path"] + "' is already in the list.");
                        return;
                    }

                    ProSupport.terminalServerTableAdapter.Update(datatableTerminalServer);

                    UpdateTerminalServerList(); // Update the list box
                    lstTerminalServer.Select();
                }
                else
                {   // Path is too long
                    MessageBox.Show("The server path is too long, please use a path that is max 255 character");
                }
            }
        }

        private void lstTerminalServer_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lstTerminalServer.SelectedIndex == -1)
            {   // No item selcted in the TFTP directory list
                btnDeleteTerminalServer.Enabled = false;
            }
            else
            {   // User has selcted an item in the list
                btnDeleteTerminalServer.Enabled = true;
            }
        }

        private void RadTSthisComputer_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls();
        }

        private void radTSother_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls();
        }

        private void radTSboth_CheckedChanged(object sender, EventArgs e)
        {
            UpdateControls();
        }

        // Add a TFTP server
        private void btnAddTFTPpath_Click(object sender, EventArgs e)
        {       
            // Show dialog
            frmAddTFTP addTFTPdialog = new frmAddTFTP();
            DialogResult result = addTFTPdialog.ShowDialog();
            if (result == DialogResult.OK)
            { 
                string strPath;
                strPath = addTFTPdialog.inputstring.Trim();

                if (Directory.Exists(strPath))
                {
                    // Convert to UNC, share local directory, add directory to database
                    AddTFTPpath(strPath);
                }
                else
                {
                    MessageBox.Show("Error: Cannot find or access the directory. Please check name and rights. (34212)");
                }
                UpdateTftpList();
            }
        }
        string tftp_path = string.Empty;
        private void btnBrowseTFTP_Click(object sender, EventArgs e)
        {
            var t = new Thread(new ThreadStart(CreateFolderBrowser));
            t.IsBackground = true;
            t.SetApartmentState(ApartmentState.STA);
            t.Start();
            while (t.IsAlive) { Application.DoEvents(); }
            txtTFTPpath.Text = tftp_path;
            txtTFTPpath.Select();
        }
        private void CreateFolderBrowser()
        {
            folderBrowserDialog = new FolderBrowserDialog();
            folderBrowserDialog.RootFolder = Environment.SpecialFolder.MyComputer;
            DialogResult result = folderBrowserDialog.ShowDialog();
            if (result != DialogResult.OK) return;
            tftp_path = folderBrowserDialog.SelectedPath.Trim();
        }
    }
}
 