Example #1
0
        /// <summary>
        /// check if the driver we are about to install has already been installed
        /// if it has and is firmware then rollback if is not then just uninstall
        /// </summary>
        /// <param name="infNameToTest"></param>
        /// <param name="expectedDriverVersion"></param>
        /// <returns></returns>
        internal static bool CheckInstalled(string line, string hardwareID, string friendlyDriverName, string infNameToTest, string expectedDriverVersion, string expectedDriverDate)
        {
            Logger.FunctionEnter();
            string installedDriversCSVPath = Program.dirName + @"\installledDrivers.csv";
            string csvFileName             = "DeviceName-InfName.czv";
            string csvFileFullPath         = Program.dirName + csvFileName;
            string infName                = string.Empty;
            string infNameFromReg         = string.Empty;
            string installedDriverVersion = string.Empty;
            string installedDeviceName    = string.Empty;
            bool   result    = false;
            string classGUID = GetData.GetClassGUID(line);

            if (string.IsNullOrEmpty(hardwareID))
            {
                //do nothing for now
                hardwareID = "0x00000000";
                Console.WriteLine("not getting a hardwareID...??");
                Logger.Comment("no hardwareID in the INF so we can't use it to check if driver is installed");
            }
            else
            {
                infNameFromReg = GetDataFromReg.GetOEMinfNameFromRegSTR(infName, hardwareID, classGUID);
            }
            try
            {
                using (ManagementObjectSearcher s2 =
                           new ManagementObjectSearcher(
                               "root\\CIMV2",
                               "SELECT * FROM Win32_PnPSignedDriver"))

                    foreach (ManagementObject WmiObject in s2.Get())
                    {
                        if (WmiObject["InfName"] == null)
                        {
                            continue;
                        }
                        else
                        {
                            infName = WmiObject["InfName"].ToString();
                        }
                        if (WmiObject["DriverVersion"] == null)
                        {
                            continue;
                        }
                        else
                        {
                            installedDriverVersion = WmiObject["DriverVersion"].ToString();
                        }
                        if (WmiObject["DeviceName"] == null)
                        {
                            continue;
                        }
                        else
                        {
                            installedDeviceName = WmiObject["DeviceName"].ToString();
                        }

                        // there are zeros in driver versions in inf files that are not in the devMgr
                        // and viceVersa will have to remove\replace all zeros with ""
                        if (expectedDriverVersion.EndsWith("0"))
                        {
                            expectedDriverVersion = expectedDriverVersion.TrimEnd('0');
                            expectedDriverVersion = expectedDriverVersion.TrimEnd('.');
                            expectedDriverVersion = expectedDriverVersion.TrimEnd('0');
                        }

                        if (installedDriverVersion.EndsWith("0"))
                        {
                            installedDriverVersion = installedDriverVersion.TrimEnd('0');
                            installedDriverVersion = installedDriverVersion.TrimEnd('.');
                            installedDriverVersion = installedDriverVersion.TrimEnd('0');
                        }

                        if (installedDeviceName.Contains(" "))
                        {
                            installedDeviceName = installedDeviceName.Replace(" ", "");
                        }
                        if (infName.Contains(" "))
                        {
                            infName = infName.Replace(" ", "");
                        }
                        if (infNameToTest.Contains(" "))
                        {
                            infNameToTest = infNameToTest.Replace(" ", "");
                        }
                        if (friendlyDriverName.Contains(" "))
                        {
                            friendlyDriverName = friendlyDriverName.Replace(" ", "");
                        }
                        infNameToTest = infNameToTest.Split('.')[0];
                        if (infNameToTest.Equals("SurfaceEC"))
                        {
                            infNameToTest = "SurfaceEmbeddedControllerFirmware";
                        }

                        string lineContains = string.Empty;

                        switch (lineContains)
                        {
                        case string infNameFromR when infName.Equals(infNameFromReg):
                            if (expectedDriverVersion.Equals(installedDriverVersion))
                            {
                                Logger.Comment(infNameToTest);
                                result = true;
                                Logger.Comment("result from checkInstalled TRUE infName/version : ");
                            }
                            break;

                        case string installedDeviceNam when friendlyDriverName.Equals(installedDeviceName):
                            if (expectedDriverVersion.Equals(installedDriverVersion))
                            {
                                Logger.Comment(infNameToTest);
                                result = true;
                                Logger.Comment("result from checkInstalled TRUE infName/version : ");
                            }
                            break;

                        case string failedResult when Regex.Match(infName, friendlyDriverName).Success:
                            if (expectedDriverVersion.Equals(installedDriverVersion))
                            {
                                Logger.Comment(infNameToTest);
                                result = true;
                                Logger.Comment("result from checkInstalled TRUE infName/version : ");
                            }
                            break;

                        case string successinstallResult when infName.Equals(infNameFromReg):
                            if (expectedDriverVersion.Equals(installedDriverVersion))
                            {
                                Logger.Comment(infNameToTest);
                                result = true;
                                Logger.Comment("result from checkInstalled TRUE infName/version : ");
                            }
                            break;

                        case string last when installedDeviceName.Contains(infNameToTest):
                            if (expectedDriverVersion.Equals(installedDriverVersion))
                            {
                                Logger.Comment(infNameToTest);
                                result = true;
                                Logger.Comment("result from checkInstalled TRUE infName/version : ");
                            }
                            break;

                        default:
                            continue;
                        }
                    }
            }

            catch (Exception ex)
            {
                GetData.GetExceptionMessage(ex);
            }
            Logger.Comment("result actually being returned from checkInstalled : " + result);
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("result actually being returned from checkInstalled : " + result);
            Console.ForegroundColor = ConsoleColor.White;
            Logger.FunctionLeave();
            return(result);
        }
