trunk/TSAdminTool/Image.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.CodeDom.Compiler;
using System.Windows.Forms;
using System.Diagnostics;
using log4net;

namespace AnywhereTS
{
    // Represents an ATS image to be used by thin clients
    // Currrently only configuration data is stored and some configuration data is not included.
    public class ATSImage
    {
        // Configuration data that can be changed runtime, after the client has booted
        public ATSImageRuntimeConfig RuntimeConfig;
        public ATSImageDesigntimeConfig DesigntimeConfig;
        public TempFileCollection objTempdir;  //      Temp file collection, to be deleted afterwards


        // Configuration data that can only be changed designtime, before the client has booted


        // Constructor
        public ATSImage()
        {   // Create the two types of configurations
            RuntimeConfig = new ATSImageRuntimeConfig();
            DesigntimeConfig = new ATSImageDesigntimeConfig();
            objTempdir = new TempFileCollection();
            if (!Directory.Exists(objTempdir.BasePath))
            {
                Directory.CreateDirectory(objTempdir.BasePath);
            }
        }


        public bool WriteDesigntimeConfigFile(string pathfile)
        {
            System.IO.StreamWriter writer = null;
            bool result = false; // Assume we have a problem.

            // Write a designtime new client config file.
            try
            {
                writer = new StreamWriter(pathfile);
                writer.NewLine = "\n"; // Unix style line terminators
                writer.WriteLine("# This is a client file generated by AnywhereTS. Do not change.");
                DesigntimeConfig.WriteParameters(writer);
                RuntimeConfig.WriteParameters(writer);
                result = true; // It went ok.                
            }
            finally
            {
                writer.Close();

            }
            return result;
        }

        public void ReadDefaultFromDatabase()
        {
            RuntimeConfig.ReadDefaultFromDatabase();
            DesigntimeConfig.ReadDefaultFromDatabase();
        }

        public void WriteDefaultToDatabase()
        {
            RuntimeConfig.WriteDefaultsToDatabase();
            DesigntimeConfig.WriteDefaultsToDatabase();
        }

        // Reset all properties that to the state they should have in a non-licensed version of ATS.
        // This is useful when switching from the Pro version to a free version image, to make
        // sure no pro features remain enabled.
        public void ResetProProperties()
        {
            RuntimeConfig.ResetProProperties();
        }


        public void Make()
        {
            TempFileCollection objTempRoot = new TempFileCollection();        //Temp file collection, to be deleted afterwards

            // Clean temp collection, as there might be files here from previous runs
            // Needed when going back in wizard and rebuild
            if (objTempdir.Count > 0)
            {
                objTempdir.Delete();
            }

            string strBase;
            strBase = objTempRoot.BasePath;

            try
            {
                objTempRoot.AddFile(strBase + @"\defaults", false);
            }
            catch { }

            // Create tree with selected drivers
            CopyGraphicsDrv(objTempRoot);
            CopyNetworkDrv(objTempRoot);
            CopySoundDrv(objTempRoot);

            // Copy the resolution support file
            File.Copy(DesigntimeConfig.DataDirectory + @"\modelines", strBase + @"\modelines", true);

            try
            {
                WriteDesigntimeConfigFile(strBase + @"\defaults");
            }
            catch (Exception e)
            {
                MessageBox.Show("Error: Could not write configuration to disk (67732). Do you have sufficient rights? Error:" + e.Message);
                using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                {
                    Logging.ATSAdminLog.Error("Could not write configuration to disk (67732)");
                }
            }

            // Save designtime parameters to database, so they will be remembered to next time
            DesigntimeConfig.WriteDefaultsToDatabase();

            // Save defaults to database, so they can be used by new clients
           
            // If client is managed or there is no server in default settings, then update default settings
            ATSImageRuntimeConfig defaultRuntimeConfig = new ATSImageRuntimeConfig();
            defaultRuntimeConfig.ReadDefaultFromDatabase();
            if (defaultRuntimeConfig.ServerName == "" //  There is no server name in default config, update default record.
                || DesigntimeConfig.ConfigFile) // Client is managed, update default record
            {   
                RuntimeConfig.WriteDefaultsToDatabase();
                ProSupport.WriteConfigFiles(RuntimeConfig, "network", true);
            }

            string strRoot = objTempRoot.BasePath;

            CreateInitrd(strRoot);
            objTempRoot.Delete();

        }

