Add OCDaemonHoster Version 1.

OCUploadDownloadServer/OCDaemonHoster/OCDaemonHoster.csproj

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+  <PropertyGroup>
+    <ProjectGuid>{08F6D48F-9EAB-4861-9D50-F9F1BC10C074}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>OCDaemonHoster</RootNamespace>
+    <AssemblyName>OCDaemonHoster</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <ApplicationIcon>..\Icon2.ico</ApplicationIcon>
+    <NoWin32Manifest>False</NoWin32Manifest>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'AnyCPU' ">
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <OutputPath>bin\Debug\</OutputPath>
+    <DebugSymbols>True</DebugSymbols>
+    <DebugType>Full</DebugType>
+    <Optimize>False</Optimize>
+    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <OutputPath>bin\Release\</OutputPath>
+    <DebugSymbols>False</DebugSymbols>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <DefineConstants>TRACE</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Net">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="OCNetworkClient.cs" />
+    <Compile Include="OCNetworkListener.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

OCUploadDownloadServer/OCDaemonHoster/OCNetworkClient.cs

@@ -0,0 +1,179 @@
+/*
+ * Created by SharpDevelop.
+ * User: Alfred
+ * Date: 28/12/2019
+ * Time: 18:34
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace captainalm.network.oc
+{
+	public class OCNetworkClient {
+		private Socket sock;
+		private IPEndPoint remoteAddress;
+		private IPEndPoint localAddress;
+		private Boolean connected;
+
+		internal OCNetworkClient(Socket socketIn) {
+			sock = socketIn;
+			if (sock != null) {
+				if (sock.Connected) {
+					remoteAddress = (IPEndPoint) sock.RemoteEndPoint;
+					localAddress = (IPEndPoint) sock.LocalEndPoint;
+					connected = true;
+				} else {
+					connected = false;
+				}
+			} else {
+				connected = false;
+			}
+		}
+
+		public IPEndPoint getRemoteAddress() {
+			return remoteAddress;
+		}
+
+		public IPEndPoint getLocalAddress() {
+			return localAddress;
+		}
+
+		public Socket getSocket() {
+			return sock;
+		}
+
+		public Boolean sendHandshake(String chIn) {
+			if (chIn == null) {
+				return false;
+			}
+			if (connected && chIn.Length == 1) {
+				try {
+					var bts = System.Text.Encoding.ASCII.GetBytes(chIn.Substring(0,1));
+					sock.Send(bts,bts.Length, SocketFlags.None);
+					return true;
+				} catch (SocketException e) {
+					connected = false;
+				}
+			}
+			return false;
+		}
+
+		public String receiveProtocol() {
+			if (connected) {
+				try {
+					var bts = new Byte[1];
+					sock.Receive(bts,1,SocketFlags.None);
+					String prot = System.Text.Encoding.ASCII.GetString(bts);
+					return prot;
+				} catch (SocketException e) {
+					connected = false;
+				}
+			}
+			return "";
+		}
+
+		public Boolean receiveHandshake(String chIn) {
+			if (chIn == null) {
+				return false;
+			}
+			if (connected && chIn.Length == 1) {
+				try {
+					var bts = new Byte[1];
+					sock.Receive(bts,1,SocketFlags.None);
+					Boolean test = System.Text.Encoding.ASCII.GetString(bts).Equals(chIn.Substring(0,1));
+					return test;
+				} catch (SocketException e) {
+					connected = false;
+				}
+			}
+			return false;
+		}
+
+		public Boolean sendData(String data) {
+			if (data == null) {
+				return false;
+			}
+			if (connected && data.Length > 0) {
+				try {
+					var bts = System.Text.Encoding.ASCII.GetBytes(data);
+					sock.Send(bts,bts.Length, SocketFlags.None);
+					return true;
+				} catch (SocketException e) {
+					connected = false;
+				}
+			}
+			return false;
+		}
+
+		public String receiveData() {
+			String toret = "";
+			if (connected) {
+				try {
+					int lout = 0;
+					while (sock.Available < 1 && lout < 50) {
+						try {
+							Thread.Sleep(100);
+						} catch (ThreadInterruptedException e) {
+						}
+						lout++;
+					}
+					int len = sock.Available;
+					byte[] bufferIn = new byte[len];
+					int res = sock.Receive(bufferIn,len,SocketFlags.None);
+					if (res == 0 && len != 0) {
+						connected = false;
+					} else {
+						connected = true;
+					}
+					toret = System.Text.Encoding.ASCII.GetString(bufferIn);
+				} catch (SocketException e) {
+					connected = false;
+					toret = "";
+				}
+			}
+			return toret;
+		}
+
+		public void invokeConnectionCheck() {
+			try {
+				byte[] bufferIn = new byte[1];
+				int res = sock.Receive(bufferIn,1,SocketFlags.None);
+				if (res == 0) {
+					connected = false;
+				} else {
+					connected = true;
+				}
+			} catch (SocketException e) {
+				connected = false;
+			}
+		}
+
+		public Boolean getIsConnected() {
+			return connected;
+		}
+
+		public void shutdown() {
+			if (connected) {
+				try {
+					sock.Shutdown(SocketShutdown.Both);
+				} catch (SocketException e) {
+				}
+			}
+		}
+
+		public void close() {
+			if (connected) {
+				try {
+					sock.Close();
+				} catch (SocketException e) {
+				}
+			}
+			connected = false;
+			sock = null;
+		}
+	}
+}

OCUploadDownloadServer/OCDaemonHoster/OCNetworkListener.cs

@@ -0,0 +1,146 @@
+/*
+ * Created by SharpDevelop.
+ * User: Alfred
+ * Date: 28/12/2019
+ * Time: 19:08
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace captainalm.network.oc
+{
+	public class OCNetworkListener {
+		private Socket sSock;
+		private Thread lThread;
+		private Boolean listening;
+		private OCNetworkClient acceptedClient;
+		private Boolean cWaiting;
+		private Boolean cExists;
+		private Object slockcl = new Object();
+		private IPEndPoint listeningAddress;
+
+		public OCNetworkListener(IPEndPoint addressIn) {
+			lThread = new Thread(new ThreadStart(this.run));
+			lThread.IsBackground = true;
+			listening = false;
+			listeningAddress = addressIn;
+			try {
+				if (Environment.OSVersion.Version.Major >= 6 && addressIn.Address.Equals(IPAddress.IPv6Any)) {
+					sSock = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
+					sSock.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
+				} else {
+					sSock = new Socket(addressIn.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+				}
+				sSock.ReceiveBufferSize = Int16.MaxValue;
+				sSock.SendBufferSize = Int16.MaxValue;
+				sSock.ReceiveTimeout = 5000;
+				sSock.SendTimeout = 5000;
+			} catch (SocketException e) {
+				sSock = null;
+			}
+			try {
+				if (sSock == null) {
+					throw new SocketException(0);
+				}
+				sSock.Bind(addressIn);
+				sSock.Listen(1);
+				listening = true;
+			} catch (SocketException e) {
+			}
+			if (listening) {
+				lThread.Start();
+			}
+		}
+
+		public OCNetworkClient getAcceptedClient() {
+			OCNetworkClient toret = null;
+			lock (slockcl) {
+				if (cWaiting && acceptedClient != null) {
+					cExists = true;
+					cWaiting = false;
+					toret = acceptedClient;
+				}
+			}
+			return toret;
+		}
+
+		public void returnAcceptedClient(OCNetworkClient toRet) {
+			lock (slockcl) {
+				if (cExists && toRet == acceptedClient) {
+					toRet.shutdown();
+					toRet.close();
+					toRet = null;
+					cExists = false;
+				}
+			}
+		}
+
+		public IPEndPoint getListeningAddress() {
+			return listeningAddress;
+		}
+
+		public Boolean getIsThereGottenClient() {
+			return cExists;
+		}
+
+		public Boolean getIsThereAcceptedClient() {
+			return cWaiting;
+		}
+
+		public Boolean getIsListening() {
+			return listening;
+		}
+
+		public void close() {
+			if (acceptedClient != null && (cWaiting == true)) {
+				this.getAcceptedClient();
+			}
+			if (acceptedClient != null && (cExists == true)) {
+				this.returnAcceptedClient(acceptedClient);
+			}
+			if (listening) {
+				sSock.Close();
+			}
+			listening = false;
+			while (lThread.IsAlive) {
+				try {
+					Thread.Sleep(100);
+				} catch (ThreadInterruptedException e) {
+				}
+			}
+			sSock = null;
+		}
+		
+		protected void run() {
+			while (listening) {
+				while (cExists) {
+					try {
+						Thread.Sleep(100);
+					} catch (ThreadInterruptedException e) {
+					}
+				}
+				try {
+					Socket sa = sSock.Accept();
+					sa.ReceiveBufferSize = Int16.MaxValue;
+					sa.SendBufferSize = Int16.MaxValue;
+					sa.ReceiveTimeout = 5000;
+					sa.SendTimeout = 5000;
+					acceptedClient = new OCNetworkClient(sa);
+					cWaiting = true;
+					while (cWaiting) {
+						try {
+							Thread.Sleep(100);
+						} catch (ThreadInterruptedException e) {
+						}
+					}
+				} catch (SocketException e) {
+				}
+			}
+		}
+	}
+}

OCUploadDownloadServer/OCDaemonHoster/Program.cs

@@ -0,0 +1,318 @@
+/*
+ * Created by SharpDevelop.
+ * User: Alfred
+ * Date: 28/12/2019
+ * Time: 17:53
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Threading;
+
+using captainalm.network.oc;
+
+namespace OCDaemonHoster
+{
+	public class Program {
+		public static String ipAddress;
+		public static int port;
+		public static int version = 0;
+
+		public static Dictionary<String, String> settings = new Dictionary<String, String>();
+		public static String cache;
+		public static List<String> addrsv4;
+		public static List<String> addrsv6;
+
+		public static void Main(String[] args) {
+			writeLine("Open Computers Daemon Hoster (OCDH) : (C) Captain ALM 2019.");
+			writeLine("License: BSD 2-Clause.");
+			addrsv4 = getInterfaceAddresses(4);
+			addrsv6 = getInterfaceAddresses(6);
+			if (args != null) {
+				if (args.Length < 2) {
+					printUsage();
+					Environment.Exit(1);
+				} else {
+					decryptArgs(args);
+					if (settings.ContainsKey("mode")) {
+						if (settings["mode"].ToLower().Equals("h")) {
+							hoster();
+						} else if (settings["mode"].ToLower().Equals("a")) {
+							accessor();
+						}
+					}
+				}
+			} else {
+				printUsage();
+				Environment.Exit(1);
+			}
+			Environment.Exit(0);
+		}
+
+		public static void hoster() {
+			writeLine("Hosting Mode!");
+			IPEndPoint address = new IPEndPoint(IPAddress.Parse(ipAddress),port);
+			writeLine("[INFO] : Address Setup!");
+			if (settings.ContainsKey("target")) {
+				writeLine("[INFO] : Target File : " + settings["target"]);
+			}
+			cache = "";
+			if (settings.ContainsKey("cache") && settings.ContainsKey("target")) {
+				try {
+					cache = loadFile(settings["target"]);
+					writeLine("[INFO] : File Cached!");
+				} catch (IOException e) {
+				}
+			}
+			OCNetworkListener server = new OCNetworkListener(address);
+			writeLine("[INFO] : Listener Started!");
+			writeLine("[INFO] : Listener 'Address:Port' : " + server.getListeningAddress().Address.ToString()
+			          + ":" + server.getListeningAddress().Port);
+			writeLine("[INFO] : Open Addresses 'Address:Port' :");
+			if (version == 4 && ipAddress.Equals(IPAddress.Any.ToString())) {
+				foreach (String c in addrsv4) {
+					writeLine(c + ":" + port);
+				}
+			} else if (version == 6 && ipAddress.Equals(IPAddress.IPv6Any.ToString())) {
+				foreach (String c in addrsv6) {
+					writeLine(c + ":" + port);
+				}
+			} else if (version == 0 && ipAddress.Equals(IPAddress.IPv6Any.ToString())) {
+				List<String> addrsT = new List<String>();
+				addrsT.AddRange(addrsv4);
+				addrsT.AddRange(addrsv6);
+				foreach (String c in addrsT) {
+					writeLine(c + ":" + port);
+				}
+				addrsT.Clear();
+				addrsT = null;
+			} else {
+				writeLine(ipAddress + ":" + port);
+			}
+			Boolean exec = true;
+			while (exec) {
+				if (server.getIsThereAcceptedClient()) {
+					OCNetworkClient client = server.getAcceptedClient();
+					writeLine("[INFO] : Client Accepted!");
+					writeLine("[INFO] : Client 'Address:Port' : " + client.getRemoteAddress().Address.ToString()
+					          + ":" + client.getRemoteAddress().Port);
+					handleProtocol(client);
+					server.returnAcceptedClient(client);
+					writeLine("[INFO] : Client Disposed!");
+				}
+				try {
+					Thread.Sleep(100);
+				} catch (ThreadInterruptedException e) {
+				}
+			}
+			server.close();
+			server = null;
+		}
+
+		public static void accessor() {
+			throw new NotImplementedException("Method not Implemented.");
+		}
+
+		public static void handleProtocol(OCNetworkClient clientIn) {
+			String prot = clientIn.receiveProtocol();
+			if (prot.Equals("1")) {
+				writeLine("[INFO] : Sending...");
+				String data = "";
+				if (settings.ContainsKey("target") && !settings.ContainsKey("cache")) {
+					writeLine("[INFO] : Sending : Loading Data...");
+					try {
+						data = loadFile(settings["target"]);
+					} catch (IOException e) {
+						data = "";
+					}
+				} else if (settings.ContainsKey("cache")) {
+					writeLine("[INFO] : Sending : Retrieving Data...");
+					data = cache;
+				}
+				writeLine("[INFO] : Sending : Sending Handshake...");
+				clientIn.sendHandshake("1");
+				writeLine("[INFO] : Sending : Waiting For Handshake...");
+				Boolean hand1Succ = clientIn.receiveHandshake("1");
+				if (hand1Succ) {
+					writeLine("[INFO] : Sending : Sending Data...");
+					clientIn.sendData(data);
+					writeLine("[INFO] : Sending : Waiting For Handshake...");
+					clientIn.receiveHandshake("1");
+				}
+			} else if (prot.Equals("2")) {
+				writeLine("[INFO] : Receiving...");
+				writeLine("[INFO] : Receiving : Sending Handshake...");
+				clientIn.sendHandshake("1");
+				writeLine("[INFO] : Receiving : Waiting For Data...");
+				String data = clientIn.receiveData();
+				writeLine("[INFO] : Receiving : Processing Data...");
+				if (data.Contains("\r") && !data.Contains("\n")) {
+					data = data.Replace("\r", "\r\n");
+				}
+				if (data.Contains("\n") && !data.Contains("\r")) {
+					data = data.Replace("\n", "\r\n");
+				}
+				if (settings.ContainsKey("cache")) {
+					writeLine("[INFO] : Receiving : Caching Data...");
+					cache = data;
+				}
+				if (settings.ContainsKey("target")) {
+					writeLine("[INFO] : Receiving : Saving Data...");
+					try {
+						saveFile(settings["target"], data);
+					} catch (IOException e) {
+					}
+				}
+				writeLine("[INFO] : Receiving : Sending Handshake...");
+				clientIn.sendHandshake("1");
+			}
+		}
+
+		public static String loadFile(String target) {
+			return System.IO.File.ReadAllText(target, System.Text.Encoding.ASCII);
+		}
+
+		public static void saveFile(String target, String contents) {
+			System.IO.File.WriteAllText(target,contents,System.Text.Encoding.ASCII);
+		}
+
+		public static void decryptArgs(String[] args) {
+			try {
+				port = Int32.Parse(args[1]);
+			} catch (FormatException e) {
+				port = 0;
+			}
+			for (int i = 2; i < args.Length; i++) {
+				String carg = args[i];
+				Boolean hasEquals = carg.Contains("=");
+				Boolean isSwitch = carg.StartsWith("-");
+				String cSwitch = "";
+				String cValue = "";
+				if (isSwitch && !hasEquals) {
+					cSwitch = carg.Substring(1).ToLower();
+				} else if (isSwitch && hasEquals) {
+					cSwitch = carg.Substring(1, carg.IndexOf("=")).ToLower();
+					cValue = carg.Substring(carg.IndexOf("=") + 1);
+				}
+				if (!settings.ContainsKey(cSwitch)) {
+					settings.Add(cSwitch, cValue);
+				}
+			}
+			try {
+				var ip = IPAddress.Parse(args[0]);
+				if (ip.AddressFamily == AddressFamily.InterNetworkV6 && ! args[0].Equals(IPAddress.IPv6Any.ToString())) {
+					version = 6;
+				} else if (ip.AddressFamily == AddressFamily.InterNetworkV6 && args[0].Equals(IPAddress.IPv6Any.ToString()) && Environment.OSVersion.Version.Major >= 6) {
+					version = 0;
+				} else if (ip.AddressFamily == AddressFamily.InterNetworkV6 && args[0].Equals(IPAddress.IPv6Any.ToString()) && Environment.OSVersion.Version.Major < 6) {
+					version = 6;
+				} else {
+					version = 4;
+				}
+			} catch (FormatException ex) {
+				if (Environment.OSVersion.Version.Major >= 6) {
+					version = 0;
+				} else {
+					version = 4;
+				}
+			}
+			try {
+				ipAddress = verifyInterface(args[0], version);
+			} catch (SocketException ex) {
+				ipAddress = IPAddress.IPv6Any.ToString();
+			}
+		}
+
+		public static List<String> getInterfaceAddresses(int ver) {
+			List<String> toret = new List<String>();
+			var allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
+			foreach (NetworkInterface netc in allNetworkInterfaces) {
+				if (netc.OperationalStatus == OperationalStatus.Up) {
+					var ipInfo = netc.GetIPProperties().UnicastAddresses;
+					foreach (UnicastIPAddressInformation cadd in ipInfo) {
+						String sadd = "";
+						if (cadd.Address.AddressFamily == AddressFamily.InterNetwork && (ver == 4 || ver == 0)) {
+							sadd = cadd.Address.ToString();
+						} else if (cadd.Address.AddressFamily == AddressFamily.InterNetworkV6 && (ver == 6 || ver == 0)) {
+							sadd =  cadd.Address.ToString();
+						}
+						if (sadd != "") {
+							if (sadd.Contains("%")) {
+								sadd = sadd.Substring(0, sadd.IndexOf("%"));
+							}
+							toret.Add(sadd);
+						}
+					}
+				}
+			}
+			return toret;
+		}
+
+		public static String verifyInterface(String inF, int ver) {
+			Boolean isContained = false;
+			List<String> addrsT = new List<String>();
+			if (ver == 4 || ver == 0) {
+				addrsT.AddRange(addrsv4);
+			} else if (ver == 6 ||  ver == 0) {
+				addrsT.AddRange(addrsv6);
+			}
+			foreach (String c in addrsT) {
+				if (c.Equals(inF)) {
+					isContained = true;
+					break;
+				}
+			}
+			if (! isContained) {
+				if (inF.Equals(IPAddress.Any.ToString()) && ver == 4) {
+					return IPAddress.Any.ToString();
+				}
+			}
+			addrsT.Clear();
+			addrsT = null;
+			if (isContained) {
+				return inF;
+			} else {
+				return IPAddress.IPv6Any.ToString();
+			}
+		}
+
+		public static void printUsage() {
+			writeLine("");
+			writeLine("Usage:");
+			writeLine(
+				"OCDH.exe <listening IP Address> <listening Port> [-mode=<MODE>] [-target=<target file path>] [-cache] [-enumeration] [-creation] [-deletion]");
+			writeLine("");
+			writeLine("-mode=<MODE> : allows to select a Hosting Mode.");
+			writeLine("-target=<target file path> : allows to select a file for hosting (File Host Mode Only).");
+			writeLine("-cache : caches the target file once (File Host Mode Only).");
+			writeLine("-enumeration : allows for file/directory enumeration (File Access Mode Only).");
+			writeLine("-creation : allows for file/directory creation (File Access Mode Only).");
+			writeLine("-deletion : allows for file/directory deletion (File Access Mode Only).");
+			writeLine("");
+			writeLine("MODE:");
+			writeLine("H : File Host Mode, Hosts a single file for access.");
+			writeLine("A : File Access Mode, Allows file system access.");
+		}
+
+		public static void write(String stringIn) {
+			Console.Out.Write(stringIn);
+		}
+
+		public static void writeLine(String stringIn) {
+			Console.Out.WriteLine(stringIn);
+		}
+
+		public static void writeError(String stringIn) {
+			Console.Error.Write(stringIn);
+		}
+
+		public static void writeErrorLine(String stringIn) {
+			Console.Error.WriteLine(stringIn);
+		}
+	}
+}

OCUploadDownloadServer/OCDaemonHoster/Properties/AssemblyInfo.cs

@@ -0,0 +1,31 @@
+#region Using directives
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+#endregion
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OCDaemonHoster")]
+[assembly: AssemblyDescription("Open Computers Daemon Hoster")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Captain ALM")]
+[assembly: AssemblyProduct("Open Computers Daemon Hoster")]
+[assembly: AssemblyCopyright("Copyright (C) Captain ALM 2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+[assembly: ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all the values or you can use the default the Revision and 
+// Build Numbers by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.*")]

OCUploadDownloadServer/OCDaemonHoster/app.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+	<startup>
+		<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
+	</startup>
+</configuration>