public bool Examine()
{
IList <string> data = new List <string>();
string rewritePath = _path.Replace(Client.Behavior.FolderDelimeter.ToString(),
Client.Behavior.FolderDelimeterString);
if (!_client.SendAndReceive(string.Format(ImapCommands.Examine, rewritePath), ref data))
{
if (Flags.Any())
{
data.Clear();
if (!_client.SendAndReceive(string.Format(ImapCommands.Examine, Flags[0].Trim('\\')), ref data))
{
return(false);
}
}
else
{
return(false);
}
}
ProcessSelectOrExamineResult(data);
return(true);
}
public void WriteUsages()
{
if (!_usages.Any())
{
Console.WriteLine("No documentation for this command");
return;
}
Console.WriteLine(" Usages for '{0}' ({1})", _commandName, _description);
if (_usages.Count == 1)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(" " + _usages.Single().Usage);
Console.ResetColor();
}
else
{
writeMultipleUsages();
}
if (Arguments.Any())
{
writeArguments();
}
if (!Flags.Any())
{
return;
}
writeFlags();
}
public override bool Execute()
{
compiler = new GCC(string.IsNullOrEmpty(CompilerPath) ? DefaultCompiler : CompilerPath);
Logger.Instance = new XBuildLogProvider(Log); // TODO: maybe initialise statically
var flags = (Flags != null && Flags.Any()) ? Flags.Aggregate(string.Empty, (curr, next) => string.Format("{0} {1}", curr, next.ItemSpec)) : string.Empty;
using (var cache = new FileCacheManager(ObjectFilesDirectory))
{
var objectFiles = new List <string>();
var compilationResult = System.Threading.Tasks.Parallel.ForEach(Sources.Select(x => x.ItemSpec), new System.Threading.Tasks.ParallelOptions {
MaxDegreeOfParallelism = Parallel ? -1 : 1
}, (source, loopState) => {
var objectFile = ObjectFilesDirectory == null ? regex.Replace(source, ".o") : string.Format("{0}/{1}", ObjectFilesDirectory, regex.Replace(source, ".o"));
if (!compiler.Compile(source, objectFile, flags, cache.SourceHasChanged))
{
loopState.Break();
}
lock (objectFiles)
{
objectFiles.Add(objectFile);
}
});
if (compilationResult.LowestBreakIteration != null)
{
return(false);
}
ObjectFiles = objectFiles.Any() ? objectFiles.Select(x => new TaskItem(x)).ToArray() : new TaskItem[0];
return(true);
}
}
private void Flag_Changed(object sender, System.Windows.RoutedEventArgs e)
{
Flags.Clear();
foreach (KmlPart part in Parts)
{
if (part.Flag != "" && !Flags.Any(x => x.ToLower() == part.Flag.ToLower()))
{
Flags.Add(part.Flag);
}
}
}
/// <summary>
/// Selects the folder, making messages available for queries
/// </summary>
/// <returns></returns>
public bool Select()
{
if (!Selectable)
{
throw new InvalidOperationException("A non-selectable folder cannot be selected.");
}
if (_client.SelectedFolder == this && !ReadOnly)
{
return(true);
}
if (_client.IdleState == IdleState.On)
{
_client.StopIdling();
}
IList <string> data = new List <string>();
string rewritePath = _path.Replace(Client.Behavior.FolderDelimeter.ToString(),
Client.Behavior.FolderDelimeterString);
if (!_client.SendAndReceive(string.Format(ImapCommands.Select, rewritePath), ref data))
{
if (Flags.Any())
{
data.Clear();
if (!_client.SendAndReceive(string.Format(ImapCommands.Select, Flags[0].Trim('\\')), ref data))
{
return(false);
}
}
else
{
return(false);
}
}
ProcessSelectOrExamineResult(data);
if (_client.SelectedFolder != null)
{
_client.SelectedFolder.ReadOnly = true;
}
_client.SelectedFolder = this;
return(true);
}
public override bool Execute()
{
Logger.Instance = new XBuildLogProvider(Log); // TODO: maybe initialise statically; this put in constructor causes NRE
if (!ObjectFiles.Any())
{
return(true);
}
var lfiles = new List <string>();
var ofiles = ObjectFiles.Select(x => x.ItemSpec);
var flags = (Flags != null && Flags.Any()) ? Flags.Select(x => x.ItemSpec).ToList() : new List <string>();
if (Libraries != null)
{
foreach (var library in Libraries.Select(x => x.ItemSpec))
{
if (File.Exists(library))
{
var directory = Path.GetDirectoryName(library);
var fileName = Path.GetFileName(library);
lfiles.Add(library);
flags.Add(string.Format(" -L{0} -l:{1}", directory, fileName));
}
else
{
flags.Add(string.Format("-l{0}", library));
}
}
}
var joinedFlags = string.Join(" ", flags);
using (var cache = new FileCacheManager(Path.GetDirectoryName(Output)))
{
if (!cache.SourceHasChanged(ofiles.Union(lfiles), joinedFlags) && File.Exists(Output))
{
return(true);
}
}
// linking
var linker = new GLD(string.IsNullOrEmpty(LinkerPath) ? DefaultLinker : LinkerPath);
return(linker.Link(ofiles, Output, joinedFlags));
}
public override string ToString()
{
bool anyFlags = Flags != null && Flags.Any();
bool anyAces = Aces != null && Aces.Any();
StringBuilder sb = new StringBuilder();
if (anyFlags)
{
sb.AppendLineEnv($"{nameof(Flags)}: {string.Join(", ", Flags)}");
}
if (anyAces)
{
for (int i = 0; i < Aces.Length; ++i)
{
sb.AppendLineEnv($"Ace[{i:00}]");
sb.AppendIndentEnv(Aces[i].ToString());
}
}
return(sb.ToString());
}
public JObject ToJObject()
{
bool anyFlags = Flags != null && Flags.Any();
bool anyAces = Aces != null && Aces.Any();
JObject parsedAcl = new JObject();
if (anyFlags)
{
//parsedAcl.Add("Flags", JArray.FromObject(Flags));
}
if (anyAces)
{
int inc = 0;
foreach (Ace ace in Aces)
{
JObject parsedAce = new JObject();
JArray aceFlagsJArray = new JArray();
if (ace.AceFlags != null)
{
aceFlagsJArray = JArray.FromObject(ace.AceFlags);
}
string aceSidAlias = ace.AceSid.Alias;
string aceSidRaw = ace.AceSid.Raw;
string aceType = "";
if (ace.AceType == "ACCESS_ALLOWED")
{
aceType = "Allow";
}
else if (ace.AceType == "ACCESS_DENIED")
{
aceType = "Deny";
}
else
{
aceType = ace.AceType;
}
JArray aceRights = JArray.FromObject(ace.Rights);
string displayName = LDAPstuff.GetUserFromSid(aceSidRaw);
parsedAce.Add("SID", aceSidRaw);
parsedAce.Add("Name", displayName);
parsedAce.Add("Type", aceType);
if (aceRights.Count > 1)
{
parsedAce.Add("Rights", aceRights);
}
else if (aceRights.Count == 1)
{
parsedAce.Add("Rights", aceRights[0].ToString());
}
if (aceFlagsJArray.Count > 1)
{
parsedAce.Add("Flags", aceFlagsJArray);
}
else if (aceFlagsJArray.Count == 1)
{
parsedAce.Add("Flags", aceFlagsJArray[0].ToString());
}
parsedAcl.Add(new JProperty(inc.ToString(), parsedAce));
inc++;
}
}
return(parsedAcl);
}
public override bool Execute()
{
Logger.Instance = new XBuildLogProvider(Log); // TODO: maybe initialise statically; this put in constructor causes NRE
if (!ObjectFiles.Any())
{
return(true);
}
var lfiles = new List <string>();
var ofiles = ObjectFiles.Select(x => x.ItemSpec);
var flags = (Flags != null && Flags.Any()) ? Flags.Select(x => x.ItemSpec).ToList() : new List <string>();
if (Libraries != null)
{
foreach (var library in Libraries.Select(x => x.ItemSpec))
{
if (File.Exists(library))
{
var directory = Path.GetDirectoryName(library);
var fileName = Path.GetFileName(library);
lfiles.Add(library);
flags.Add(string.Format(" -L{0} -l:{1}", directory, fileName));
}
else
{
flags.Add(string.Format("-l{0}", library));
}
}
}
var joinedFlags = string.Join(" ", flags);
using (var cache = new FileCacheManager(Path.GetDirectoryName(Output)))
{
if (!cache.SourceHasChanged(ofiles.Union(lfiles), joinedFlags) && File.Exists(Output))
{
return(true);
}
}
// linking
var linkerPath = string.IsNullOrEmpty(LinkerPath) ? DefaultLinker : LinkerPath;
var linker = new GLD(linkerPath);
try
{
return(linker.Link(ofiles, Output, joinedFlags));
}
catch (Exception e)
{
if (e is Win32Exception error)
{
if (error.NativeErrorCode == Utilities.ErrorFileNotFound)
{
Logger.Instance.LogError($"Could not find \"{LinkerPath}\" linker.");
}
else
{
Logger.Instance.LogError($"An error was encountered while trying to run \"{LinkerPath}\" linker: {e.Message}.");
}
}
else
{
Logger.Instance.LogError($"An unknown exception has been thrown in CLinkerTask. Message: { e.Message }.");
}
return(false);
}
}
/// <summary>
/// Adds a child KmlItem to this nodes lists of children, depending of its
/// derived class KmlNode, KmlPart, KmlAttrib or further derived from these.
/// When an KmlAttrib "Name", "Type" or "Root" are found, their value
/// will be used for the corresponding property of this node.
/// </summary>
/// <param name="beforeItem">The KmlItem where the new item should be inserted before</param>
/// <param name="newItem">The KmlItem to add</param>
protected override void Add(KmlItem beforeItem, KmlItem newItem)
{
if (newItem is KmlAttrib)
{
KmlAttrib attrib = (KmlAttrib)newItem;
if (attrib.Name.ToLower() == "type" && Type.Length == 0)
{
Type = attrib.Value;
// Get notified when Type changes
attrib.AttribValueChanged += Type_Changed;
attrib.CanBeDeleted = false;
}
else if (attrib.Name.ToLower() == "sit" && Situation.Length == 0)
{
Situation = attrib.Value;
// Get notified when Type changes
attrib.AttribValueChanged += Situation_Changed;
attrib.CanBeDeleted = false;
}
else if (attrib.Name.ToLower() == "root" && RootPart == null)
{
SetRootPart(attrib.Value);
// Get notified when Type changes
attrib.AttribValueChanged += Root_Changed;
attrib.CanBeDeleted = false;
}
}
else if (newItem is KmlPart)
{
KmlPart part = (KmlPart)newItem;
if (beforeItem != null)
{
KmlPart beforePart = null;
int allIndex = AllItems.IndexOf(beforeItem);
for (int i = allIndex; i < AllItems.Count; i++)
{
if (AllItems[i] is KmlPart && Parts.Contains((KmlPart)AllItems[i]))
{
beforePart = (KmlPart)AllItems[i];
break;
}
}
if (beforePart != null)
{
beforePart.InsertionPreparation();
Parts.Insert(Parts.IndexOf(beforePart), part);
beforePart.InsertionFinalization();
}
else
{
Parts.Add(part);
}
}
else
{
Parts.Add(part);
}
if (Parts.Count == rootPartIndex + 1)
{
RootPart = Parts[rootPartIndex];
}
if (part.Flag != "" && !Flags.Any(x => x.ToLower() == part.Flag.ToLower()))
{
Flags.Add(part.Flag);
}
if (part.HasResources)
{
foreach (string resType in part.ResourceTypes)
{
ResourceTypes.Add(resType);
}
}
KmlAttrib flag = part.GetAttrib("flag");
if (flag != null)
{
flag.AttribValueChanged += Flag_Changed;
}
}
base.Add(beforeItem, newItem);
}
public JObject ToJObject()
{
bool anyFlags = Flags != null && Flags.Any();
bool anyAces = Aces != null && Aces.Any();
JObject parsedAcl = new JObject();
if (anyFlags)
{
//parsedAcl.Add("Flags", JArray.FromObject(Flags));
}
if (anyAces)
{
int inc = 0;
foreach (Ace ace in Aces)
{
JObject parsedAce = new JObject();
JArray aceFlagsJArray = new JArray();
if (ace.AceFlags != null)
{
aceFlagsJArray = JArray.FromObject(ace.AceFlags);
}
string aceSidAlias = ace.AceSid.Alias;
string aceSidRaw = ace.AceSid.Raw;
string aceType;
if ((ace.AceType == "ACCESS_ALLOWED") || (ace.AceType == "OBJECT_ACCESS_ALLOWED"))
{
aceType = "Allow";
}
else if ((ace.AceType == "ACCESS_DENIED") || (ace.AceType == "OBJECT_ACCESS_DENIED"))
{
aceType = "Deny";
}
else
{
aceType = ace.AceType;
}
Dictionary <string, string> boringRights = new Dictionary <string, string>()
{
{ "READ_CONTROL", "Read ACL" },
{ "SYNCHRONIZE", "Synchronize" },
{ "GENERIC_EXECUTE", "Execute" },
{ "GENERIC_READ", "Read" },
{ "READ_PROPERTY", "Read Property" },
{ "LIST_CHILDREN", "List Children" },
{ "LIST_OBJECT", "List Object" }
};
Dictionary <string, string> interestingRights = new Dictionary <string, string>()
{
{ "KEY_ALL", "Full Control" },
{ "DELETE_TREE", "Delete Tree" },
{ "STANDARD_DELETE", "Delete" },
{ "CREATE_CHILD", "Create Child" },
{ "DELETE_CHILD", "Delete Child" },
{ "WRITE_PROPERTY", "Write Property" },
{ "GENERIC_ALL", "Full Control" },
{ "GENERIC_WRITE", "Write" },
{ "WRITE_DAC", "Write ACL" },
{ "WRITE_OWNER", "Write Owner" },
{ "STANDARD_RIGHTS_ALL", "Full Control" },
{ "STANDARD_RIGHTS_REQUIRED", "Delete, Write DACL, Write Owner" },
{ "CONTROL_ACCESS", "Extended Rights" },
{ "SELF_WRITE", "Self Write" }
};
JArray aceRightsJArray = new JArray();
foreach (string right in ace.Rights)
{
// if the right is interesting, we'll take it
if (interestingRights.ContainsKey(right))
{
aceRightsJArray.Add(interestingRights[right]);
continue;
}
// if it's boring and we're not showing defaults, we'll skip it.
else if ((boringRights.ContainsKey(right)) && (GlobalVar.IntLevelToShow > 0))
{
continue;
}
else if ((boringRights.ContainsKey(right)) && (GlobalVar.IntLevelToShow == 0))
{
aceRightsJArray.Add(boringRights[right]);
continue;
}
else
{
// KEY_READ will land here. not sure what to do with it cos reading the right registry key is of course very interesting, but those cases are going to be pretty rare.
// Might have to handle further downstream?
Utility.Output.DebugWrite(right + " was not defined as either boring or interesting. Consider adding it to the dicts in Acl.cs?");
aceRightsJArray.Add(right);
}
}
string displayName = LDAPstuff.GetUserFromSid(aceSidRaw);
parsedAce.Add("SID", aceSidRaw);
parsedAce.Add("Name", displayName);
parsedAce.Add("Type", aceType);
if (aceRightsJArray.Count > 1)
{
parsedAce.Add("Rights", aceRightsJArray);
}
else if (aceRightsJArray.Count == 1)
{
parsedAce.Add("Rights", aceRightsJArray[0].ToString());
}
if (aceFlagsJArray.Count > 1)
{
parsedAce.Add("Flags", aceFlagsJArray);
}
else if (aceFlagsJArray.Count == 1)
{
parsedAce.Add("Flags", aceFlagsJArray[0].ToString());
}
parsedAcl.Add(new JProperty(inc.ToString(), parsedAce));
inc++;
}
}
return(parsedAcl);
}
public override bool Execute()
{
compiler = new GCC(string.IsNullOrEmpty(CompilerPath) ? DefaultCompiler : CompilerPath);
Logger.Instance = new XBuildLogProvider(Log); // TODO: maybe initialise statically
var flags = (Flags != null && Flags.Any()) ? Flags.Aggregate(string.Empty, (curr, next) => string.Format("{0} {1}", curr, next.ItemSpec)) : string.Empty;
using (var cache = new FileCacheManager(ObjectFilesDirectory))
{
var objectFiles = new List <string>();
System.Threading.Tasks.ParallelLoopResult compilationResult;
try
{
// We normalize the directory separator in paths to make handling of gcc -MM easier.
var sourceFiles = System.IO.Path.DirectorySeparatorChar == '\\'
? Sources.Select(x => x.ItemSpec.Replace("\\", "/"))
: Sources.Select(x => x.ItemSpec);
compilationResult = System.Threading.Tasks.Parallel.ForEach(sourceFiles, new System.Threading.Tasks.ParallelOptions {
MaxDegreeOfParallelism = Parallel ? -1 : 1
}, (source, loopState) =>
{
var objectFile = ObjectFilesDirectory == null ? regex.Replace(source, ".o") : string.Format("{0}/{1}", ObjectFilesDirectory, regex.Replace(source, ".o"));
if (!compiler.Compile(source, objectFile, flags, cache.SourceHasChanged))
{
loopState.Break();
}
lock (objectFiles)
{
objectFiles.Add(objectFile);
}
});
}
catch (Exception e)
{
if (e.InnerException is Win32Exception error)
{
if (error.NativeErrorCode == Utilities.ErrorFileNotFound)
{
Logger.Instance.LogError($"Could not find \"{CompilerPath}\" compiler.");
}
else
{
Logger.Instance.LogError($"An error was encountered while trying to run \"{CompilerPath}\" compiler: {e.InnerException.Message}.");
}
}
else
{
Logger.Instance.LogError($"An unknown exception has been thrown in CCompilerTask. Message: { e.InnerException?.Message ?? e.Message }.");
}
return(false);
}
if (compilationResult.LowestBreakIteration != null)
{
return(false);
}
ObjectFiles = objectFiles.Any() ? objectFiles.Select(x => new TaskItem(x)).ToArray() : new TaskItem[0];
return(true);
}
}
public void Run(string[] args)
{
var ctx = new Context();
// 初期値設定
foreach (var flag in Flags)
{
ctx.GlobalFlagValues.Add(flag.Name, flag.Value);
}
Action <Context> action = Action == null ? writeHelpText: Action;
// ContextのFlag、Args設定
Command command = null;
for (int i = 0; i < args.Length; i++)
{
var arg = args[i];
// Option
if (arg.Substring(0, 1) == "-")
{
string optionName = arg.Substring(0, 2) == "--" ? arg.Substring(2) : arg.Substring(1);
if (command is null)
{
// Global Options
if (!Flags.Any(x => x.Names().Any(x => x == optionName)))
{
continue;
}
Flag flag = Flags.First(x => x.Names().Any(x => x == optionName));
if (flag is BoolFlag)
{
ctx.GlobalFlagValues[flag.Name] = true;
}
else
{
if (i + 1 < args.Length)
{
ctx.GlobalFlagValues[flag.Name] = args[++i];
}
}
}
else
{
// Command Options
Flag flag;
if (command.Flags.Any(x => x.Names().Any(x => x == optionName)))
{
flag = command.Flags.First(x => x.Names().Any(x => x == optionName));
}
else if (Flags.Any(x => x.Names().Any(x => x == optionName)))
{
flag = Flags.First(x => x.Names().Any(x => x == optionName));
}
else
{
continue;
}
if (flag is BoolFlag)
{
ctx.FlagValues[flag.Name] = true;
}
else
{
if (i + 1 < args.Length)
{
ctx.FlagValues[flag.Name] = args[++i];
}
}
}
}
else
{
// Command or args
if (command is null)
{
if (Commands.Any(x => x.Names().Any(x => x == arg)))
{
command = Commands.First(x => x.Names().Any(x => x == arg));
}
else
{
ctx.Args = args.Skip(i).ToArray();
break;
}
}
else
{
if (command.SubCommands.Any(x => x.Names().Any(x => x == arg)))
{
command = command.SubCommands.First(x => x.Names().Any(x => x == arg));
}
else
{
ctx.Args = args.Skip(i).ToArray();
break;
}
}
}
}
if (command is not null)
{
action = command.Action;
}
action.Invoke(ctx);
}