        private void CopyGraphicsDrv(TempFileCollection objTempRoot)
        {
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            string strDriverDestDir; // The destination directory for all drivers
            strDriverDestDir = objTempRoot.BasePath + @"\x11_drv";

            if (DesigntimeConfig.GraphicsDriver == "")
            {   // Driver autodetect selected
                // Copy all graphics driver files 
                Directory.CreateDirectory(strDriverDestDir);
                CopyAllFiles(DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedGraphicsAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);
            }
            else
            {   // Specific driver selected
                // Copy only the files for the selected graphics adapter
                Directory.CreateDirectory(strDriverDestDir);
                CopyFiles(DesigntimeConfig.GraphicsDriver, DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedGraphicsAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);
            }
        }


        private void CopySoundDrv(TempFileCollection objTempRoot)
        {
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            string strDriverDestDir; // The destination directory for all drivers
            strDriverDestDir = objTempRoot.BasePath + @"\drivers";

            if (DesigntimeConfig.SoundType == ATSImageDesigntimeConfig.ATSSoundType.ATSAutodetect)
            {
                // Autodetect sound driver selected
                // Copy all sound driver files 
                Directory.CreateDirectory(strDriverDestDir);
                CopyAllFiles(DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedSoundAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);

            }
            else if (DesigntimeConfig.SoundType == ATSImageDesigntimeConfig.ATSSoundType.ATSSelectedDriver)
            {
                // Specific sound driver selected, copy only the files for the selected sound adapter
                Directory.CreateDirectory(strDriverDestDir);
                CopyFiles(DesigntimeConfig.SoundDriver, DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedSoundAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);
            }
            else
            {
                //  No sound
            }
        }

