BadNetHostExtensions.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
 
using BadScript2.ConsoleAbstraction.Implementations.Remote;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Interop.Functions.Extensions;
using BadScript2.Runtime.Interop.Reflection.Objects;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.NetHost;
 
public class BadNetHostExtensions : BadInteropExtension
{
    private static BadTable CreateNameValueTable(NameValueCollection headers)
    {
        BadTable t = new BadTable();
 
        foreach (string key in headers.AllKeys)
        {
            t.SetProperty(key, headers[key]);
        }
 
        return t;
    }
 
    private static BadArray CreateCookieTable(CookieCollection cookies)
    {
        BadArray table = new BadArray();
 
        foreach (Cookie cookie in cookies)
        {
            table.InnerArray.Add(new BadReflectedObject(cookie));
        }
 
        return table;
    }
 
    private static void CopyHeaderTable(NameValueCollection dst, BadTable src)
    {
        foreach (KeyValuePair<string, BadObject> kvp in src.InnerTable)
        {
            if (kvp.Value is not IBadString v)
            {
                throw new BadRuntimeException("Header Table must only contain string keys and values");
            }
 
            dst[kvp.Key] = v.Value;
        }
    }
 
    private static BadTable CreateContentTable(Stream content, Encoding enc)
    {
        BadTable table = new BadTable();
 
        table.SetFunction("AsString",
                          () =>
                          {
                              StreamReader sr = new StreamReader(content, enc);
 
                              return sr.ReadToEnd();
                          },
                          BadNativeClassBuilder.GetNative("string")
                         );
 
        table.SetFunction("AsBytes",
                          () =>
                          {
                              byte[] data = new byte[content.Length];
                              int read = content.Read(data, 0, data.Length);
 
                              if (read != data.Length)
                              {
                                  throw new BadNetworkConsoleException("Could not read all data from stream");
                              }
 
                              return new BadArray(data.Select(x => (BadObject)x)
                                                      .ToList()
                                                 );
                          },
                          BadNativeClassBuilder.GetNative("Array")
                         );
 
        return table;
    }
 
    private void AddContextExtensions(BadInteropExtensionProvider provider)
    {
        provider.RegisterObject<BadHttpContext>("Request", c => new BadHttpRequest(c.Context.Request));
        provider.RegisterObject<BadHttpContext>("Response", c => CreateResponseTable(c.Context.Response));
    }
 
    private void AddRequestExtensions(BadInteropExtensionProvider provider)
    {
        provider.RegisterObject<BadHttpRequest>("ContentLength", r => r.Request.ContentLength64);
        provider.RegisterObject<BadHttpRequest>("ContentType", r => r.Request.ContentType);
        provider.RegisterObject<BadHttpRequest>("Headers", r => CreateNameValueTable(r.Request.Headers));
        provider.RegisterObject<BadHttpRequest>("HttpMethod", r => r.Request.HttpMethod);
        provider.RegisterObject<BadHttpRequest>("IsLocal", r => r.Request.IsLocal);
        provider.RegisterObject<BadHttpRequest>("IsSecureConnection", r => r.Request.IsSecureConnection);
        provider.RegisterObject<BadHttpRequest>("IsAuthenticated", r => r.Request.IsAuthenticated);
        provider.RegisterObject<BadHttpRequest>("IsWebSocketRequest", r => r.Request.IsWebSocketRequest);
        provider.RegisterObject<BadHttpRequest>("KeepAlive", r => r.Request.KeepAlive);
        provider.RegisterObject<BadHttpRequest>("QueryString", r => CreateNameValueTable(r.Request.QueryString));
        provider.RegisterObject<BadHttpRequest>("RawUrl", r => r.Request.RawUrl);
        provider.RegisterObject<BadHttpRequest>("Url", r => new BadReflectedObject(r.Request.Url));
        provider.RegisterObject<BadHttpRequest>("UrlReferrer", r => new BadReflectedObject(r.Request.UrlReferrer));
        provider.RegisterObject<BadHttpRequest>("ServiceName", r => r.Request.ServiceName);
        provider.RegisterObject<BadHttpRequest>("UserAgent", r => r.Request.UserAgent);
        provider.RegisterObject<BadHttpRequest>("ClientCertificateError", r => r.Request.ClientCertificateError);
        provider.RegisterObject<BadHttpRequest>("HasEntityBody", r => r.Request.HasEntityBody);
        provider.RegisterObject<BadHttpRequest>("UserHostAddress", r => r.Request.UserHostAddress);
        provider.RegisterObject<BadHttpRequest>("UserHostName", r => r.Request.UserHostName);
 
        provider.RegisterObject<BadHttpRequest>("UserLanguages",
                                                r => new BadArray((r.Request.UserLanguages ?? Array.Empty<string>())
                                                                  .Select(x => (BadObject)x)
                                                                  .ToList()
                                                                 )
                                               );
 
        provider.RegisterObject<BadHttpRequest>("AcceptTypes",
                                                r => new BadArray((r.Request.AcceptTypes ?? Array.Empty<string>())
                                                                  .Select(x => (BadObject)x)
                                                                  .ToList()
                                                                 )
                                               );
        provider.RegisterObject<BadHttpRequest>("ContentEncoding", r => r.Request.ContentEncoding.EncodingName);
        provider.RegisterObject<BadHttpRequest>("Cookies", r => CreateCookieTable(r.Request.Cookies));
 
        provider.RegisterObject<BadHttpRequest>("Content",
                                                r => CreateContentTable(r.Request.InputStream,
                                                                        r.Request.ContentEncoding
                                                                       )
                                               );
    }
 
    private static BadTable CreateResponseTable(HttpListenerResponse resp)
    {
        BadTable table = new BadTable();
        table.SetFunction("SetHeader", (string key, string value) => resp.Headers[key] = value);
        table.SetFunction("SetHeaders", (BadTable headers) => CopyHeaderTable(resp.Headers, headers));
        table.SetFunction("SetCookie", (Cookie cookie) => resp.Cookies.Add(cookie));
 
        table.SetFunction("SetCookies",
                          (BadArray cookies) =>
                          {
                              foreach (BadObject cookie in cookies.InnerArray)
                              {
                                  if (cookie is BadReflectedObject { Instance: Cookie c })
                                  {
                                      resp.Cookies.Add(c);
                                  }
                                  else
                                  {
                                      throw new BadRuntimeException("Cookies must be Cookie objects");
                                  }
                              }
                          }
                         );
        table.SetFunction("SetStatusCode", (int code) => resp.StatusCode = code);
        table.SetFunction("SetStatusDescription", (string desc) => resp.StatusDescription = desc);
        table.SetFunction("SetContentType", (string type) => resp.ContentType = type);
        table.SetFunction("SetContentEncoding", (string enc) => resp.ContentEncoding = Encoding.GetEncoding(enc));
        table.SetFunction("SetContentLength", (long len) => resp.ContentLength64 = len);
        table.SetFunction("SetKeepAlive", (bool keepAlive) => resp.KeepAlive = keepAlive);
        table.SetFunction("Redirect", (string location) => resp.Redirect(location));
        table.SetFunction("Abort", resp.Abort);
        table.SetFunction("Close", resp.Close);
 
        table.SetFunction("SetContent",
                          (string content) =>
                          {
                              byte[] data = (resp.ContentEncoding ?? Encoding.UTF8).GetBytes(content);
                              resp.OutputStream.Write(data, 0, data.Length);
                          }
                         );
 
        return table;
    }
 
    protected override void AddExtensions(BadInteropExtensionProvider provider)
    {
        AddContextExtensions(provider);
        AddRequestExtensions(provider);
    }
}