HSB Namespace Reference

Classes
class	AssociatedFile
class	Binding
	Defines the path of the servlet, optionally it can catch ALL the requests that search for path starting with the given value. More...
class	Configuration
	This class contains all the settings of the server. More...
class	Cookie
class	Custom
class	DataWriter
	A class to simplify the construction of byte arrays. More...
class	Debugger
class	Error
class	HttpUtils
class	Request
class	Response
class	Server
class	Servlet
class	Session
class	SessionManager
class	SslConfiguration
class	SystemTLS
class	Terminal
class	TLSImpl
class	Utils

Enumerations
enum	BG_COLOR {   DEFAULT , BLACK , RED , GREEN ,   YELLOW , BLUE , MAGENTA , CYAN ,   WHITE }
enum	FG_COLOR {   DEFAULT , BLACK , RED , GREEN ,   YELLOW , BLUE , MAGENTA , CYAN ,   WHITE }

Functions
class	DataReader (byte[] data)
	A class to simplify reading data from a byte array.
readonly struct	OAuth1_0Information (Dictionary< string, string > parameters)
class	Index (Request req, Response res, Configuration config)

Enumeration Type Documentation

BG_COLOR

enum HSB.BG_COLOR

Definition at line 3 of file Terminal.cs.

    {
        DEFAULT,
        BLACK,
        RED,
        GREEN,
        YELLOW,
        BLUE,
        MAGENTA,
        CYAN,
        WHITE
    }

FG_COLOR

enum HSB.FG_COLOR

Definition at line 15 of file Terminal.cs.

    {
        DEFAULT,
        BLACK,
        RED,
        GREEN,
        YELLOW,
        BLUE,
        MAGENTA,
        CYAN,
        WHITE
    }

Function Documentation

DataReader()

class HSB.DataReader

(

byte[]

data

)

A class to simplify reading data from a byte array.

Reads 1 byte from the data and returns it as a UInt16

Returns

Reads 2 bytes from the data and returns them as a ushort

Returns

Reads 3 bytes from the data and returns them as a uint24

Returns

Reads 4 bytes from the data and returns them as a uint32

Returns

Reads 4 bytes from the data and returns them as a signed int (int32)

Returns

Definition at line 5 of file DataReader.cs.

{
    private readonly byte[] data = data;
    private uint offset = 0;
    private uint endOffset = (uint)data.Length;
 
    public void Rewind()
    {
        offset = 0;
    }
    public void SetReaderPosition(uint position)
    {
        this.offset = position;
    }
 
    public void SetEndPosition(uint position)
    {
        endOffset = position;
    }
 
    public uint GetCurrentPosition()
    {
        return offset;
    }
    public bool DataAvailable()
    {
        return offset < endOffset;
    }
 
    public int RemainingData => (int)(endOffset - offset);
 
 
    public byte ReadByte()
    {
        offset++;
        return data[offset - 1];
    }
 
    public byte[] ReadBytes(uint size)
    {
        if (size > endOffset - offset)
        {
            size = endOffset - offset - 1;
            Console.WriteLine("Not enough data to read, returning what is available");
        }
 
        byte[] bytes = new byte[size];
        Array.Copy(data, offset, bytes, 0, size);
        offset += size;
        return bytes;
    }
 
    public byte[] ReadBytes(uint size, uint offset)
    {
        byte[] bytes = new byte[size];
        Array.Copy(data, offset, bytes, 0, size);
        return bytes;
    }
 
    public byte[] ReadBytes((uint size, uint offset) values)
    {
        return ReadBytes(values.size, values.offset);
    }
    public UInt16 ReadSmallUint(){
        byte[] ushrt = ReadBytes(1);
        return Utils.BytesToUShort([0, ushrt[0]]);
    }
 
    //aka uint16
    public ushort ReadUShort()
    {
        byte[] ushrt = ReadBytes(2);
        return Utils.BytesToUShort(ushrt);
    }
    public uint ReadUInt24()
    {
        byte[] uint24 = ReadBytes(3);
        return Utils.UInt24ToUInt32(uint24);
    }
 
    public uint ReadUInt()
    {
        byte[] ushrt = ReadBytes(4);
        return BitConverter.ToUInt32(ushrt);
    }
    public int ReadInt()
    {
        byte[] uin = ReadBytes(4);
        return BitConverter.ToInt32(uin);
    }
 
 
 
}

