private static string GetStartupApprovedKey(StartupEntry startupEntry)
{
if (!startupEntry.IsRegKey)
{
return(startupEntry.AllUsers
? @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder"
: @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder");
}
if (startupEntry.IsRunOnce)
{
if (startupEntry.AllUsers)
{
return(startupEntry.ParentLongName.Contains("Wow6432Node")
? @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\RunOnce32"
: @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\RunOnce");
}
return(@"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\RunOnce");
}
if (startupEntry.AllUsers)
{
return(startupEntry.ParentLongName.Contains("Wow6432Node")
? @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run32"
: @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run");
}
return(@"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run");
}
private static bool GetDisabled(StartupEntry startupEntry)
{
using (var key = RegistryTools.CreateSubKeyRecursively(GetStartupApprovedKey(startupEntry)))
{
var bytes = key.GetValue(startupEntry.EntryLongName) as byte[];
return(bytes != null && bytes.Length > 0 && !bytes[0].Equals(0x02));
}
}
private static void SetDisabled(StartupEntry startupEntry, bool disabled)
{
using (var key = RegistryTools.CreateSubKeyRecursively(GetStartupApprovedKey(startupEntry)))
{
key.SetValue(startupEntry.EntryLongName, disabled ? DisabledBytes : EnabledBytes,
RegistryValueKind.Binary);
}
}
/// <summary>
/// Disable startup entry to stop it from being processed at startup. It is stored in the backup store.
/// </summary>
/// <param name="startupEntry"></param>
public static void Disable(StartupEntry startupEntry)
{
if (startupEntry.DisabledStore)
{
return;
}
DisableFunctions.Disable(startupEntry);
}
public bool StillExists(StartupEntry startupEntry)
{
if (startupEntry.IsRegKey)
{
using (var key = RegistryTools.OpenRegistryKey(startupEntry.ParentLongName))
return(!string.IsNullOrEmpty(key.GetStringSafe(startupEntry.EntryLongName)));
}
return(File.Exists(startupEntry.FullLongName));
}
public void Delete(StartupEntry startupEntry)
{
RemoveDisabledRegEntry(startupEntry);
// Remove the backup file
if (!startupEntry.IsRegKey)
{
File.Delete(GetDisabledEntryPath(startupEntry));
}
}
/// <summary>
/// Set if this startup entry should run for all users or only for the current user.
/// </summary>
public static void SetAllUsers(StartupEntry startupEntry, bool allUsers)
{
// Find the suitable replacement
var target = StartupEntryFactory.RunLocations.First(x => (x.IsRegKey == startupEntry.IsRegKey) &&
(x.IsRunOnce == startupEntry.IsRunOnce) &&
(x.AllUsers == allUsers) && !x.IsWow);
// Don't want to deal with the disable wizardry
var wasDisabled = startupEntry.Disabled;
if (wasDisabled)
{
Enable(startupEntry);
}
// Remove old entry or move the link to the new directory.
if (startupEntry.IsRegKey)
{
try
{
// Can't do this with links as they would get deleted
startupEntry.Delete();
}
catch
{
// Key doesn't exist
}
}
else
{
if (File.Exists(startupEntry.FullLongName))
{
var newPath = Path.Combine(target.Path, startupEntry.EntryLongName);
File.Delete(newPath);
File.Move(startupEntry.FullLongName, newPath);
}
}
// Plug in new data
startupEntry.SetParentLongName(target.Path);
startupEntry.AllUsersStore = allUsers;
// Update registry stuff
if (startupEntry.IsRegKey)
{
CreateRegValue(startupEntry);
}
// Restore disable status
if (wasDisabled)
{
Disable(startupEntry);
}
}
/// <summary>
/// Create a registry value for the specified entry. Works for drive links as well.
/// </summary>
/// <param name="startupEntry"></param>
internal static void CreateRegValue(StartupEntry startupEntry)
{
if (string.IsNullOrEmpty(startupEntry.Command))
{
return;
}
using (var runKey = RegistryTools.CreateSubKeyRecursively(startupEntry.ParentLongName))
{
runKey.SetValue(startupEntry.EntryLongName, startupEntry.Command, RegistryValueKind.String);
}
}
/// <summary>
/// Delete startup entry data from registry and file system.
/// Only needed items are removed, for example if entry is disabled the entry from "Run" key is
/// not removed if it exists, same for the "Startup" folder. To remove them change the Disabled
/// property and run this command again.
/// </summary>
/// <param name="startupEntry">Entry to delete</param>
public static void Delete(StartupEntry startupEntry)
{
if (startupEntry.Disabled)
{
DisableFunctions.Enable(startupEntry);
}
if (startupEntry.IsRegKey)
{
RegistryTools.RemoveRegistryValue(startupEntry.ParentLongName, startupEntry.EntryLongName);
}
else
{
File.Delete(startupEntry.FullLongName);
}
}
private static bool GetDisabled(StartupEntry startupEntry)
{
try
{
using (var key = RegistryTools.CreateSubKeyRecursively(GetStartupApprovedKey(startupEntry)))
{
var bytes = key.GetValue(startupEntry.EntryLongName) as byte[];
return(bytes != null && bytes.Length > 0 && !bytes[0].Equals(0x02));
}
}
catch (SystemException ex)
{
Console.WriteLine(ex);
return(false);
}
}
/// <summary>
/// Remove registry key of a disabled startup entry. Link file is not touched if it exists.
/// </summary>
private static void RemoveDisabledRegEntry(StartupEntry startupEntry)
{
using (var disabledStartupEntryStore = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path, true))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
var disabledSubkeyKey =
disabledStartupEntryStore.GetSubKeyNames()
.FirstOrDefault(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase));
if (!string.IsNullOrEmpty(disabledSubkeyKey))
{
disabledStartupEntryStore.DeleteSubKey(disabledSubkeyKey);
}
}
}
public void Disable(StartupEntry startupEntry)
{
if (startupEntry.DisabledStore)
{
return;
}
var newPath = CreateDisabledEntryPath(startupEntry);
// Remove the startup entry / move the file to the backup folder
if (startupEntry.IsRegKey)
{
try
{
startupEntry.Delete();
}
catch
{
// Key doesn't exist
}
}
else
{
if (File.Exists(startupEntry.FullLongName))
{
File.Delete(newPath);
if (!Directory.Exists(DriveDisableBackupPath))
{
Directory.CreateDirectory(DriveDisableBackupPath);
}
File.Move(startupEntry.FullLongName, newPath);
startupEntry.BackupPath = newPath;
}
else
{
throw new InvalidOperationException(Localisation.StartupManager_FailedEnable_FileNotFound
+ "\n\n" + startupEntry.FullLongName);
}
}
CreateDisabledEntry(startupEntry, newPath);
startupEntry.DisabledStore = true;
}
public bool StillExists(StartupEntry startupEntry)
{
try
{
using (var key = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
return(key.GetSubKeyNames()
.Any(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase)));
}
}
catch
{
return(false);
}
}
/// <summary>
/// Crate backup of the entry in the specified directory. If backup file already exists, it is overwritten.
/// </summary>
public static void CreateBackup(StartupEntry startupEntry, string backupPath)
{
var newPath = Path.Combine(backupPath, "Startup - " + startupEntry.EntryLongName);
if (startupEntry.IsRegKey)
{
var sb = new StringBuilder();
sb.AppendLine("Windows Registry Editor Version 5.00");
sb.AppendLine();
sb.AppendLine($@"[{startupEntry.ParentLongName}]");
sb.AppendLine(
$"\"{startupEntry.EntryLongName}\"=\"{startupEntry.Command.Replace("\\", "\\\\").Replace("\"", "\\\"")}\"");
File.WriteAllText(newPath + ".reg", sb.ToString());
}
else
{
if (!File.Exists(newPath))
{
File.Delete(newPath);
}
if (startupEntry.Disabled)
{
var disabledFile = DisableFunctions.GetDisabledEntryPath(startupEntry);
if (File.Exists(disabledFile))
{
File.Copy(disabledFile, newPath);
}
}
else
{
if (File.Exists(startupEntry.FullLongName))
{
File.Copy(startupEntry.FullLongName, newPath);
}
}
}
}
/// <summary>
/// Look for links in startup folders
/// </summary>
private static IEnumerable <StartupEntry> GetDriveStartupItems(StartupPointData point)
{
if (!Directory.Exists(point.Path))
{
yield break;
}
foreach (var name in Directory.GetFiles(point.Path)
.Where(name => ".lnk".Equals(Path.GetExtension(name), StringComparison.CurrentCultureIgnoreCase)))
{
StartupEntry result;
try
{
result = new StartupEntry(point, Path.GetFileName(name), WindowsTools.ResolveShortcut(name));
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
continue;
}
yield return(result);
}
}
public static void MoveToRegistry(StartupEntry startupEntry)
{
if (startupEntry.IsRegKey)
{
return;
}
// Don't want to deal with the disable wizardry
var wasDisabled = startupEntry.Disabled;
if (wasDisabled)
{
Enable(startupEntry);
}
// Delete old entry
startupEntry.Delete();
// Plug in new data
startupEntry.IsRegKey = true;
var newPoint =
StartupEntryFactory.RunLocations.First(x => x.IsRegKey && (x.AllUsers == startupEntry.AllUsers) &&
!x.IsRunOnce && !x.IsWow);
startupEntry.SetParentLongName(newPoint.Path);
startupEntry.SetParentFancyName(newPoint.Name);
// Recreate registry entry
CreateRegValue(startupEntry);
// Restore disable status
if (wasDisabled)
{
Disable(startupEntry);
}
}
public void Enable(StartupEntry startupEntry)
{
if (!startupEntry.DisabledStore)
{
return;
}
// Reconstruct the startup entry
if (!startupEntry.IsRegKey)
{
// Move the backup file back to its original location
var oldPath = GetDisabledEntryPath(startupEntry);
if (File.Exists(oldPath))
{
File.Delete(startupEntry.FullLongName);
File.Move(oldPath, startupEntry.FullLongName);
}
else
{
throw new InvalidOperationException(Localisation.StartupManager_FailedEnable_FileNotFound
+ "\n\n" + oldPath);
}
}
else
{
// Recreate the registry key
StartupEntryManager.CreateRegValue(startupEntry);
}
Delete(startupEntry);
startupEntry.BackupPath = string.Empty;
// Entry is no longer disabled
startupEntry.DisabledStore = false;
}
/// <summary>
/// Look for entries in the disabled startup backup store.
/// </summary>
public IEnumerable <StartupEntry> AddDisableInfo(IList <StartupEntry> existingEntries)
{
foreach (var entry in existingEntries)
{
yield return(entry);
}
using (var regDisKey = RegistryTools.CreateSubKeyRecursively(RegistryDisabledKey.Path))
{
var badLocations = new List <string>();
foreach (var subKeyName in regDisKey.GetSubKeyNames())
{
using (var subKey = regDisKey.OpenSubKey(subKeyName))
{
if (subKey == null)
{
continue;
}
var key = subKey.GetValue("key") as string;
var hkey = subKey.GetValue("hkey") as string;
var item = subKey.GetValue("item") as string;
var command = subKey.GetValue("command") as string;
if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(hkey) ||
string.IsNullOrEmpty(item) || string.IsNullOrEmpty(command))
{
continue;
}
var location = Path.Combine(RegistryTools.GetKeyRoot(hkey, false), key);
if (string.IsNullOrEmpty(location.Trim()))
{
continue;
}
var runLocation = StartupEntryFactory.RunLocations
.FirstOrDefault(x => PathTools.PathsEqual(location, x.Path));
if (runLocation != null)
{
StartupEntry startupEntry;
try
{
startupEntry = new StartupEntry(runLocation, item, command)
{
DisabledStore = true
};
}
catch
{
badLocations.Add(location);
continue;
}
yield return(startupEntry);
}
else
{
badLocations.Add(location);
}
}
}
#if DEBUG
if (badLocations.Any())
{
throw new InvalidDataException(Localisation.Error_InvalidRegKeys + "\n"
+
string.Join("\n", badLocations.Distinct().OrderBy(x => x).ToArray()));
}
#endif
}
using (var hddDisKey = RegistryTools.CreateSubKeyRecursively(DriveDisabledKey.Path))
{
foreach (var subKeyName in hddDisKey.GetSubKeyNames())
{
using (var subKey = hddDisKey.OpenSubKey(subKeyName))
{
if (subKey == null)
{
continue;
}
var path = subKey.GetValue("path") as string;
var location = subKey.GetValue("location") as string;
var backup = subKey.GetValue("backup") as string;
var command = subKey.GetValue("command") as string;
if (backup == null || location == null || path == null || command == null)
{
continue;
}
var runLocation =
StartupEntryFactory.RunLocations.FirstOrDefault(x => PathTools.PathsEqual(x.Path, location));
yield return(new StartupEntry(runLocation, Path.GetFileName(path), command)
{
BackupPath = backup,
DisabledStore = true
});
}
}
}
}
/// <summary>
/// Create a new record in the appropriate disabled entry store. If the entry already exists it is overwritten.
/// </summary>
/// <param name="startupEntry">Startup entry to create the record for</param>
/// <param name="newEntryPath">Full path to the new backup file</param>
private static void CreateDisabledEntry(StartupEntry startupEntry, string newEntryPath)
{
using (var disabledStartupEntryStore = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path, true))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
var disabledSubkeyKey =
disabledStartupEntryStore.GetSubKeyNames()
.FirstOrDefault(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase));
// Clean up old disabled entry if any
if (!string.IsNullOrEmpty(disabledSubkeyKey))
{
disabledStartupEntryStore.DeleteSubKey(disabledSubkeyKey);
}
using (
var storeSubkey = disabledStartupEntryStore.CreateSubKey(disabledSubKeyName,
RegistryKeyPermissionCheck.ReadWriteSubTree))
{
if (storeSubkey == null)
{
return;
}
if (startupEntry.IsRegKey)
{
storeSubkey.SetValue("key", RegistryTools.StripKeyRoot(startupEntry.ParentLongName),
RegistryValueKind.String);
storeSubkey.SetValue("item", startupEntry.EntryLongName, RegistryValueKind.String);
storeSubkey.SetValue("hkey", RegistryTools.GetKeyRoot(startupEntry.ParentLongName, true),
RegistryValueKind.String);
storeSubkey.SetValue("inimapping", 0, RegistryValueKind.String);
}
else
{
storeSubkey.SetValue("item",
Path.GetFileNameWithoutExtension(startupEntry.EntryLongName) ?? string.Empty,
RegistryValueKind.String);
storeSubkey.SetValue("path", startupEntry.FullLongName, RegistryValueKind.String);
storeSubkey.SetValue("location", startupEntry.ParentLongName, RegistryValueKind.String);
storeSubkey.SetValue("backup", newEntryPath, RegistryValueKind.String);
storeSubkey.SetValue("backupExtension", BackupExtension, RegistryValueKind.String);
}
// Command stays the same for both
storeSubkey.SetValue("command", startupEntry.Command, RegistryValueKind.String);
// Set the disable date
var now = DateTime.Now;
storeSubkey.SetValue("YEAR", now.Year, RegistryValueKind.DWord);
storeSubkey.SetValue("MONTH", now.Month, RegistryValueKind.DWord);
storeSubkey.SetValue("DAY", now.Day, RegistryValueKind.DWord);
storeSubkey.SetValue("HOUR", now.Hour, RegistryValueKind.DWord);
storeSubkey.SetValue("MINUTE", now.Minute, RegistryValueKind.DWord);
storeSubkey.SetValue("SECOND", now.Second, RegistryValueKind.DWord);
}
}
}
public void Disable(StartupEntry startupEntry)
{
SetDisabled(startupEntry, true);
}
public void Enable(StartupEntry startupEntry)
{
SetDisabled(startupEntry, false);
}
/// <summary>
/// Create backup store path for the link. The backup extension is appended as well.
/// Works only for links, returns garbage for registry values.
/// </summary>
public string GetDisabledEntryPath(StartupEntry startupEntry)
{
return(string.IsNullOrEmpty(startupEntry.BackupPath)
? CreateDisabledEntryPath(startupEntry)
: startupEntry.BackupPath);
}
public string GetDisabledEntryPath(StartupEntry startupEntry)
{
return(startupEntry.FullLongName);
}