Example #2
0
        /// <summary>
        /// firmware or regular driver will still call this to do the actual installation
        /// </summary>
        /// <param name="infName"></param>
        /// <param name="line"></param>
        /// <param name="installer"></param>
        /// <param name="installArgs"></param>
        /// <param name="InputTestFilePath"></param>
        /// <param name="rebootRequired"></param>
        /// <param name="hardwareID"></param>
        /// SafeNativeMethods.InstallUninstallCall(seedIndex, rebootRequired, infName, line, installer, InputTestFilePath);
        internal static void InstallUninstallCall(int seedIndex, bool rebootRequired, string infName, string line, string installer, string InputTestFilePath)
        {
            try
            {
                Logger.FunctionEnter();
                string expectedDriverVersion = GetData.GetDriverVersion(line);
                string infNameToTest         = Path.GetFileNameWithoutExtension(line);
                string expectedDriverDate    = GetData.GetDriverDate(line);
                string infPath = Path.GetDirectoryName(line);
                string installArgs;
                string friendlyDriverName = XMLReader.GetFriendlyDriverName(InputTestFilePath, line);
                Console.WriteLine(line + " and " + seedIndex);
                Console.WriteLine("RemoveXMLElement now");
                XMLWriter.RemoveXMLElemnt(Program.InputTestFilePath, line, seedIndex);
                Console.WriteLine("check the xml please..");
                string hardwareID  = GetData.FirmwareInstallGetHID(line);
                bool   isInstalled = CheckWhatInstalled.CheckInstalled(line, hardwareID, friendlyDriverName, infNameToTest, expectedDriverVersion, expectedDriverDate);
                if (isInstalled)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("----------------------------------------------------------");
                    Console.WriteLine("THIS PnP DRIVER VERSION IS INSTALLED UN-INSTALLING NOW....");
                    Console.WriteLine(infName);
                    Console.WriteLine("----------------------------------------------------------");
                    Console.ForegroundColor = ConsoleColor.White;

                    Logger.Comment("rebootRequired is showing as : " + rebootRequired);
                    installArgs = " /C /U " + line + " /Q /D";
                    Install_Inf(line, installer, installArgs, seedIndex);
                    Logger.Comment("Operation should be complete: " + line);

                    string classGUID = GetData.GetClassGUID(line);
                    GetDataFromReg.GetOEMinfNameFromReg(infName, hardwareID, classGUID);

                    if (RegCheck.IsRebootPending())
                    {
                        Logger.Comment("there is a pending reboot...");
                        RebootAndContinue.RebootCmd(true);
                    }
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("---------------------------------------------------------------");
                    Console.WriteLine("THIS PnP DRIVER VERSION WAS NOT INSTALLED YET INSTALLING NOW...");
                    Console.WriteLine(infName);
                    Console.WriteLine("---------------------------------------------------------------");
                    Console.ForegroundColor = ConsoleColor.White;

                    Logger.Comment("rebootRequired is showing as : " + rebootRequired);
                    installArgs = " /C /A /Q /SE /F /PATH " + infPath;
                    Install_Inf(line, installer, installArgs, seedIndex);
                    string classGUID = GetData.GetClassGUID(line);
                    XMLWriter.SetLastInstalled(line);

                    //can we check registry simiarly to firmware for PnP drivers?
                    Logger.Comment("Operation should be complete: " + line);

                    if (RegCheck.IsRebootPending())
                    {
                        Logger.Comment("there is a pending reboot...");
                        RebootAndContinue.RebootCmd(true);
                    }
                }
                Logger.FunctionLeave();
            }
            catch (Exception ex)
            {
                GetData.GetExceptionMessage(ex);
            }
        }