        private void CopyNetworkDrv(TempFileCollection objTempRoot)
        {
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            string strDriverDestDir; // The destination directory for all drivers
            strDriverDestDir = objTempRoot.BasePath + @"\drivers";

            if (DesigntimeConfig.NetworkDriver == "")
            {   // Autodetect network driver selected
                // Copy all network driver files 
                Directory.CreateDirectory(strDriverDestDir);
                CopyAllFiles(DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedNicAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);
            }
            else
            {   // One network driver selcted, copy only the files for the selected network adapter
                Directory.CreateDirectory(strDriverDestDir);
                CopyFiles(DesigntimeConfig.NetworkDriver, DesigntimeConfig.DataDirectory + @"\" + ATSGlobals.SelectedNicAdaptersFile, DesigntimeConfig.DataDirectory, strDriverDestDir, objTempRoot);
            }
        }


        // Copies all files specified in strFile from strSourcePath to strDestPath.
        // The first paramter on each line is skipped the following parameters on the line is iterpreted as file names
        private void CopyAllFiles(string strFile, string strSourcePath, string strDestPath, TempFileCollection objTempRoot)
        {
            using (Microsoft.VisualBasic.FileIO.TextFieldParser MyReader = new Microsoft.VisualBasic.FileIO.TextFieldParser(strFile))
            {
                MyReader.TextFieldType = Microsoft.VisualBasic.FileIO.FieldType.Delimited;
                MyReader.SetDelimiters(";");
                string[] currentRow;
                while (!MyReader.EndOfData)
                {
                    try
                    {
                        currentRow = MyReader.ReadFields();
                        for (int i = 2; i <= currentRow.GetUpperBound(0); i++)
                        {
                            if (!File.Exists(strDestPath + @"\" + currentRow[i]))
                            {
                                File.Copy(strSourcePath + @"\" + currentRow[i], strDestPath + @"\" + currentRow[i], true);
                                try
                                {
                                    objTempRoot.AddFile(strDestPath + @"\" + currentRow[i], false);
                                }
                                catch { }
                            }
                        }
                    }
                    catch (Microsoft.VisualBasic.FileIO.MalformedLineException ex)
                    {
                        MessageBox.Show("Error in file " + strFile + ", line: '" + ex.Message + "'is not valid and will be skipped (77224).");
                        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("file={0} line={1}", strFile, ex.Message)))
                            {
                                Logging.ATSAdminLog.Error("Encountered invalid file");
                            }
                        }
                    }
                } // While
            } // using
        } // CopyAllFiles


        // Does a look-up in the file strFile on the line numbered by intIndex (zero based), then skips the first parameter on the line,
        // and interprets all the following parameters on the row as files to be copied from strSourcePath to strDestPath
        private void CopyFiles(string strDriver, string strFile, string strSourcePath, string strDestPath, TempFileCollection objTempRoot)
        {
            using (Microsoft.VisualBasic.FileIO.TextFieldParser MyReader = new Microsoft.VisualBasic.FileIO.TextFieldParser(strFile))
            {
                MyReader.TextFieldType = Microsoft.VisualBasic.FileIO.FieldType.Delimited;
                MyReader.SetDelimiters(";");
                string[] currentRow;
                currentRow = new string[2];
                currentRow[1] = "";
                // Read rows until we found the row
                while (!MyReader.EndOfData && currentRow[1] != strDriver)
                {
                    try
                    {
                        currentRow = MyReader.ReadFields();

                    }
                    catch (Microsoft.VisualBasic.FileIO.MalformedLineException ex)
                    {
                        MessageBox.Show("Error in file " + strFile + ", line: '" + ex.Message + "'is not valid and will be skipped.");
                        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("file={0} line={1}", strFile, ex.Message)))
                            {
                                Logging.ATSAdminLog.Error("Encountered invalid file");
                            }
                        }
                    }
                } // While
                // We have found the right row
                for (int i = 2; i <= currentRow.GetUpperBound(0); i++)
                {
                    File.Copy(strSourcePath + @"\" + currentRow[i], strDestPath + @"\" + currentRow[i], true);
                    try
                    {
                        objTempRoot.AddFile(strDestPath + @"\" + currentRow[i], false);
                    }
                    catch { }
                }
            } // using
        } // CopyFiles

        public string KernelAppendString()
        {
            string strString;

            strString = "initrd=initrd load_ramdisk=1 ramdisk_blocksize=4096 console=ttyS3 root=/dev/ram0 ramdisk_size=262144";

            // color  depth     | 640x480  800x600  1024x768 1280x1024
            // 256        (8bit)|  769      771       773      775
            // 32000     (15bit)|  784      787       790      793
            // 65000     (16bit)|  785      788       791      794
            // 16.7 Mil. (24bit)|  786      789       792      795

            if ((DesigntimeConfig.BootPicture.Type == 1) || (DesigntimeConfig.BootPicture.Type > 10))
            {   // BootImage selected

                strString = strString + " splash=silent";
                switch (DesigntimeConfig.BootPicture.Width)
                {
                    case 640:
                        strString += " vga=785"; // 640x480
                        break;
                    case 800:
                        strString += " vga=788"; // 800x600 
                        break;
                    case 1024:
                        strString += " vga=791"; // 1024x768
                        break;
                    case 1280:
                        strString += " vga=794"; // 1280x1024
                        break;
                    default:
                        MessageBox.Show("ERROR unknown boot picture resolution (49488)");
                        strString += " vga=791"; // Default to 1024x768

                        using (log4net.NDC.Push(string.Format("width=", DesigntimeConfig.BootPicture.Width)))
                            {
                                Logging.ATSAdminLog.Error("ERROR unknown boot picture resolution (49488)");
                            }
                        
                        break;
                }
            }
            return strString;
        }

        // Create an ISO file containing a bootable client
        public void CreateClientISO()
        {
            CreateISO(objTempdir.BasePath + @"\initrd");
        }

        public void CreateISO(string pathInitrd)
        {   // pathInitrd = Path to the initrd file that should be put on the CD
            string strCDroot = objTempdir.BasePath + @"\cd";
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            CreateClientRoot(pathInitrd, strCDroot);
            
            // Lauch mkisofs.exe to create the ISO
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\mkisofs\mkisofs.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.StartInfo.Arguments = @" -o " + @"""" + objTempdir.BasePath + @"\client.iso""" + " -b isolinux.bin -f -c boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table " + @"""" + strCDroot + @"""";
            p.Start();
            p.WaitForExit();
            try
            {
                objTempdir.AddFile(objTempdir.BasePath + @"\client.iso", false);
            }
            catch {}
        }

        public void CreateEtherboot()
        {
            string strBase;

            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            strBase = objTempdir.BasePath;

            // Launch wraplinux.exe to create the etherboot image
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\tools\wraplinux.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.StartInfo.Arguments = @"-p " + @"""" + KernelAppendString() + @"""" + @" -i " + @"""" + strBase + @"\initrd" + @"""" + @" -N -o " + @"""" + strBase + @"\client" + @"""" + " " + @"""" + DesigntimeConfig.DataDirectory + @"\vmlinuz" + @"""";
            p.Start();
            p.WaitForExit();
            if (!File.Exists(strBase + @"\client"))
            {
                MessageBox.Show("Internal error: Failed to create Network Boot Image. Aborting (22399).", "AnywhereTS", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);

                using (log4net.NDC.Push(string.Format("image=", strBase + @"\client")))
                    {
                        Logging.ATSAdminLog.Error("Failed to create Network Boot Image.");
                    }
                
                Application.Exit();
            }
            try
            {
                objTempdir.AddFile(strBase + @"\client", false);
            }
            catch { }
        }


        // Create client root
        // Creates a directory containing a client, made from an initrd file.
        // This directory can be put on CD, Hard disk or USB.
        // All that is then needed is a booter, that varies with the media
        // IN pathIntird: Path to the Initrd file that contains the client
        // IN strClientDirectory: Path to the directory where the client will be put. If not existing, directory will be created.
        public void CreateClientRoot (string pathInitrd, string strClientDirectory)
        {   // pathInitrd = Path to the initrd file that should be put on the CD
            string strBase;
            
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            strBase = objTempdir.BasePath;

            // Make a temp directory for the client root
            Directory.CreateDirectory(strClientDirectory);
            
            // Create the isolinux.cfg file
            System.IO.StreamWriter writer = null;
            bool writeok = false; // Assume we have a problem.
           
            string isolinuxCfg = strClientDirectory + @"\isolinux.cfg"; // Path to isolinux.cfg

            // Write the isolinux.cfg file.
            try
            {
                writer = new StreamWriter(isolinuxCfg);
                writer.NewLine = "\n"; // Unix style line terminators
                writer.WriteLine(@"timeout 0");
                writer.WriteLine(@"default vmlinuz");
                writer.WriteLine(@"append " + KernelAppendString());
                writeok = true; // It went ok.                
            }
            finally
            {
                writer.Close();
            }

            if (writeok)
            {
                try
                {
                    // There was no prevoius version of the file, add it to the temp collection.
                    objTempdir.AddFile(isolinuxCfg, false);
                }
                catch { }
            }
            else
            {
                MessageBox.Show("Error cannot write to file (10065)", "AnywhereTS");
                return;
            }

            // Copy the files from the template directory to the temp directory
            File.Copy(DesigntimeConfig.DataDirectory + @"\vmlinuz", strClientDirectory + @"\vmlinuz", true);
            try
            {
                objTempdir.AddFile(strClientDirectory + @"\vmlinuz", false);
            }
            catch
            {} // File already exists in the collection

            File.Copy(DesigntimeConfig.DataDirectory + @"\isolinux.bin", strClientDirectory + @"\isolinux.bin", true);
            try
            {
            objTempdir.AddFile(strClientDirectory + @"\isolinux.bin", false);
            }
            catch
            { } // File already exists in the collection

            File.Copy(pathInitrd, strClientDirectory + @"\initrd", true);
            try
            {
                objTempdir.AddFile(strClientDirectory + @"\initrd", false);
            }
            catch
            { } // File already exists in the collection


        }

        public void CreateCfg(string strCfgName,string strDestPath)
        {
            // Create the isolinux.cfg file
            System.IO.StreamWriter writer = null;
            bool writeok = false; // Assume we have a problem.
            string isolinuxCfg = strDestPath + @"\" + strCfgName; // Path and filename

            // Write the isolinux.cfg file.
            try
            {
                writer = new StreamWriter(isolinuxCfg);
                writer.NewLine = "\n"; // Unix style line terminators
                writer.WriteLine(@"timeout 0");
                writer.WriteLine(@"default vmlinuz");
                writer.WriteLine(@"append " + KernelAppendString());
                writeok = true; // It went ok.                
            }
            finally
            {
                writer.Close();
            }

            if (writeok)
            {
                try
                {
                    // Add it to the temp collection.
                    objTempdir.AddFile(isolinuxCfg, false);
                }
                catch { }
            }
            else
            {
                MessageBox.Show("Error cannot write to file (10565)", "AnywhereTS");
               
                    using (log4net.NDC.Push(string.Format("file={0}", isolinuxCfg)))
                    {
                        Logging.ATSAdminLog.Error("Cannot write to file");
                    }
                
                return;
            }
        }

        // Create an initrd file
        // strRoot: 
        public void CreateInitrd(string strRoot)
        {
            string strBase;

            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            strBase = objTempdir.BasePath;

            File.Copy(DesigntimeConfig.DataDirectory + @"\xorg", strBase + @"\initrd", true);
            try
            {
                objTempdir.AddFile(strBase + @"\initrd", false);
            }
            catch { }

            // Lauch mksqfs.exe.exe to append files to initrd
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\mksquash\mksqfs.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.StartInfo.Arguments = @"""" + strRoot + @"""" + " " + @"""" + strBase + @"\initrd" + @"""";
            p.Start();
            p.WaitForExit();
        }

        // Create an ISO file containing a hard disk boot client including a hard disk writer that writes the client to hard disk
        public void CreateHardDiskBootISO()
        {
            string strBase, strHDroot;

            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            strBase = objTempdir.BasePath;

            // Make a temp directory for the HD root
            strHDroot = strBase + @"\hd";
            Directory.CreateDirectory(strHDroot);

            // Write a signature to the initrd file, to make it bootable with ATS protection
            WriteHarddiskBootSignature(strBase + @"\initrd");

            // Copy HDimage to HDimage directory
            File.Copy(strAppdir + @"\tools\hdimage", strHDroot + @"\initrd", true);
            try
            {
                objTempdir.AddFile(strHDroot + @"\initrd", false);
            }
            catch { }
            // Make a syslinux.cfg to be added to hard disk
            CreateCfg(@"\syslinux.cfg", strBase);

            // Add Initrd to HDImage
            // Lauch mksqfs.exe.exe to add initrd file to hdboot
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\mksquash\mksqfs.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.StartInfo.Arguments = @"""" + strBase + @"\initrd" + @"""" + " " + @"""" + strBase + @"\syslinux.cfg" + @"""" + " " + @"""" + strHDroot + @"\initrd" + @"""";
            p.Start();
            p.WaitForExit();

            // Prepare CD with an initrd that is the HD burner
            CreateISO(strHDroot + @"\initrd");
        }

        // Make a hard disk boot client including a hard disk writer that writes the client to hard disk, to be written to an USB drive 
        // pathUsbRoot = The path to the USB removable drive that the client will be written to. Should end with a backslash!
        // Return: true = went ok. False = error.
        public void CreateHardDiskBootUSB()
        {
            string strBase, strHDroot;
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            strBase = objTempdir.BasePath;

            string strPathTempUsbRoot = objTempdir.BasePath + @"\usb";  // Temp Directory for the USB root files.

            // Make a temp directory for the HD root
            strHDroot = strBase + @"\hd";
            Directory.CreateDirectory(strHDroot);

            // Make a syslinux.cfg to be added to hard disk
            CreateCfg(@"\syslinux.cfg", strBase);

            // Write a signature to the har disk boot initrd file, to make it bootable
            WriteHarddiskBootSignature(strBase + @"\initrd");

            // Copy HDimage to HDimage directory
            File.Copy(strAppdir + @"\tools\hdimage", strHDroot + @"\initrd", true);
            try
            {
                objTempdir.AddFile(strHDroot + @"\initrd", false);
            }
            catch { }

            // Add Initrd to HDImage
            // Lauch mksqfs.exe.exe to add initrd file to hdboot
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\mksquash\mksqfs.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            p.StartInfo.Arguments = @"""" + strBase + @"\initrd" + @"""" + " " + @"""" + strBase + @"\syslinux.cfg" + @"""" + " " + @"""" + strHDroot + @"\initrd" + @"""";

            p.Start();
            p.WaitForExit();

            // Write a signature to the har USB boot initrd file, to make it bootable
            WriteHarddiskBootSignature(strHDroot + @"\initrd");

            CreateClientRoot(strHDroot + @"\initrd", strPathTempUsbRoot);
        }

        // Make a bootable USB memory that contains a hard disk boot client including a hard disk writer that writes the client to hard disk. 
        // pathUsbRoot = The path to the USB removable drive that the client will be written to. Should end with a backslash!
        // Return: true = went ok. False = error.
        // Assumes the files are in objTempdir.BasePath + @"\usb"
        public bool WriteHardDiskBootUSB(string pathUsbMemoryRoot)
        {
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            string strPathTempUsbRoot = objTempdir.BasePath + @"\usb";  // Temp Directory for the USB root files.

            // Copy client root fles to USB
            try
            {
                File.Copy(strPathTempUsbRoot + @"\initrd", pathUsbMemoryRoot + @"initrd", true);
                File.Copy(strPathTempUsbRoot + @"\isolinux.cfg", pathUsbMemoryRoot + @"syslinux.cfg", true); // On a HD/USB, the name should be syslinux.cfg
                File.Copy(strPathTempUsbRoot + @"\vmlinuz", pathUsbMemoryRoot + @"vmlinuz", true);
                // Make USB bootable
                MakeUsbMemoryBootable(pathUsbMemoryRoot);
            }
            catch
            {
                MessageBox.Show("Error: Could write to removable drive. Please check write protection and rights.", "AnywhereTS");
                return false;
            }

            return true;
        }

        // Install a bootble AnywhereTS client to a USB memory.
        // pathUsbRoot = The path to the USB removable drive that the client will be written to.
        public void CreateUSBBootedClient()
        {
            string strPathTempUsbRoot = objTempdir.BasePath + @"\usb";
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);

            // Write a signature to the USB boot initrd file, to make it bootable
            WriteHarddiskBootSignature(objTempdir.BasePath + @"\initrd");

            CreateClientRoot(objTempdir.BasePath + @"\initrd", strPathTempUsbRoot);
        }

