mirror of
https://github.com/gnh1201/welsonjs.git
synced 2025-05-08 20:56:04 +00:00
396 lines
14 KiB
C#
396 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Xml.Linq;
|
|
|
|
namespace WelsonJS.Launcher.Tools
|
|
{
|
|
public class ResourceServer
|
|
{
|
|
private readonly HttpListener _listener;
|
|
private CancellationTokenSource _cts;
|
|
private Task _serverTask;
|
|
private bool _isRunning;
|
|
private string _prefix;
|
|
private string _resourceName;
|
|
private ExecutablesCollector _executablesCollector;
|
|
|
|
public ResourceServer(string prefix, string resourceName)
|
|
{
|
|
_prefix = prefix;
|
|
_listener = new HttpListener();
|
|
_listener.Prefixes.Add(prefix);
|
|
_resourceName = resourceName;
|
|
_executablesCollector = new ExecutablesCollector();
|
|
}
|
|
|
|
public string GetPrefix()
|
|
{
|
|
return _prefix;
|
|
}
|
|
|
|
public void Start()
|
|
{
|
|
if (_isRunning) return;
|
|
|
|
_isRunning = true;
|
|
_cts = new CancellationTokenSource();
|
|
_listener.Start();
|
|
|
|
// Open the web browser
|
|
Program.OpenWebBrowser(_prefix);
|
|
|
|
// Run a task with cancellation token
|
|
_serverTask = Task.Run(() => ListenLoop(_cts.Token));
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
_isRunning = false;
|
|
_cts.Cancel();
|
|
_listener.Stop();
|
|
|
|
MessageBox.Show("Server stopped.");
|
|
}
|
|
|
|
public bool IsRunning()
|
|
{
|
|
return _isRunning;
|
|
}
|
|
|
|
private async Task ListenLoop(CancellationToken token)
|
|
{
|
|
while (!token.IsCancellationRequested && _isRunning)
|
|
{
|
|
try
|
|
{
|
|
await ProcessRequest(await _listener.GetContextAsync());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (token.IsCancellationRequested || !_isRunning) break;
|
|
MessageBox.Show($"Error: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task ProcessRequest(HttpListenerContext context)
|
|
{
|
|
string path = context.Request.Url.AbsolutePath.TrimStart('/');
|
|
|
|
// Serve the favicon.ico file
|
|
if ("favicon.ico".Equals(path, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ServeResource(context, GetResource("favicon"), "image/x-icon");
|
|
return;
|
|
}
|
|
|
|
// Serve the code completion (word suggestion)
|
|
const string completionPrefix = "completion/";
|
|
if (path.StartsWith(completionPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ServeCompletion(context, path.Substring(completionPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve the DevTools Protocol
|
|
const string devtoolsPrefix = "devtools/";
|
|
if (path.StartsWith(devtoolsPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
await ServeDevTools(context, path.Substring(devtoolsPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve WHOIS request (use KRNIC server)
|
|
const string whoisPrefix = "whois/";
|
|
if (path.StartsWith(whoisPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
await ServeWhoisRequest(context, path.Substring(whoisPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve DNS Query request (use Google DNS server)
|
|
const string dnsQueryPrefix = "dns-query/";
|
|
if (path.StartsWith(dnsQueryPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ServeDnsQueryRequest(context, path.Substring(dnsQueryPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve TFA request
|
|
const string tfaPrefix = "tfa/";
|
|
if (path.StartsWith(tfaPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ServeTfaRequest(context, path.Substring(tfaPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve a value of App Config request
|
|
const string configPrefix = "config/";
|
|
if (path.StartsWith(configPrefix, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ServeConfigRequest(context, path.Substring(configPrefix.Length));
|
|
return;
|
|
}
|
|
|
|
// Serve a resource
|
|
ServeResource(context, GetResource(_resourceName), "text/html");
|
|
}
|
|
|
|
private void ServeCompletion(HttpListenerContext context, string word)
|
|
{
|
|
try
|
|
{
|
|
List<string> executables = _executablesCollector.GetExecutables();
|
|
|
|
CompletionItem[] completionItems = executables
|
|
.Where(exec => exec.IndexOf(word, 0, StringComparison.OrdinalIgnoreCase) > -1)
|
|
.Take(100) // Limit the number of results
|
|
.Select(exec => new CompletionItem
|
|
{
|
|
Label = Path.GetFileName(exec),
|
|
Kind = "Text",
|
|
Documentation = $"An executable file: {exec}",
|
|
InsertText = exec
|
|
})
|
|
.ToArray();
|
|
|
|
XElement response = new XElement("suggestions",
|
|
completionItems.Select(item => new XElement("item",
|
|
new XElement("label", item.Label),
|
|
new XElement("kind", item.Kind),
|
|
new XElement("documentation", item.Documentation),
|
|
new XElement("insertText", item.InsertText)
|
|
))
|
|
);
|
|
|
|
ServeResource(context, response.ToString(), "application/xml");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ServeResource(context, $"<error>Failed to process completion request. {ex.Message}</error>", "application/xml", 500);
|
|
}
|
|
}
|
|
|
|
private async Task ServeDevTools(HttpListenerContext context, string endpoint)
|
|
{
|
|
try
|
|
{
|
|
using (HttpClient client = new HttpClient())
|
|
{
|
|
string url = "http://localhost:9222/" + endpoint;
|
|
string data = await client.GetStringAsync(url);
|
|
|
|
ServeResource(context, data, "application/json");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ServeResource(context, $"<error>Failed to process DevTools request. {ex.Message}</error>", "application/xml", 500);
|
|
}
|
|
}
|
|
|
|
private async Task ServeWhoisRequest(HttpListenerContext context, string query)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(query) || query.Length > 255)
|
|
{
|
|
ServeResource(context, "<error>Invalid query parameter</error>", "application/xml", 400);
|
|
return;
|
|
}
|
|
|
|
string whoisServerUrl = "https://xn--c79as89aj0e29b77z.xn--3e0b707e";
|
|
|
|
using (var client = new HttpClient())
|
|
{
|
|
client.Timeout = TimeSpan.FromSeconds(10);
|
|
|
|
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, $"{whoisServerUrl}/kor/whois.jsc")
|
|
{
|
|
Content = new StringContent($"query={Uri.EscapeDataString(query)}&ip=141.101.82.1", Encoding.UTF8, "application/x-www-form-urlencoded")
|
|
};
|
|
|
|
request.Headers.Add("Accept", "*/*");
|
|
request.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.3124.77");
|
|
client.DefaultRequestHeaders.Referrer = new Uri($"{whoisServerUrl}/kor/whois/whois.jsp");
|
|
|
|
try
|
|
{
|
|
HttpResponseMessage response = await client.SendAsync(request);
|
|
string responseBody = await response.Content.ReadAsStringAsync();
|
|
|
|
ServeResource(context, responseBody, "text/plain", (int)response.StatusCode);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ServeResource(context, $"<error>Failed to process WHOIS request. {ex.Message}</error>", "application/xml", 500);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ServeDnsQueryRequest(HttpListenerContext context, string query)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(query) || query.Length > 255)
|
|
{
|
|
ServeResource(context, "<error>Invalid query parameter</error>", "application/xml", 400);
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
DnsQuery dns = new DnsQuery();
|
|
Dictionary<string, List<string>> allRecords = dns.QueryAll(query);
|
|
|
|
StringBuilder result = new StringBuilder();
|
|
foreach (var recordType in allRecords.Keys)
|
|
{
|
|
result.AppendLine($"\n{recordType} Records:");
|
|
foreach (var record in allRecords[recordType])
|
|
{
|
|
result.AppendLine(record);
|
|
}
|
|
}
|
|
|
|
string data = result.ToString();
|
|
ServeResource(context, data, "text/plain", 200);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ServeResource(context, $"<error>Failed to process DNS query. {ex.Message}</error>", "application/xml", 500);
|
|
}
|
|
}
|
|
|
|
private void ServeTfaRequest(HttpListenerContext context, string endpoint)
|
|
{
|
|
Tfa _tfa = new Tfa();
|
|
|
|
if (endpoint.Equals("pubkey"))
|
|
{
|
|
ServeResource(context, _tfa.GetPubKey(), "text/plain", 200);
|
|
return;
|
|
}
|
|
|
|
ServeResource(context);
|
|
}
|
|
|
|
public void ServeConfigRequest(HttpListenerContext context, string key)
|
|
{
|
|
string value = Program.GetAppConfig(key);
|
|
if (!String.IsNullOrEmpty(value))
|
|
{
|
|
ServeResource(context, value, "text/plain", 200);
|
|
return;
|
|
}
|
|
|
|
ServeResource(context);
|
|
}
|
|
|
|
private void ServeResource(HttpListenerContext context)
|
|
{
|
|
ServeResource(context, "<error>Not Found</error>", "application/xml", 404);
|
|
}
|
|
|
|
private void ServeResource(HttpListenerContext context, byte[] data, string mimeType = "text/html", int statusCode = 200)
|
|
{
|
|
string xmlHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
|
|
|
|
if (data == null) {
|
|
data = Encoding.UTF8.GetBytes(xmlHeader + "\r\n<error>Could not find the resource.</error>");
|
|
mimeType = "application/xml";
|
|
statusCode = 404;
|
|
}
|
|
|
|
context.Response.StatusCode = statusCode;
|
|
context.Response.ContentType = mimeType;
|
|
context.Response.ContentLength64 = data.Length;
|
|
using (Stream outputStream = context.Response.OutputStream)
|
|
{
|
|
outputStream.Write(data, 0, data.Length);
|
|
}
|
|
}
|
|
|
|
private void ServeResource(HttpListenerContext context, string data, string mimeType = "text/html", int statusCode = 200)
|
|
{
|
|
string xmlHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
|
|
|
|
if (data == null)
|
|
{
|
|
data = xmlHeader + "\r\n<error>Could not find the resource.</error>";
|
|
mimeType = "application/xml";
|
|
statusCode = 404;
|
|
}
|
|
else if (mimeType == "application/xml" && !data.StartsWith("<?xml"))
|
|
{
|
|
data = xmlHeader + "\r\n" + data;
|
|
}
|
|
|
|
ServeResource(context, Encoding.UTF8.GetBytes(data), mimeType, statusCode);
|
|
}
|
|
|
|
private byte[] GetResource(string resourceName)
|
|
{
|
|
// Try to fetch embedded resource.
|
|
byte[] data = GetEmbeddedResource(typeof(Program).Namespace + "." + resourceName);
|
|
if (data != null) return data;
|
|
|
|
// Fallback: Try to fetch resource from ResourceManager.
|
|
return GetResourceFromManager(resourceName);
|
|
}
|
|
|
|
private byte[] GetEmbeddedResource(string fullResourceName)
|
|
{
|
|
Assembly assembly = Assembly.GetExecutingAssembly();
|
|
using (Stream stream = assembly.GetManifestResourceStream(fullResourceName))
|
|
{
|
|
if (stream != null)
|
|
{
|
|
using (MemoryStream memoryStream = new MemoryStream())
|
|
{
|
|
stream.CopyTo(memoryStream);
|
|
return memoryStream.ToArray();
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private byte[] GetResourceFromManager(string resourceName)
|
|
{
|
|
object resourceObject = Properties.Resources.ResourceManager.GetObject(resourceName);
|
|
switch (resourceObject)
|
|
{
|
|
case byte[] resourceBytes:
|
|
return resourceBytes;
|
|
case System.Drawing.Icon icon:
|
|
return ConvertIconToBytes(icon);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private byte[] ConvertIconToBytes(System.Drawing.Icon icon)
|
|
{
|
|
using (MemoryStream memoryStream = new MemoryStream())
|
|
{
|
|
icon.Save(memoryStream);
|
|
return memoryStream.ToArray();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CompletionItem
|
|
{
|
|
public string Label { get; set; }
|
|
public string Kind { get; set; }
|
|
public string Documentation { get; set; }
|
|
public string InsertText { get; set; }
|
|
}
|
|
}
|