Index()

class HSB.Index	(	Request	req,
		Response	res,
		Configuration	config
	)

Definition at line 7 of file Index.cs.

                                                                    : Servlet(req, res, config)
{
    public override void ProcessGet()
    {
        string page = ReadFromResources("index.html");
        string version = "v";
        if (Assembly.GetExecutingAssembly().GetName().Version != null)
        {
            version += Assembly.GetExecutingAssembly().GetName().Version!.ToString();
        }
 
 
 
        string footer_div = "";
        string server_name;
        string logo = "";
        //string title = "";
        if (configuration.CustomServerName != "")
        {
            server_name = configuration.CustomServerName;
        }
        else
        {
            server_name = "HSB<sup>#</sup>";
            footer_div = "<div class=\"footer\">Copyright &copy; 2021-2023 Lorenzo L. Concas</div>";
            string logo_b64 = ReadFromResources("logo_b64");
            logo = $"<img width=\"32px\" src=\"{logo_b64}\" />";
            // title = "Http Server Boxed <sup>#</sup>";
        }
 
        //set attributes
        res.AddAttribute("logo", logo); //this break some configurations, logo must be replaced with a smaller image
                                        //  res.AddAttribute("title", title);
        res.AddAttribute("serverName", server_name);
        res.AddAttribute("footer_div", footer_div);
        res.AddAttribute("hsbVersion", version);
 
        res.SendHTMLContent(page, true);
 
    }
}

OAuth1_0Information()

readonly struct HSB.OAuth1_0Information

(

Dictionary< string, string >

parameters

)

Definition at line 5 of file OAuth1_0Information.cs.

{
    public readonly string access_token = parameters.TryGetValueFromDict("access_token", "");
    public readonly string nonce = parameters.TryGetValueFromDict("oauth_nonce", "");
    public readonly string token = parameters.TryGetValueFromDict("oauth_token", "");
    public readonly string version = parameters.TryGetValueFromDict("oauth_version", "");
    public readonly string signature_method = parameters.TryGetValueFromDict("oauth_signature_method", "");
    public readonly string timestamp = parameters.TryGetValueFromDict("oauth_timestamp", "");
    public readonly string consumer_key = parameters.TryGetValueFromDict("oauth_consumer_key", "");
    public readonly string signature = parameters.TryGetValueFromDict("oauth_signature", "");
 
    public readonly bool IsValid()
    {
        return access_token != "" && nonce != "" && token != "" && version != "" && signature_method != "" && timestamp != "" && consumer_key != "" && signature != "";
    }
 
    public override readonly string ToString()
    {
        return IsValid() ? $"Valid oAuth1.0 with timestamp {timestamp}, version {version}" : "No valid oAuth1.0 found";
    }
 
    public override readonly bool Equals([NotNullWhen(true)] object? obj)
    {
        if(obj is OAuth1_0Information auth){
            return access_token == auth.access_token && nonce == auth.nonce && token == auth.token && version == auth.version && signature_method == auth.signature_method && timestamp == auth.timestamp && consumer_key == auth.consumer_key && signature == auth.signature;
        }
        return false;
    }
 
    public override readonly int GetHashCode()
    {
        return HashCode.Combine(access_token, nonce, token, version, signature_method, timestamp, consumer_key, signature);
    }
 
    public static bool operator ==(OAuth1_0Information left, OAuth1_0Information right)
    {
        return left.Equals(right);
    }
 
    public static bool operator !=(OAuth1_0Information left, OAuth1_0Information right)
    {
        return !(left == right);
    }
}