        // Install a bootble AnywhereTS client to a USB memory.
        // pathUsbRoot = The path to the USB removable drive that the client will be written to.
        // Return: true = went ok. False = error.
        // Source files will be found in objTempdir.BasePath + @"\usb
        public bool WriteUSBBootedClient(string pathUsbMemoryRoot)
        {
            string strPathTempUsbRoot = objTempdir.BasePath + @"\usb";
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            // Copy client root fles to USB
            try
            {
                File.Copy(strPathTempUsbRoot + @"\initrd", pathUsbMemoryRoot + @"initrd", true);
                File.Copy(strPathTempUsbRoot + @"\isolinux.cfg", pathUsbMemoryRoot + @"syslinux.cfg", true); // On a HD/USB, the name should be syslinux.cfg
                File.Copy(strPathTempUsbRoot + @"\vmlinuz", pathUsbMemoryRoot + @"vmlinuz", true);
                // Make USB bootable
                MakeUsbMemoryBootable(pathUsbMemoryRoot);
            }
            catch
            {
                //MessageBox.Show(ex.ToString()+ "   " + ex.Message);
                MessageBox.Show("Error: Could not write to removable drive. Please check write protection and rights.", "AnywhereTS");
                return false;
            }
            return true;
        }


        // Writes a boot sector to an USB flash memory
        public void MakeUsbMemoryBootable(string pathUsbMemoryRoot)
        {
            string strAppdir = Path.GetDirectoryName(Application.ExecutablePath);
            string strUsbDrive = pathUsbMemoryRoot.Remove(2);
            // Lauch syslinux.exe to write boot sector to USB drive
            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(strAppdir + @"\tools\syslinux.exe");
            p.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
            p.StartInfo.Arguments = @"-m -a -d /boot/syslinux " + strUsbDrive;
            p.Start();
            if (!p.WaitForExit(20000)) // Wait 20 sek for the process to terminate
            { // Process terminated because of timeout
                MessageBox.Show("Error: Could not make removable drive bootable (27611)", ATSGlobals.ApplicationName);
                p.Close();

            }
        }

        // Appends a a two byte signature to a client that should be booted from harddisk.
        // This acts as a license protection for harddisk boot, and eliminates the possibility of copying a free client to a hard disk.
        // IN strPathInitrd: Path to the initrd file that the signature should be appended to
        private void WriteHarddiskBootSignature(string strPathInitrd)
        {
            {   // Append the image file to the inird file
                // Create a signature in memory
                byte[] fileSignature = new byte[2];
                fileSignature[0] = 19;
                fileSignature[1] = 71;
                // Append to initrd file
                FileStream objDest = File.Open(strPathInitrd, FileMode.Append, FileAccess.Write);
                objDest.Write(fileSignature,0,2);
                objDest.Close();
            }
        }

    } // ATSImage
} // Namespace
Revision:	47
Committed:	Thu Jul 12 14:29:34 2012 UTC (10 years, 10 months ago) by william
File size:	33405 byte(s)
Log Message:	+ fix compilation errors