public void Convert()
{
var tempReg = System.Guid.NewGuid().ToString("N") + ".reg";
var tempDir = "reg-out-" + System.Guid.NewGuid().ToString("N");
Directory.CreateDirectory(tempDir);
try
{
var mfn = typeof(TestConversion).Assembly.GetManifestResourceNames().First(a => a.EndsWith("team.reg"));
using (var mf = typeof(TestConversion).Assembly.GetManifestResourceStream(mfn))
{
using (var fs = File.OpenWrite(tempReg))
{
// ReSharper disable once PossibleNullReferenceException
mf.CopyTo(fs);
fs.Flush(true);
}
}
var regConv = new MsixRegistryFileWriter(tempDir);
var regPars = new RegFileParser();
regPars.Parse(Path.Combine(tempReg));
regConv.ImportRegFile(tempReg);
}
finally
{
ExceptionGuard.Guard(() =>
{
Directory.Delete(tempDir, true);
File.Delete(tempReg);
});
}
}
public void Import(string regFile)
{
var regParser = new RegFileParser();
var parsedKeys = regParser.Parse(regFile);
foreach (var key in parsedKeys)
{
this.Add(key);
}
}
private void ImportRegFileToolStripMenuItem_Click(object sender, EventArgs e)
{
openFileDlg.RestoreDirectory = true;
openFileDlg.InitialDirectory = PathManager.Init.GetLastPath(Settings.Default.ImportLastPath);
openFileDlg.Filter = "RegShot Files|*.reg";
if (openFileDlg.ShowDialog(this) == DialogResult.OK)
{
Settings.Default.ImportLastPath = Path.GetDirectoryName(openFileDlg.FileName);
var regFileParser = new RegFileParser();
ImportSourceFolder(regFileParser, openFileDlg.FileName);
}
}
public void Convert()
{
var tempReg = System.Guid.NewGuid().ToString("N") + ".reg";
var tempDir = "reg-out-" + System.Guid.NewGuid().ToString("N");
Directory.CreateDirectory(tempDir);
try
{
var mfn = typeof(TestConversion).Assembly.GetManifestResourceNames().First(a => a.EndsWith("team.reg"));
using (var mf = typeof(TestConversion).Assembly.GetManifestResourceStream(mfn))
{
using (var fs = System.IO.File.OpenWrite(tempReg))
{
// ReSharper disable once PossibleNullReferenceException
mf.CopyTo(fs);
fs.Flush(true);
}
}
var regConv = new RegConverter();
var regPars = new RegFileParser();
regPars.Parse(Path.Combine(tempReg));
regConv.ConvertFromRegToDat(tempReg, Path.Combine(tempDir, "Registry.dat"), RegistryRoot.HKEY_LOCAL_MACHINE).GetAwaiter().GetResult();
regConv.ConvertFromRegToDat(tempReg, Path.Combine(tempDir, "UserClasses.dat"), RegistryRoot.HKEY_CLASSES_ROOT).GetAwaiter().GetResult();
regConv.ConvertFromRegToDat(tempReg, Path.Combine(tempDir, "User.dat"), RegistryRoot.HKEY_CURRENT_USER).GetAwaiter().GetResult();
}
finally
{
ExceptionGuard.Guard(() =>
{
System.IO.Directory.Delete(tempDir, true);
System.IO.File.Delete(tempReg);
});
}
}
private void ImportRegClipboard()
{
var clipTxt = Clipboard.GetText();
List <string> clipListData = null;
if (!string.IsNullOrWhiteSpace(clipTxt))
{
clipListData = clipTxt.ToListStr();
}
else
{
// Get the DataObject.
IDataObject data_object = Clipboard.GetDataObject();
if (data_object != null)
{
var fileDropData = data_object.GetData(DataFormats.FileDrop, true) as string[];
if (fileDropData != null)
{
clipListData = new List <string>();
foreach (var item in fileDropData)
{
clipListData.Add(item);
}
}
}
}
if (clipListData != null && clipListData.Count > 0)
{
for (int index = 0; index < clipListData.Count; index++)
{
string tempRegFile = string.Format("{0}RegKey_ClipImport.reg", Path.GetTempPath());
string exeFullPath = FileUtility.Inst.GetSearchPath("reg.exe");
string args = string.Format("export \"{0}\" \"{1}\" /y", clipListData[index], tempRegFile);
try
{
using (Process proc = new Process())
{
proc.StartInfo.FileName = exeFullPath;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.RedirectStandardError = true;
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.Arguments = args;
proc.Start();
string stdout = proc.StandardOutput.ReadToEnd();
string stderr = proc.StandardError.ReadToEnd();
proc.WaitForExit();
}
var regFileParser = new RegFileParser();
ImportSourceFolder(regFileParser, tempRegFile);
}
catch (Exception ex)
{
ErrorLog.Inst.ShowError("Clipboad data not supported : {0}", ex.Message);
}
}
}
else
{
ErrorLog.Inst.ShowError("Clipboad data not supported");
}
}
/// <summary>
/// The constructor takes the content of a .REG file, the expected header (=first line of the .REG file) and import options (if any)
/// </summary>
/// <param name="content">Content of the .REG file</param>
/// <param name="expectedHeader">Expected header</param>
/// <param name="options">Import options</param>
public RegFileImporter(string content, string expectedHeader, RegFileImportOptions options)
{
Parser = new RegFileParser(expectedHeader, options);
Content = content;
Result = null;
}
/// <summary>
/// The constructor takes the content of a .REG file, the expected header (=first line of the .REG file) and import options (if any)
/// </summary>
/// <param name="content">Content of the .REG file</param>
/// <param name="expectedHeader">Expected header</param>
/// <param name="options">Import options</param>
public RegFileImporter(string content, string expectedHeader, RegFileImportOptions options)
{
Parser = new RegFileParser(expectedHeader, options);
Content = content;
Result = null;
}
public async Task ConvertFromRegToDat(string regFile, string file, RegistryRoot?root = null)
{
var regParser = new RegFileParser();
var parsedKeys = regParser.Parse(regFile);
IEnumerable <RegistryEntry> parsedFilteredKeys;
if (root == null)
{
parsedFilteredKeys = parsedKeys;
}
else
{
parsedFilteredKeys = parsedKeys.Where(r => r.Root == root.Value);
}
var reader = new RawReader();
using (var hive = await reader.Create())
{
var mustSave = false;
foreach (var item in parsedFilteredKeys)
{
var key = PrepareRegistryKey(item);
mustSave = true;
var k = this.EnsureRegistryKey(hive.Root, key);
if (!string.IsNullOrEmpty(item.Name))
{
switch (item.Type)
{
case ValueType.Default:
break;
case ValueType.String:
k.SetValue(item.Name, this.Tokenize((string)item.Value));
break;
case ValueType.DWord:
var val = (long)Convert.ChangeType(item.Value, typeof(long));
if (val > int.MaxValue)
{
k.SetValue(item.Name, val);
}
else
{
k.SetValue(item.Name, (int)val);
}
break;
case ValueType.QWord:
k.SetValue(item.Name, (long)Convert.ChangeType(item.Value, typeof(long)));
break;
case ValueType.Multi:
k.SetValue(item.Name, this.Tokenize((string[])item.Value));
break;
case ValueType.Expandable:
k.SetValue(item.Name, this.Tokenize((string)item.Value));
break;
case ValueType.Binary:
k.SetValue(item.Name, (byte[])item.Value);
break;
case ValueType.DWordBigEndian:
k.SetValue(item.Name, (int)Convert.ChangeType(item.Value, typeof(int)));
break;
}
}
}
if (mustSave)
{
await hive.Save(file);
}
}
}
