HSB.Server Class Reference

Public Member Functions
	Server (Configuration config)
void	Start (bool openInBrowser=false)

Static Public Member Functions
static void	Main ()

Detailed Description

Definition at line 15 of file Server.cs.

Constructor & Destructor Documentation

Server()

HSB.Server.Server

(

Configuration

config

)

Definition at line 31 of file Server.cs.

    {
        int errorCode = 0;
        if (!config.HideBranding)
            Utils.PrintLogo();
 
        if (config.Port == 0)
        {
            //if port is 0, we use a random port in the range 1024-65535
            config.Port = (ushort)new Random().Next(1024, 65535);
        }
 
        this.config = config;
        config.Debug.INFO("Starting logging...");
 
        try
        {
 
 
            if (config.Address == "")
            {
                //address must be ANY
                ipAddress = config.ListeningMode switch
                {
                    IPMode.IPV4_ONLY => IPAddress.Any,
                    _ => IPAddress.IPv6Any,
                };
            }
            else //note that in this case ListeningMode is NOT a valid parameter as it depends on the address
            {
                List<IPAddress> addresses = [.. Dns.GetHostAddresses(config.Address, AddressFamily.InterNetwork)];
 
                //this fixes an error where user specifies an ipv4 address but want the server to listenes to BOTH or ipv6 only
 
                if (addresses.Count != 0)
                {
                    ipAddress = addresses.First();
                    config.ListeningMode = IPMode.IPV4_ONLY;
                }
                else
                {
                    addresses = [.. Dns.GetHostAddresses(config.Address, AddressFamily.InterNetworkV6)];
                    if (addresses.Count != 0)
                    {
                        ipAddress = addresses.First();
                        config.ListeningMode = IPMode.IPV6_ONLY;
                    }
                    else
                    {
                        errorCode = (int)SERVER_ERRORS.ADDRESS_NOT_FOUND;
                        throw new Exception("Cannot found address to listen to");
                    }
                }
            }
 
            //initialize the endpoints
            localEndPoint = new(ipAddress, config.Port);
            listener = new(ipAddress.AddressFamily,
                SocketType.Stream, ProtocolType.Tcp);
 
            SslConfiguration sslConf = config.SslSettings;
 
 
            //if ssl is set and configuration is set to use two ports we start the sslListener
            if ((sslConf.IsEnabled() || sslConf.IsDebugModeEnabled()) && sslConf.PortMode == SSL_PORT_MODE.DUAL_PORT)
            {
                sslLocalEndPoint = new(ipAddress, config.SslSettings.SslPort);
                if (sslLocalEndPoint == null)
                {
                    errorCode = (int)SERVER_ERRORS.CANNOT_CREATE_SSL_ENDPOINT;
                    throw new Exception("Cannot create SSL endpoint");
                }
                sslListener = new(ipAddress.AddressFamily,
                    SocketType.Stream, ProtocolType.Tcp);
                if (sslListener == null)
                {
                    errorCode = (int)SERVER_ERRORS.CANNOT_CREATE_SSL_LISTENER;
                    throw new Exception("Cannot create SSL listener");
                }
                if (sslConf.UseDebugCertificate)
                {
                    sslCertificate = SslConfiguration.TryLoadDebugCertificate(c: config);
                    if (sslCertificate == null)
                    {
                        errorCode = (int)SERVER_ERRORS.CANNOT_LOAD_DEBUG_CERTIFICATE;
                        throw new Exception("Cannot load debug certificate, server cannot start with this configuration! Make sure openssl is installed");
                    }
                }
                else if (sslConf.IsEnabled())
                    sslCertificate = sslConf.GetCertificate();
            }
 
            if (config.ListeningMode == IPMode.ANY)
            {
                listener.DualMode = true;
                if (config.SslSettings.IsEnabled())
                    sslListener!.DualMode = true;
            }
 
 
            if (sslConf.IsEnabled() || sslConf.IsDebugModeEnabled())
            {
                config.Debug.INFO("Server is running in SSL mode");
 
            }
            var prefix = "http";
            if ((sslConf.IsEnabled() || sslConf.IsDebugModeEnabled()) && sslConf.PortMode == SSL_PORT_MODE.DUAL_PORT)
            {
                if (config.PublicURL == "")
                    config.Debug.INFO($"Listening at https://{sslLocalEndPoint}/");
                else config.Debug.INFO($"Listening at https://{config.PublicURL}:{sslConf.SslPort}/");
            }
 
            else if ((sslConf.IsEnabled() || sslConf.IsDebugModeEnabled())&& sslConf.PortMode == SSL_PORT_MODE.SINGLE_PORT)
                prefix += "s";
 
            if (config.PublicURL == "")
                config.Debug.INFO($"Listening at {prefix}://{localEndPoint}/");
            else config.Debug.INFO($"Listening at {prefix}://{config.PublicURL}:{config.Port}/");
 
            config.Debug.INFO("Server started");
        }
        catch (Exception e)
        {
            config.Debug.ERROR("An exception occurred while initializing the server ->\n" + e);
            config.Debug.INFO("Server will now exit...");
            Environment.Exit(-errorCode);
        }
        //end of the server initialization
    }

Member Function Documentation

Main()

static void HSB.Server.Main ( )

static

Definition at line 25 of file Server.cs.

    {
        Terminal.INFO("HSB-# has wrongfully been compiled has executable and will not run!");
        Terminal.INFO("To run as standalone you must compile/execute the \"Standalone\" or the \"Launcher\" project");
        Terminal.INFO("Check the documentation for more info (\"https://github.com/lorenzoconcas/HSB-Sharp\")");
    }

Start()

void HSB.Server.Start

(

bool

openInBrowser = false

)

Definition at line 162 of file Server.cs.

    {
 
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(100);
 
            var sslConf = config.SslSettings;
 
            if (sslConf.IsEnabled() || sslConf.IsDebugModeEnabled())
            { //sslListener and sslLocalEndPoint are not null because we checked in the constructor
                sslListener!.Bind(sslLocalEndPoint!);
                sslListener.Listen(100);
            }
 
            OpenInBrowserIfSet(openInBrowser, sslConf.IsEnabled(), sslConf.PortMode == SSL_PORT_MODE.DUAL_PORT ? sslLocalEndPoint! : localEndPoint);
 
            //this makes the second port listen to SSL requests
            if ((sslConf.IsEnabled() || sslConf.IsDebugModeEnabled()) && sslConf.PortMode == SSL_PORT_MODE.DUAL_PORT)
            {
                new Task(() =>
                {
                    while (true)
                    {
                        Step(sslListener!, true);
                    }
                }).Start();
            }
 
            //since the base port is always listening this is always executed
            while (true)
            {
                //if ssl is enabled and single port is used
                var sslMode = (sslConf.IsEnabled() || sslConf.IsDebugModeEnabled()) && sslConf.PortMode == SSL_PORT_MODE.SINGLE_PORT;
 
                Step(listener, sslMode);
            }
        }
        catch (Exception e)
        {
            Terminal.ERROR(e);
        }
    }

---

The documentation for this class was generated from the following file:

• HSB/Server.cs