public bool Equals(MLTProject pProject)
{
return(
pProject != null &&
SourceExists.Equals(pProject.SourceExists) &&
SourceIsValid.Equals(pProject.SourceIsValid) &&
TargetExists.Equals(pProject.TargetExists) &&
TargetIsValid.Equals(pProject.TargetIsValid) &&
TargetName.Equals(pProject.TargetName) &&
TargetPath.Equals(pProject.TargetPath) &&
FullPath.Equals(pProject.FullPath) &&
Job.Equals(pProject.Job) &&
Name.Equals(pProject.Name) &&
SourcePath.Equals(pProject.SourcePath));
}
public override ExitCode Execute()
{
string[] Arguments = this.Params;
ProjectName = ParseParamValue("project", ProjectName);
Targets = ParseParamValue("target", Targets);
Platforms = ParseParamValue("platform", Platforms);
Configurations = ParseParamValue("configuration", Configurations);
Clean = ParseParam("clean") || Clean;
if (string.IsNullOrEmpty(Targets))
{
throw new AutomationException("No target specified with -target. Use -help to see all options");
}
bool NoTools = ParseParam("notools");
IEnumerable <string> TargetList = Targets.Split(new char[] { '+' }, StringSplitOptions.RemoveEmptyEntries);
IEnumerable <UnrealTargetConfiguration> ConfigurationList = null;
IEnumerable <UnrealTargetPlatform> PlatformList = null;
try
{
ConfigurationList = Configurations.Split(new char[] { '+' }, StringSplitOptions.RemoveEmptyEntries)
.Select(C => (UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), C, true)).ToArray();
}
catch (Exception Ex)
{
LogError("Failed to parse configuration string. {0}", Ex.Message);
return(ExitCode.Error_Arguments);
}
try
{
PlatformList = Platforms.Split(new char[] { '+' }, StringSplitOptions.RemoveEmptyEntries)
.Select(C =>
{
UnrealTargetPlatform Platform;
if (!UnrealTargetPlatform.TryParse(C, out Platform))
{
throw new AutomationException("No such platform {0}", C);
}
return(Platform);
}).ToArray();
}
catch (Exception Ex)
{
LogError("Failed to parse configuration string. {0}", Ex.Message);
return(ExitCode.Error_Arguments);
}
FileReference ProjectFile = null;
if (!string.IsNullOrEmpty(ProjectName))
{
ProjectFile = ProjectUtils.FindProjectFileFromName(ProjectName);
if (ProjectFile == null)
{
throw new AutomationException("Unable to find uproject file for {0}", ProjectName);
}
string SourceDirectoryName = Path.Combine(ProjectFile.Directory.FullName, "Source");
if (Directory.Exists(SourceDirectoryName))
{
IEnumerable <string> TargetScripts = Directory.EnumerateFiles(SourceDirectoryName, "*.Target.cs");
foreach (string TargetName in TargetList)
{
string TargetScript = TargetScripts.Where(S => S.IndexOf(TargetName, StringComparison.OrdinalIgnoreCase) >= 0).FirstOrDefault();
if (TargetScript == null && (
TargetName.Equals("Client", StringComparison.OrdinalIgnoreCase) ||
TargetName.Equals("Game", StringComparison.OrdinalIgnoreCase)
)
)
{
// if there's no ProjectGame.Target.cs or ProjectClient.Target.cs then
// fallback to Project.Target.cs
TargetScript = TargetScripts.Where(S => S.IndexOf(ProjectName + ".", StringComparison.OrdinalIgnoreCase) >= 0).FirstOrDefault();
}
if (TargetScript == null)
{
throw new AutomationException("No Target.cs file for target {0} in project {1}", TargetName, ProjectName);
}
string FullName = Path.GetFileName(TargetScript);
TargetNames[TargetName] = Regex.Replace(FullName, ".Target.cs", "", RegexOptions.IgnoreCase);
}
}
}
else
{
Log.TraceWarning("No project specified, will build vanilla UE4 binaries");
}
// Handle content-only projects or when no project was specified
if (TargetNames.Keys.Count == 0)
{
foreach (string TargetName in TargetList)
{
TargetNames[TargetName] = string.Format("UE4{0}", TargetName);
}
}
UE4Build Build = new UE4Build(this);
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
string EditorTarget = TargetList.Where(T => T.EndsWith("Editor", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
IEnumerable <string> OtherTargets = TargetList.Where(T => T != EditorTarget);
UnrealTargetPlatform CurrentPlatform = HostPlatform.Current.HostEditorPlatform;
if (!NoTools)
{
Agenda.AddTarget("UnrealHeaderTool", CurrentPlatform, UnrealTargetConfiguration.Development, ProjectFile);
}
if (string.IsNullOrEmpty(EditorTarget) == false)
{
string TargetName = TargetNames[EditorTarget];
Agenda.AddTarget(TargetName, CurrentPlatform, UnrealTargetConfiguration.Development, ProjectFile);
if (!NoTools)
{
Agenda.AddTarget("UnrealPak", CurrentPlatform, UnrealTargetConfiguration.Development, ProjectFile);
Agenda.AddTarget("ShaderCompileWorker", CurrentPlatform, UnrealTargetConfiguration.Development);
Agenda.AddTarget("UnrealLightmass", CurrentPlatform, UnrealTargetConfiguration.Development);
Agenda.AddTarget("CrashReportClient", CurrentPlatform, UnrealTargetConfiguration.Shipping);
Agenda.AddTarget("CrashReportClientEditor", CurrentPlatform, UnrealTargetConfiguration.Shipping);
}
}
foreach (string Target in OtherTargets)
{
string TargetName = TargetNames[Target];
bool IsServer = Target.EndsWith("Server", StringComparison.OrdinalIgnoreCase);
IEnumerable <UnrealTargetPlatform> PlatformsToBuild = IsServer ? new UnrealTargetPlatform[] { CurrentPlatform } : PlatformList;
foreach (UnrealTargetPlatform Platform in PlatformsToBuild)
{
foreach (UnrealTargetConfiguration Config in ConfigurationList)
{
Agenda.AddTarget(TargetName, Platform, Config);
}
}
}
// Set clean and log
foreach (var Target in Agenda.Targets)
{
if (Clean)
{
Target.Clean = Clean;
}
Log.TraceInformation("Will {0}build {1}", Clean ? "clean and " : "", Target);
}
Build.Build(Agenda, InUpdateVersionFiles: false);
return(ExitCode.Success);
}
private void InitializeAttackVectors()
{
string URL;
URL = ctlConnection1.UseSsl == true ? "https://" : "http://";
URL += ctlConnection1.TargetUrl;
string Method = ctlConnection1.ConnectMethod;
if (Method.Equals(""))
{
return;
}
SafelyChangeCursor(Cursors.WaitCursor);
// Generate StringDict
string TargetName, TargetField;
bool InjectAsString;
TargetName = String.Empty; TargetField = String.Empty;
NameValueCollection Others = new NameValueCollection();
NameValueCollection Cookies = new NameValueCollection();
Others = FormParameters.FormParameters(ref TargetName, ref TargetField, out InjectAsString);
Cookies = FormParameters.Cookies;
if (TargetName.Equals(String.Empty))
{
UserStatus("No Injection Point Found");
SafelyChangeCursor(Cursors.Default);
return;
}
UserStatus("Beginning Preliminary Scan");
try
{
SafelyChangeEnableOfControl(butInitializeInjection, false);
AttackVectorFactory avf;
InjectionOptions opts;
if (optBlindInjection.Checked == true)
{
opts = new BlindInjectionOptions();
((BlindInjectionOptions)opts).Tolerance = _AbsintheState.FilterTolerance;
((BlindInjectionOptions)opts).Delimiter = _AbsintheState.FilterDelimiter;
}
else
{
opts = new ErrorInjectionOptions();
((ErrorInjectionOptions)opts).VerifyVersion = chkVerifyVersion.Checked;
}
opts.TerminateQuery = _AbsintheState.TerminateQuery;
opts.Cookies = Cookies;
opts.WebProxies = _AppSettings.ProxyQueue();
opts.InjectAsString = InjectAsString;
opts.UserAgent = _AbsintheState.UserAgent;
opts.AuthCredentials = ctlUserAuth1.NetworkCredential;
opts.AppendedQuery = _AbsintheState.AppendedText;
avf = new AttackVectorFactory(URL, TargetName, TargetField, Others, Method, opts);
avf.UserStatus += new UserEvents.UserStatusEventHandler(UserStatus);
int PluginNumber = Array.IndexOf(_PluginEntries, _AbsintheState.LoadedPluginName);
IPlugin pt = null;
if (optBlindInjection.Checked)
{
foreach (IPlugin bp in _AbsintheState.PluginList)
{
if (bp.GetType().GetInterface("IBlindPlugin") != null)
{
if (bp.PluginDisplayTargetName == _AbsintheState.LoadedPluginName)
{
pt = (IPlugin)bp;
break;
}
}
}
_AbsintheState.TargetAttackVector = avf.BuildBlindSqlAttackVector(_AbsintheState.FilterTolerance, (IBlindPlugin)pt);
UserStatus("Finished initial scan");
}
else if (optErrorBasedInjection.Checked)
{
if (PluginNumber <= 0)
{
pt = AutoDetectPlugin(avf);
}
else
{
foreach (IPlugin ep in _AbsintheState.PluginList)
{
if (ep.PluginDisplayTargetName == _AbsintheState.LoadedPluginName)
{
pt = (IPlugin)ep;
break;
}
}
}
if (pt != null)
{
try
{
_AbsintheState.TargetAttackVector = avf.BuildSqlErrorAttackVector((IErrorPlugin)pt);
UserStatus("Finished initial scan");
}
catch (UnsupportedSQLErrorVersionException sqlex)
{
ErrorReportingDelegate ts = new ErrorReportingDelegate(ThreadUnsafeDisplayErrorReportDialog);
this.Invoke(ts, new object[] { sqlex.VersionErrorPageHtml, sqlex.HavingErrorPageHtml });
}
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
UserStatus(e.Message);
}
finally
{
SafelyChangeEnableOfControl(butInitializeInjection, true);
SafelyChangeCursor(Cursors.Default);
}
}