Example #3
0
        /// <summary>
        /// this is called when installing firmware to perform the extra actions needed such as regkey writes and reboot
        /// </summary>
        /// <param name="infName"></param>
        /// <param name="infFileContent"></param>
        /// <param name="hardwareID"></param>
        /// <param name="rebootRequired"></param>
        /// <param name="rollBackLine"></param>
        /// <param name="installer"></param>
        /// <param name="installArgs"></param>
        /// <param name="InputTestFilePath"></param>
        internal static void RollbackInstall(int seedIndex, string line, string infName, string infFileContent, string hardwareID, bool rebootRequired, string InputTestFilePath)
        {
            Logger.FunctionEnter();
            string installArgs;
            string fullRollBackFile   = string.Empty;
            string fullRollBackDIR    = string.Empty;
            string fullRollBackDIRdir = string.Empty;

            try
            {
                XMLWriter.RemoveXMLElemnt(Program.InputTestFilePath, line, seedIndex);
                RegCheck.CreatePolicyRegKeyAndSetValue(hardwareID, rebootRequired.Equals(true));

                fullRollBackDIR = GetData.CheckRollbacksExist(line, infName);

                if (string.IsNullOrEmpty(fullRollBackDIR))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("should i even be trying to rollback at all???");
                    Console.ForegroundColor = ConsoleColor.White;
                }
                else
                {
                    fullRollBackDIRdir = Path.GetDirectoryName(fullRollBackDIR);
                }

                installArgs = " /C /U " + line + " /Q /D";
                string tmpfileName = string.Empty;
                string tmpVersion  = GetData.GetDriverVersion(line);
                var    binsList    = Directory.EnumerateFiles(@"C:\Windows\Firmware\");
                foreach (string binFileToDelete in binsList)
                {
                    tmpfileName = Path.GetFileNameWithoutExtension(binFileToDelete);
                    tmpVersion  = tmpVersion.TrimEnd('0').TrimEnd('0').TrimEnd('.');
                    if (Regex.Match(tmpfileName, tmpVersion).Success)
                    {
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine("binFileToDelete exists : " + tmpfileName);
                        File.Delete(tmpfileName);
                        Console.ForegroundColor = ConsoleColor.White;
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }
                Install_Inf(line, Program.installer, installArgs, seedIndex);
                Logger.Comment("Uninstall Operation should be complete: " + line);
                installArgs = " /C /A /Q /SE /F /PATH " + fullRollBackDIRdir;
                Logger.Comment("start rollback...");
                XMLWriter.SetLastInstalled(fullRollBackDIR);
                Install_Inf(line, Program.installer, installArgs, seedIndex);
                string classGUID             = GetData.GetClassGUID(line);
                string expectedDriverVersion = GetData.GetDriverVersion(line);
                GetDataFromReg.GetOEMinfNameFromReg(infName, hardwareID, classGUID);
                if (RegCheck.IsRebootPending())
                {
                    Logger.Comment("there is a pending reboot...");
                    RebootAndContinue.RebootCmd(true);
                }
            }
            catch (Exception ex)
            {
                GetData.GetExceptionMessage(ex);
            }
            Logger.FunctionLeave();
        }
        /// <summary>
        /// just another check to be sure driver is installed
        /// this will run after there is a reboot so is mostly for validation of firmware installs
        /// GetData.IsInstalledAfterReboot();
        /// </summary>
        internal static string IsInstalledAfterReboot(string line)
        {
            string result     = "pass";
            string returnCode = "pass";

            try
            {
                // get the file attributes for file or directory
                FileAttributes attr = File.GetAttributes(line);
                // detect whether its a directory or file
                if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
                {
                    foreach (string tmpPath in Directory.EnumerateFiles(line))
                    {
                        if (tmpPath.EndsWith(".inf"))
                        {
                            line = tmpPath;
                        }
                        else
                        {
                            continue;
                        }
                    }
                }

                string TMPexpectedVersion = GetDriverVersion(line);
                string TMPinfName         = Path.GetFileNameWithoutExtension(line);
                string TMPhardwareID      = FirmwareInstallGetHID(line);
                string classGUID          = GetClassGUID(line);
                int    TMPinfListCount    = XMLReader.GetInfsPathListCount(Program.InputTestFilePathBAK);
                int    executionCount     = XMLReader.GetExecutionCount(Program.InputTestFilePath);
                bool   TMPisCapsule       = CheckDriverIsFirmware(line, executionCount, TMPinfListCount);
                bool   stopOnError        = XMLReader.GetStopOnError(Program.InputTestFilePathBAK);

                if (TMPisCapsule)
                {
                    string CapsuleDidInstall = GetDataFromReg.CheckRegCapsuleIsInstalled(TMPinfName, TMPhardwareID, TMPexpectedVersion, line);
                    if (stopOnError.Equals(true))
                    {
                        switch (returnCode)
                        {
                        case string failed when CapsuleDidInstall.Equals("unsuccessful"):
                            returnCode = "unsuccessful registry code is 1 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string InsufficientResources when CapsuleDidInstall.Equals("InsufficientResources"):
                            returnCode = "InsufficientResources registry code is 2 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string IncorrectVersion when CapsuleDidInstall.Equals("IncorrectVersion"):
                            returnCode = "IncorrectVersion registry code is 3 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string invalidImage when CapsuleDidInstall.Equals("invalidImage"):
                            returnCode = "invalidImage registry code is 4 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string authenticationERR when CapsuleDidInstall.Equals("authenticationERR"):
                            returnCode = "authenticationERR registry code is 5 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string ACnotConnected when CapsuleDidInstall.Equals("ACnotConnected"):
                            returnCode = "ACnotConnected registry code is 6 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        case string insufficientPower when CapsuleDidInstall.Equals("insufficientPower"):
                            returnCode = "insufficientBatteryPower registry code is 7 ";

                            XMLErrorMessage(returnCode, line);
                            break;

                        default:
                            returnCode = "pass";
                            result     = returnCode;
                            Logger.Comment("checked the registry after reboot but this firmware installed correctly " + returnCode + " " + line);
                            Console.WriteLine("checked the registry after reboot but this firmware installed correctly " + returnCode + " " + line);
                            break;
                        }
                    }
                }
                return(result);
            }
            catch (Exception ex)
            {
                GetExceptionMessage(ex);
                return(result);
            }
        }