mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
339 lines
9.7 KiB
C#
339 lines
9.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.IO;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
|
|
using DamienG.Security.Cryptography;
|
|
|
|
namespace SabreTools
|
|
{
|
|
/*
|
|
TODO: Add the following flags:
|
|
Remove MD5
|
|
Remove SHA1
|
|
Set forceunpacking
|
|
Zips as files
|
|
Old style DATs
|
|
Set all of the fields in the DAT header
|
|
Auto set Name and Description from current folder
|
|
Version and date from current date
|
|
*/
|
|
|
|
class DATFromDir
|
|
{
|
|
// Path-related variables
|
|
private static string _7zPath;
|
|
private static string _basePath;
|
|
private static string _tempDir;
|
|
|
|
// Extraction and listing related variables
|
|
private static char _delim;
|
|
private static string _baseExtract;
|
|
private static ProcessStartInfo _psi;
|
|
private static List<Tuple<string, string, long, string, string, string>> _roms;
|
|
|
|
// User specified variables
|
|
private static bool _remMD5;
|
|
private static bool _remSHA1;
|
|
private static bool _forceunzip;
|
|
private static bool _allfiles;
|
|
private static bool _old;
|
|
private static string _name;
|
|
private static string _desc;
|
|
private static string _cat;
|
|
|
|
// Other required variables
|
|
private static string _version = DateTime.Now.ToString("yyyyMMddHHmmss");
|
|
|
|
static void Main(string[] args)
|
|
{
|
|
// First things first, take care of all of the arguments that this could have
|
|
_remMD5 = false; _remSHA1 = false; _forceunzip = false; _allfiles = false; _old = false;
|
|
_name = ""; _desc = ""; _cat = "SabreTools Dir2DAT";
|
|
List<string> inputs = new List<string>();
|
|
foreach (string arg in args)
|
|
{
|
|
switch (arg)
|
|
{
|
|
case "-m":
|
|
case "--noMD5":
|
|
_remMD5 = true;
|
|
break;
|
|
case "-s":
|
|
case "--noSHA1":
|
|
_remSHA1 = true;
|
|
break;
|
|
case "-u":
|
|
case "--unzip":
|
|
_forceunzip = true;
|
|
break;
|
|
case "-f":
|
|
case "--files":
|
|
_allfiles = true;
|
|
break;
|
|
case "-o":
|
|
case "--old":
|
|
_old = true;
|
|
break;
|
|
default:
|
|
if (arg.StartsWith("-n=") || arg.StartsWith("--name="))
|
|
{
|
|
_name = arg.Split('=')[1];
|
|
}
|
|
else if (arg.StartsWith("-d=") || arg.StartsWith("--desc="))
|
|
{
|
|
_desc = arg.Split('=')[1];
|
|
}
|
|
else if (arg.StartsWith("-c=") || arg.StartsWith("--cat="))
|
|
{
|
|
_cat = arg.Split('=')[1];
|
|
}
|
|
else
|
|
{
|
|
inputs.Add(arg);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Determine the deliminator that is to be used
|
|
if (Environment.CurrentDirectory.Contains("\\"))
|
|
{
|
|
_delim = '\\';
|
|
}
|
|
else
|
|
{
|
|
_delim = '/';
|
|
}
|
|
|
|
// Set local paths and vars
|
|
_7zPath = Environment.CurrentDirectory + _delim + "7z" + (Environment.Is64BitOperatingSystem ? _delim + "x64" : "") + _delim;
|
|
_tempDir = Environment.CurrentDirectory + _delim + "temp" + DateTime.Now.ToString("yyyyMMddHHmmss") + _delim;
|
|
_basePath = (args.Length == 0 ? Environment.CurrentDirectory + _delim : (File.Exists(args[0]) ? args[0] : args[0] + _delim));
|
|
_name = (_name == "" ? _basePath.Split(_delim).Last() : _name);
|
|
_desc = (_desc == "" ? _name + " (" + _version + ")" : _desc);
|
|
|
|
// Set base arguments to be used
|
|
_baseExtract = "x -o\"" + _tempDir + "\"";
|
|
|
|
// Set the basic Process information for 7za
|
|
_psi = new ProcessStartInfo
|
|
{
|
|
Arguments = "",
|
|
FileName = _7zPath + "7za.exe",
|
|
RedirectStandardError = true,
|
|
RedirectStandardOutput = true,
|
|
UseShellExecute = false,
|
|
};
|
|
|
|
// Get an output array going that has the right mappings (parent, name, size, hash)
|
|
_roms = new List<Tuple<string, string, long, string, string, string>>();
|
|
|
|
// This is where the main loop would go
|
|
if (File.Exists(_basePath))
|
|
{
|
|
ProcessFile(_basePath);
|
|
}
|
|
else
|
|
{
|
|
foreach (string item in Directory.GetFiles(_basePath, "*", SearchOption.AllDirectories))
|
|
{
|
|
ProcessFile(item);
|
|
}
|
|
}
|
|
|
|
// Order the roms by name of parent, then name of rom
|
|
_roms.Sort(delegate (Tuple<string, string, long, string, string, string> A, Tuple<string, string, long, string, string, string> B)
|
|
{
|
|
if (A.Item1 == B.Item1)
|
|
{
|
|
if (A.Item2 == B.Item2)
|
|
{
|
|
return (int)(A.Item3 - B.Item3);
|
|
}
|
|
return String.Compare(A.Item2, B.Item2);
|
|
}
|
|
return String.Compare(A.Item1, B.Item1);
|
|
});
|
|
|
|
//TODO: So, this below section is a pretty much one for one copy of code that is written in generate
|
|
// this means that in the future, "writing to DAT" will be abstracted out to the DLL so that any
|
|
// properly formatted data can be passed in and it will get written as necessary. That would open
|
|
// the possibiliites for different ways to generate a DAT from multiple things
|
|
|
|
// Now write it all out as a DAT
|
|
try
|
|
{
|
|
FileStream fs = File.Create(_desc + ".xml");
|
|
StreamWriter sw = new StreamWriter(fs, Encoding.UTF8);
|
|
|
|
string header = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
|
|
"<!DOCTYPE datafile PUBLIC \"-//Logiqx//DTD ROM Management Datafile//EN\" \"http://www.logiqx.com/Dats/datafile.dtd\">\n\n" +
|
|
"\t<datafile>\n" +
|
|
"\t\t<header>\n" +
|
|
"\t\t\t<name>" + _name + "</name>\n" +
|
|
"\t\t\t<description>" + _desc + "</description>\n" +
|
|
"\t\t\t<category>SabreTools Dir2DAT</category>\n" +
|
|
"\t\t\t<version>" + _version + "</version>\n" +
|
|
"\t\t\t<date>" + _version + "</date>\n" +
|
|
"\t\t\t<author>Darksabre76</author>\n" +
|
|
"\t\t\t<clrmamepro " + (_forceunzip ? "forcepacking=\"unzip\" " : "") + " />\n" +
|
|
"\t\t</header>\n";
|
|
|
|
// Write the header out
|
|
sw.Write(header);
|
|
|
|
// Write out each of the machines and roms
|
|
string lastgame = "";
|
|
foreach (Tuple<string, string, long, string, string, string> rom in _roms)
|
|
{
|
|
string state = "";
|
|
if (lastgame != "" && lastgame != rom.Item1)
|
|
{
|
|
state += "\t</machine>\n";
|
|
}
|
|
|
|
if (lastgame != rom.Item1)
|
|
{
|
|
state += "\t<machine name=\"" + HttpUtility.HtmlEncode(rom.Item1) + "\">\n" +
|
|
"\t\t<description>" + HttpUtility.HtmlEncode(rom.Item1) + "</description>\n";
|
|
}
|
|
|
|
state += "\t\t<rom name=\"" + HttpUtility.HtmlEncode(rom.Item2) + "\"" +
|
|
(rom.Item3 != -1 ? " size=\"" + rom.Item3 + "\"" : "") +
|
|
(rom.Item4 != "" ? " crc=\"" + rom.Item4.ToLowerInvariant() + "\"" : "") +
|
|
(rom.Item5 != "" ? " md5=\"" + rom.Item5.ToLowerInvariant() + "\"" : "") +
|
|
(rom.Item6 != "" ? " sha1=\"" + rom.Item6.ToLowerInvariant() + "\"" : "") +
|
|
" />\n";
|
|
|
|
lastgame = rom.Item1;
|
|
|
|
sw.Write(state);
|
|
}
|
|
|
|
sw.Write("\t</machine>\n</datafile>");
|
|
Console.Write("File written!");
|
|
sw.Close();
|
|
fs.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.Write(ex.ToString());
|
|
}
|
|
}
|
|
|
|
private static void ProcessFile (string item)
|
|
{
|
|
// Create the temporary output directory
|
|
Directory.CreateDirectory(_tempDir);
|
|
|
|
_psi.Arguments = _baseExtract + " " + item;
|
|
Process zip = Process.Start(_psi);
|
|
zip.WaitForExit();
|
|
|
|
bool encounteredErrors = zip.StandardError.ReadToEnd().Contains("ERROR");
|
|
|
|
// Get a list of files including size and hashes
|
|
Crc32 crc = new Crc32();
|
|
MD5 md5 = MD5.Create();
|
|
SHA1 sha1 = SHA1.Create();
|
|
|
|
// If the file was an archive and was extracted successfully, check it
|
|
if (!encounteredErrors)
|
|
{
|
|
foreach (string entry in Directory.GetFiles(_tempDir, "*", SearchOption.AllDirectories))
|
|
{
|
|
string fileCRC = String.Empty;
|
|
string fileMD5 = String.Empty;
|
|
string fileSHA1 = String.Empty;
|
|
|
|
try
|
|
{
|
|
using (FileStream fs = File.Open(entry, FileMode.Open))
|
|
{
|
|
foreach (byte b in crc.ComputeHash(fs))
|
|
{
|
|
fileCRC += b.ToString("x2").ToLower();
|
|
}
|
|
}
|
|
using (FileStream fs = File.Open(entry, FileMode.Open))
|
|
{
|
|
fileMD5 = BitConverter.ToString(md5.ComputeHash(fs)).Replace("-", "");
|
|
}
|
|
using (FileStream fs = File.Open(entry, FileMode.Open))
|
|
{
|
|
fileSHA1 = BitConverter.ToString(sha1.ComputeHash(fs)).Replace("-", "");
|
|
}
|
|
}
|
|
catch (IOException)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
_roms.Add(new Tuple<string, string, long, string, string, string>(
|
|
Path.GetFileNameWithoutExtension(item),
|
|
entry.Remove(0, _tempDir.Length),
|
|
(new FileInfo(entry)).Length,
|
|
fileCRC,
|
|
fileMD5,
|
|
fileSHA1));
|
|
|
|
Console.WriteLine("File parsed: " + entry.Remove(0, _tempDir.Length));
|
|
}
|
|
}
|
|
// Otherwise, just get the info on the file itself
|
|
else if (!Directory.Exists(item) && File.Exists(item))
|
|
{
|
|
string fileCRC = String.Empty;
|
|
string fileMD5 = String.Empty;
|
|
string fileSHA1 = String.Empty;
|
|
|
|
try
|
|
{
|
|
using (FileStream fs = File.Open(item, FileMode.Open))
|
|
{
|
|
foreach (byte b in crc.ComputeHash(fs))
|
|
{
|
|
fileCRC += b.ToString("x2").ToLower();
|
|
}
|
|
}
|
|
using (FileStream fs = File.Open(item, FileMode.Open))
|
|
{
|
|
fileMD5 = BitConverter.ToString(md5.ComputeHash(fs)).Replace("-", "");
|
|
}
|
|
using (FileStream fs = File.Open(item, FileMode.Open))
|
|
{
|
|
fileSHA1 = BitConverter.ToString(sha1.ComputeHash(fs)).Replace("-", "");
|
|
}
|
|
|
|
string actualroot = (item == _basePath ? "Default" : Path.GetDirectoryName(item.Remove(0, _basePath.Length)).Split(_delim)[0]);
|
|
actualroot = (actualroot == "" ? "Default" : actualroot);
|
|
string actualitem = (item == _basePath ? item : item.Remove(0, _basePath.Length).Remove(0, (actualroot != "Default" ? actualroot.Length + 1 : 0)));
|
|
|
|
_roms.Add(new Tuple<string, string, long, string, string, string>(
|
|
actualroot,
|
|
actualitem,
|
|
(new FileInfo(item)).Length,
|
|
fileCRC,
|
|
fileMD5,
|
|
fileSHA1));
|
|
|
|
Console.WriteLine("File parsed: " + item.Remove(0, _basePath.Length));
|
|
}
|
|
catch (IOException) { }
|
|
}
|
|
|
|
// Delete the temp directory
|
|
if (Directory.Exists(_tempDir))
|
|
{
|
|
Directory.Delete(_tempDir, true);
|
|
}
|
|
}
|
|
}
|
|
}
|