private void BeginConversion(object sender, EventArgs e) { // Protects against potentially deleted paths Directory.CreateDirectory(Shared.OutDir); Shared.Worker = sender as BackgroundWorker; IAT.GroupSheets = groupSheets.Checked; IAT.GroupSims = groupSimulations.Checked; IAT.Run(iat); NABSA.Run(nabsa); }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnConvertClicked(object sender, EventArgs e) { // Ensure the output directory exists if (!Directory.Exists(outentry.Text)) { try { Directory.CreateDirectory(outentry.Text); } catch { new DialogBox("Invalid output directory."); return; } } List <string> files = new List <string>(); foreach (CheckButton child in listbox.AllChildren) { if (child.Active) { files.Add(path + "/" + child.Label); } } switch (combobox.ActiveText) { case "IAT": IAT.GroupSheets = joincheck.Active; IAT.GroupSims = splitcheck.Active; IAT.Run(files); break; case "NABSA": NABSA.Run(files); break; default: break; } }
static void Main(string[] args) { // A lock to proccess requests non concurrently // FAtiMA-Toolkit is not thread safe Object l = new Object(); AssetManager.Instance.Bridge = new BasicIOBridge(); // FAtiMA stuff IntegratedAuthoringToolAsset IAT; Dictionary <string, RolePlayCharacterAsset> RPCs = new Dictionary <string, RolePlayCharacterAsset>(); // Ensure that the save directory exists Directory.CreateDirectory("Saved Characters"); // Loading the Scenario // Need to use fullpaths for everything due to FAtiMA's handling of paths Console.Write("Loading Scenario..."); IAT = IntegratedAuthoringToolAsset.LoadFromFile(Path.GetFullPath("Example Character\\FAtiMA-DST.iat")); Console.WriteLine(" Done"); WebServer ws = new WebServer( (HttpListenerRequest request) => { lock (l) { Char[] delimiters = { '/' }; String[] splitted = request.RawUrl.Split(delimiters); if (splitted.Length < 3) { throw new Exception("Invalid number of arguments for the request."); } RolePlayCharacterAsset RPC; // Check if the referenced RPC already exists (either loaded or saved) and create or load it if (!RPCs.ContainsKey(splitted[1])) { try { // Try and load it from a saved file string s = Path.GetFullPath("Saved Characters\\" + splitted[1] + ".rpc"); Console.Write("Loading from saved file... "); RPC = RolePlayCharacterAsset.LoadFromFile(s); RPC.LoadAssociatedAssets(); // Bind ValidDialogue dynamic property to RPC IAT.BindToRegistry(RPC.DynamicPropertiesRegistry); RPCs.Add(splitted[1], RPC); Console.WriteLine("Done"); } catch { // If it fails we need to load it from the default RPC in the scenario string s = IAT.GetAllCharacterSources().FirstOrDefault().Source; Console.Write("No save file found, loading from default character... "); RPC = RolePlayCharacterAsset.LoadFromFile(s); RPC.LoadAssociatedAssets(); // Bind ValidDialogue dynamic property to RPC IAT.BindToRegistry(RPC.DynamicPropertiesRegistry); RPCs.Add(splitted[1], RPC); Console.WriteLine("Done"); } } else { // The RPC should exist (already checked) // If we get an error it should stop processing the request with the error // So there is no handling for the ArgumentNullException RPCs.TryGetValue(splitted[1], out RPC); } // Process the request switch (splitted[2]) { case "perceptions": if (request.HasEntityBody) { using (System.IO.Stream body = request.InputStream) // here we have data { using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding)) { string e = reader.ReadToEnd(); var p = JsonConvert.DeserializeObject <Perceptions>(e); p.UpdatePerceptions(RPC); return(JsonConvert.True); } } } return(JsonConvert.Null); case "decide": // If there is a layer for the decision, use it IEnumerable <ActionLibrary.IAction> decision; if (splitted.Count() > 3 && splitted[3] != "") { decision = RPC.Decide((Name)splitted[3]); } else { decision = RPC.Decide(); } if (decision.Count() < 1) { return(JsonConvert.Null); } Action action = Action.ToAction(decision.First(), IAT); string t = decision.Count().ToString() + ": "; foreach (ActionLibrary.IAction a in decision) { t += a.Name + " = (" + a.Target + ", " + a.Utility + "); "; } Debug.WriteLine(t); return(JsonConvert.SerializeObject(action)); case "events": if (request.HasEntityBody) { using (System.IO.Stream body = request.InputStream) // here we have data { using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding)) { string s = reader.ReadToEnd(); var e = JsonConvert.DeserializeObject <Event>(s); e.Perceive(RPC); return(JsonConvert.True); } } } return(JsonConvert.Null); default: return(JsonConvert.Null); } } } , "http://localhost:8080/"); ws.Run(); Console.WriteLine("Press a key to stop the server and save currently loaded characters."); Console.ReadKey(); Console.WriteLine("Stopping Server..."); ws.Stop(); Console.Write("Saving Characters to files... "); foreach (KeyValuePair <string, RolePlayCharacterAsset> pair in RPCs) { pair.Value.SaveToFile(Path.GetFullPath("Saved Characters\\" + pair.Key + ".rpc")); } Console.WriteLine("Saved {0} characters successfuly.", RPCs.Count); Console.WriteLine("Press a key to exit the application..."); Console.ReadKey(); }
private static void WritePE(FileStream fs, CodeInformation code_info, bool verbose) { //header information Image_Header header = new Image_Header(); List <List <Image_IAT_Header> > IAT_Headers = new List <List <Image_IAT_Header> >(); List <Image_Import_Header> IIH_Headers = new List <Image_Import_Header>(); //correct alignment if necessary if (code_info.FileAlignment > 0) { header.OptionalHeader.FileAlignment = code_info.FileAlignment; } if (code_info.SectionAlignment > 0) { header.OptionalHeader.SectionAlignment = code_info.SectionAlignment; } //temporary variables byte[] temp; byte[] temp2; uint offset; uint offset_calculation; //Data Sections MemoryStream RData_Section = new MemoryStream(); MemoryStream Data_Section = new MemoryStream(); MemoryStream RData_stringTable = new MemoryStream(); //Virtual Address locations uint Code_RVA = header.OptionalHeader.SectionAlignment; uint RData_RVA = AlignTo(Code_RVA + (uint)code_info.Code.Length, header.OptionalHeader.SectionAlignment); uint Data_RVA = 0; //Import header offsets uint total_IAT_offset = 0; uint import_header_offset = 0; #region imports if (code_info.SymbolInfo.Count > 0) { /* * [IAT1]....[IAT_n] * [Import_Header1][Import_Header2]...[Import_Headers_n] * [IAT1]....[IAT_n] * for(0...n) [0000 + function_name_1 + 00]....[0000 + function_name_n + 00] */ //Add in the placeholder headers foreach (var DLL in code_info.SymbolInfo) { IIH_Headers.Add(new Image_Import_Header()); List <Image_IAT_Header> current_IAT = DLL.Functions.Select(function => new Image_IAT_Header()).ToList(); IAT_Headers.Add(current_IAT); } //handle the first IAT list for (int i = 0; i < IIH_Headers.Count; i++) { IIH_Headers[i].ImportAddressTableAddress = RData_RVA + total_IAT_offset; foreach (CodeInformation.FunctionInformation function in code_info.SymbolInfo[i].Functions) { foreach (var replacement in function.Replacements) { offset_calculation = header.OptionalHeader.ImageBase + RData_RVA + total_IAT_offset; code_info.Code[replacement + 0] = (byte)(offset_calculation >> 0); code_info.Code[replacement + 1] = (byte)(offset_calculation >> 8); code_info.Code[replacement + 2] = (byte)(offset_calculation >> 16); code_info.Code[replacement + 3] = (byte)(offset_calculation >> 24); } total_IAT_offset += 4; } total_IAT_offset += 4; } header.OptionalHeader.DataDirectory[12].VirtualAddress = RData_RVA; header.OptionalHeader.DataDirectory[12].Size = total_IAT_offset; import_header_offset += RData_RVA + total_IAT_offset + ((uint)IIH_Headers.Count + 1) * 0x14; header.OptionalHeader.DataDirectory[1].VirtualAddress = RData_RVA + total_IAT_offset; header.OptionalHeader.DataDirectory[1].Size = (((uint)IIH_Headers.Count) + 1) * 0x14; //handle the second IAT list for (int i = 0; i < IIH_Headers.Count; i++) { IIH_Headers[i].ImportLookUpTableAddress = import_header_offset; import_header_offset += ((uint)IAT_Headers[i].Count + 1) * 4; } //handle function names and what not for (int i = 0; i < IAT_Headers.Count; i++) { for (int j = 0; j < IAT_Headers[i].Count; j++) { var func = code_info.SymbolInfo[i].Functions[j]; IAT_Headers[i][j].Address = import_header_offset; //write ordinal + function name + null temp = BitConverter.GetBytes((short)func.Ordinal); RData_stringTable.Write(temp, 0, temp.Length); temp = Encoding.UTF8.GetBytes(func.FunctionName); RData_stringTable.Write(temp, 0, temp.Length); RData_stringTable.WriteByte(0); import_header_offset += 2 + (uint)temp.Length + 1; } IIH_Headers[i].NameAddress = import_header_offset; temp = Encoding.UTF8.GetBytes(code_info.SymbolInfo[i].LibraryName); RData_stringTable.Write(temp, 0, temp.Length); RData_stringTable.WriteByte(0); import_header_offset += (uint)temp.Length + 1; } foreach (var IAT in IAT_Headers) { IAT.Add(new Image_IAT_Header()); } //add in the null header to signify the end of the list IIH_Headers.Add(new Image_Import_Header()); //this is awful and it works //convert all headers into their byte equivalent, then concatenate them all together temp = IAT_Headers .Select(x => x .Select(y => y.ToBytes()) .Aggregate((a, b) => a .Concat(b) .ToArray())) .Aggregate((a, b) => a .Concat(b) .ToArray()); temp2 = IIH_Headers .Select(x => x.ToBytes()) .Aggregate((a, b) => a.Concat(b).ToArray()); RData_Section.Write(temp, 0, temp.Length); RData_Section.Write(temp2, 0, temp2.Length); RData_Section.Write(temp, 0, temp.Length); //CopyTo doesn't seem to work 100% of the time. Maybe a bug with .NET //RData_stringTable.CopyTo(RData_Section); temp = RData_stringTable.GetBuffer(); RData_Section.Write(temp, 0, (int)RData_stringTable.Length); } #endregion #region Data Table //Correct Data RVA Data_RVA = AlignTo((uint)(RData_RVA + RData_Section.Length), header.OptionalHeader.SectionAlignment); //string table replacements offset = 0; foreach (CodeInformation.StringTableInformation stringInfo in code_info.StringTable) { temp = Encoding.UTF8.GetBytes(stringInfo.Text); foreach (int replacement in stringInfo.Replacements) { offset_calculation = header.OptionalHeader.ImageBase + Data_RVA + offset; code_info.Code[replacement + 0] = (byte)(offset_calculation >> 0); code_info.Code[replacement + 1] = (byte)(offset_calculation >> 8); code_info.Code[replacement + 2] = (byte)(offset_calculation >> 16); code_info.Code[replacement + 3] = (byte)(offset_calculation >> 24); } Data_Section.Write(temp, 0, temp.Length); Data_Section.WriteByte(0); offset += (uint)(temp.LongLength + 1); } #endregion #region Header //I don't want to hard code this as 0x170 because I might (maybe) add in more sections, and forget to change this //though at the moment with what's coded already, we're wasting a huge amount of time calculating this temp = header.ToBytes(); uint raw_header_length = (uint)temp.LongLength; uint header_length = AlignTo(raw_header_length, header.OptionalHeader.FileAlignment); //.code section header.Text_Section.VirtualSize = (uint)code_info.Code.LongLength; header.Text_Section.SizeOfRawData = AlignTo((uint)code_info.Code.LongLength, header.OptionalHeader.FileAlignment); header.Text_Section.VirtualAddress = Code_RVA; header.Text_Section.PointerToRawData = header_length; //.rdata section header.RData_Section.VirtualSize = (uint)RData_Section.Length + 1; header.RData_Section.SizeOfRawData = AlignTo((uint)RData_Section.Length, header.OptionalHeader.FileAlignment); header.RData_Section.VirtualAddress = RData_RVA; header.RData_Section.PointerToRawData = header_length + header.Text_Section.SizeOfRawData; //.data section header.Data_Section.VirtualSize = (uint)Data_Section.Length; header.Data_Section.SizeOfRawData = AlignTo((uint)Data_Section.Length, header.OptionalHeader.FileAlignment); header.Data_Section.VirtualAddress = Data_RVA; header.Data_Section.PointerToRawData = header.RData_Section.PointerToRawData + header.RData_Section.SizeOfRawData; header.OptionalHeader.Subsystem = code_info.Subsystem; header.OptionalHeader.AddressOfEntryPoint = code_info.EntryPoint + Code_RVA; header.OptionalHeader.BaseOfCode = Code_RVA; header.OptionalHeader.BaseOfData = RData_RVA; header.OptionalHeader.SizeOfHeaders = AlignTo((uint)RData_Section.Length, header.OptionalHeader.FileAlignment) + AlignTo((uint)Data_Section.Length, header.OptionalHeader.FileAlignment); header.OptionalHeader.SizeOfInitializedData = header.OptionalHeader.SizeOfHeaders; header.OptionalHeader.SizeOfImage = AlignTo(header_length, header.OptionalHeader.SectionAlignment) + AlignTo(header.Text_Section.SizeOfRawData, header.OptionalHeader.SectionAlignment) + AlignTo(header.RData_Section.SizeOfRawData, header.OptionalHeader.SectionAlignment) + AlignTo(header.Data_Section.SizeOfRawData, header.OptionalHeader.SectionAlignment); header.OptionalHeader.SizeOfCode = AlignTo((uint)code_info.Code.LongLength, header.OptionalHeader.FileAlignment); header.FileHeader.TimeDateStamp = (uint)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds; #endregion #region Write Executable //finally write the file //write PE header temp = header.ToBytes(); fs.Write(temp, 0, temp.Length); //write Header padding temp = CreatePadding((uint)fs.Position, header.OptionalHeader.FileAlignment); fs.Write(temp, 0, temp.Length); //write .code section fs.Write(code_info.Code, 0, code_info.Code.Length); //write .code padding temp = CreatePadding((uint)code_info.Code.Length, header.OptionalHeader.FileAlignment); fs.Write(temp, 0, temp.Length); //write .rdata section temp = RData_Section.GetBuffer(); fs.Write(temp, 0, (int)RData_Section.Length); //write .rdata padding temp = CreatePadding((uint)RData_Section.Length, header.OptionalHeader.FileAlignment); fs.Write(temp, 0, temp.Length); //write .data section temp = Data_Section.GetBuffer(); fs.Write(temp, 0, (int)Data_Section.Length); //write .data padding temp = CreatePadding((uint)Data_Section.Length, header.OptionalHeader.FileAlignment); fs.Write(temp, 0, temp.Length); #endregion }