Webserver Plugin

One of the cores of the innovaphone App Platform is the webserver (see "The core of the innovaphone App Platform" for details). An App can plugin itself to the webserver to receive HTTP or websocket requests. If an App whants to offer an JavaScript UI too, it actually must plugin itself into the webserver. However, this can be done by using the IWebserverPlugin interface.

The app needs to give a path to the IWebserverPlugin on creation and call IWebserverPlugin::HttpListen(), IWebserverPlugin::WebsocketListen() or IWebserverPlugin::PassthroughListen() to receive the different requests. The path given to the interface on creation will be the applications web root. So if e. G. the system is accassibly under http://192.168.1.100 and the application passes "/myapp" as path, it will be accessibly under http://192.168.1.100/myapp, wich will be the apps root. The root of the system is reserved for the Manager of the innovaphone App Platform. The application will receive every request to that path and below.

The webserver plugin is a collection of a bunch of interfaces, used for web communication. Each web request type (like GET, PUT, POST, ...) has it's own interface to handle the request. They also have ther own user class an application must subclass and pass to the IWebserverPlugin isntance to accept a request. This user class is responsible for sending and receiveing data, settings additional informations (like chunk encoded transfer, the number of bytes the response have, the data type of the response).

The IWebserverPlugin also supports static files. Those files will be converted to a C++ file, compiled and finally linked to the applications binary. This files will be automatically handled by the IWebserverPlugin. That means, that a request of a static file never will reach the applications coded. Instead, the IWebserverPlugin will send the file to the webserver who will send it to the client that requested the file. So for each incomming GET request, the IWebserverPlugin will at first look at the list of static files, if the request is for one of them. If not, the UWebserverPlugin::WebserverHttpListenResult() function will be called, so that the application can respond to that request or deny it. Note that the static files name also can include subfolder. So a static file can be linked to the applications binary as "images/icon.png", it can be accessed by a client at "http://<server-address>/<applications-root>/images/icon.png".

File information

Functions

Functions to initialize

extern IWebserverPluginProvider * CreateWebserverPluginProvider();

Overview

Helper functions

inline wsr_type_t GetResponseTypeForFileName(const char * fileName);
inline const char * WSCancelTypeToStr(wsr_cancel_type_t c);
inline const char * WSPCloseReasonToStr(wsp_close_reason_t cr);
inline const char * WSWebdavResultToStr(ws_webdav_result_t r);

Overview

Classes

class IWebserverPluginProvider {
public:
    virtual ~IWebserverPluginProvider() {}
    virtual class IWebserverPlugin * CreateWebserverPlugin(class IIoMux * const iomux,
                                                           class ISocketProvider * localSocketProvider,
                                                           class UWebserverPlugin * const user,
                                                           const char * webserverAddress,
                                                           const char * appWebRoot,
                                                           class IInstanceLog * const log);
};

Overview

Public functions

class IWebserverPlugin {
public:
    virtual ~IWebserverPlugin() {};

    virtual void SendCertificate(const char * password, const byte * certBuf, size_t certLen, const char * hostName = nullptr, UWebserverPlugin * user = nullptr);
    virtual void HttpListen(const char * path = nullptr, UWebserverPlugin * user = nullptr, const char * authUser = nullptr, const char * authUserPwd = nullptr, const char * staticFilePrefix = nullptr);
    virtual void HttpListen(const char * path, UWebserverPlugin * user, bool dynamicAuth, const char * staticFilePrefix = nullptr);
    virtual void PassthroughListen(const char * path = nullptr, UWebserverPlugin * user = nullptr);
    virtual void WebsocketListen(const char * path = nullptr, UWebserverPlugin * user = nullptr);
    virtual void SetAuthConfig(const char * path, const char * authUser = nullptr, const char * authPwd = nullptr);
    virtual void SetAuthConfig(const char * path, bool enableDynAuth);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Redirect(const char * newDestination);

    virtual void Accept(class UWebserverGet * const user);
    virtual void Accept(class UWebserverPost * const user);
    virtual void Accept(class UWebserverPut * const user);
    virtual void Accept(class UWebserverPassthrough * const user);
    virtual void Accept(class UWebserverPropfind * const user);
    virtual void Accept(class UWebserverMove * const user);
    virtual void Accept(class UWebserverMkCol * const user);
    virtual void Accept(class UWebserverCopy * const user);
    virtual void Accept(class UWebserverDelete * const user);
    virtual void Accept(class UWebserverLock * const user);
    virtual void Accept(class UWebserverUnlock * const user);
    virtual void Accept(class UWebserverProppatch * const user);
    virtual void Accept(class UWebserverOptions * const  user);
    virtual void WebsocketAccept(class UWebsocket * user);

    virtual void RequestUserPasswordResult(dword connectionID, const char * user, const char * password);

    virtual void Close();
};

Overview

Logging

Public functions

class UWebserverPlugin {
public:
    virtual ~UWebserverPlugin() {}

    virtual void WebserverPluginClose(IWebserverPlugin * plugin, wsp_close_reason_t reason, bool lastUser)
    {
        if (lastUser) delete plugin;
    }
    
    virtual void WebserverPluginHttpListenResult(IWebserverPlugin * plugin, ws_request_type_t requestType, char * resourceName, const char * registeredPathForRequest, ulong64 dataSize)
    {
        plugin->Cancel(WSP_CANCEL_NOT_FOUND);
    }

    virtual void WebserverPluginPassthroughListenResult(IWebserverPlugin * plugin, char * resourceName, const char * registeredPathForRequest, ulong64 dataSize)
    {
        plugin->Cancel(WSP_CANCEL_NOT_FOUND);
    }

    virtual void WebserverPluginWebsocketListenResult(IWebserverPlugin * plugin, const char * path, const char * registeredPathForRequest, const char * host)
    {
        plugin->WebsocketAccept(nullptr);
    }

    virtual void WebserverPluginConnected() {}
    virtual void WebserverPluginSendCertificateResult(IWebserverPlugin * plugin, byte * certBuffer) {}
    virtual void WebserverPluginRegisterPathResult(IWebserverPlugin * plugin, const char * pathName, wsp_path_type_t pathType) {}
    virtual void WebserverPluginRequestUserPassword(IWebserverPlugin * plugin, dword connectionID, char * resourceName, const char * registeredPathForRequest, const char * host, const char * user) { ASSERT(false, "UWebserverPlugin::WebserverPluginRequestUserPassword() not implemented!"); }
    virtual void SetAuthConfigResult(const char * path, ws_update_auth_result_t result) {}    
};

Overview

Public functions

class IWebserverGet {
public:
    virtual ~IWebserverGet() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetETag();
    virtual ulong64 GetRangeCount();
    virtual IWebserverGetRange * GetRange(size_t idx);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetTransferInfo(wsr_type_t resourceType, ulong64 dataSize, wsr_flags_t flags = WSP_FLAG_NONE, const char * etag = nullptr);
    virtual void SetTransferRange(ulong64 rangeStart, ulong64 rangeEnd);
    virtual void ForceDownloadResponse(const char * fileName = nullptr);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class IWebserverGetRange {
public:
    IWebserverGetRange() {}
    virtual ~IWebserverGetRange() {}

    enum range_type_t {
        RANGE_NONE       = 0x00,
        RANGE_START_END  = 0x01,
        RANGE_START_ONLY = 0x02,
        RANGE_LAST_BYTES = 0x03
    } rangeType;

    ulong64 start;
    ulong64 end;
};

Overview

Remarks

Public fields

class UWebserverGet {
public:
    virtual ~UWebserverGet() {}
        
    virtual void WebserverGetRequestAcceptComplete(IWebserverGet * const webserverGet);
    virtual void WebserverGetSendResult(IWebserverGet * const webserverGet);
    virtual void WebserverGetCloseComplete(IWebserverGet * const webserverGet);
};

Overview

Remarks

Public functions

class IWebserverPost {
public:
    virtual ~IWebserverPost() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual ulong64 GetDataSize();
    virtual bool DataIsChunkEncoded();

    virtual void SetTransferInfo(wsr_type_t resourceType, ulong64 dataSize, wsr_flags_t flags = WSP_FLAG_NONE, const char * etag = nullptr);
    virtual void ForceDownloadResponse(const char * fileName = nullptr);
    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Send(void * buffer, size_t len);
    virtual void Recv(void * buffer = nullptr, size_t len = 0);
    virtual void Close();
};

Overview

Public functions

class UWebserverPost {
public:
    virtual ~UWebserverPost() {}
        
    virtual void WebserverPostRequestAcceptComplete(IWebserverPost * const webserverPost);
    virtual void WebserverPostSendResult(IWebserverPost * const webserverPost) {}
    virtual void WebserverPostRecvResult(IWebserverPost * const webserverPost, void * buffer, size_t len);
    virtual void * WebserverPostRecvBuffer(size_t len) { return nullptr; }
    virtual void WebserverPostCloseComplete(IWebserverPost * const webserverPost);
};

Overview

Remarks

Public functions

class IWebserverPut {
public:
    virtual ~IWebserverPut() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual ulong64 GetDataSize();
    virtual bool DataIsChunkEncoded();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Send(void * buffer, size_t len);
    virtual void Recv(void * buffer = nullptr, size_t len = 0);
    virtual void Close();
};

Overview

Public functions

class UWebserverPut {
public:
    virtual ~UWebserverPut() {}
            
    virtual void WebserverPutRequestAcceptComplete(IWebserverPut * const webserverPut);
    virtual void WebserverPutSendResult(IWebserverPut * const webserverPut);
    virtual void WebserverPutRecvResult(IWebserverPut * const webserverPut, void * buffer, size_t len);
    virtual void * WebserverPutRecvBuffer(size_t len) { return nullptr; }
    virtual void WebserverPutCloseComplete(IWebserverPut * const webserverPut);
};

Overview

Remarks

Public functions

class IWebserverPropfind {
public:
    virtual ~IWebserverPropfind() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual ulong64 GetDataSize();
    virtual bool DataIsChunkEncoded();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Recv(void * buffer = nullptr, size_t len = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverPropfind {
public:
    virtual ~UWebserverPropfind() {};
    virtual void WebserverPropfindRequestAcceptComplete(IWebserverPropfind * const webserverPropfind);
    virtual void WebserverPropfindSendResult(IWebserverPropfind * const webserverPropfind);
    virtual void WebserverPropfindRecvResult(IWebserverPropfind * const webserverPropfind, void * buffer, size_t len);
    virtual void * WebserverPropfindRecvBuffer(size_t len)
    {
        return nullptr;
    }
        
    virtual void WebserverPropfindCloseComplete(IWebserverPropfind * const webserverPropfind);
};

Overview

Remarks

Public functions

class IWebserverMove {
public:
    virtual ~IWebserverMove() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void SetLocation(const char * location);
    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverMove {
public:
    virtual ~UWebserverMove() {};
    virtual void WebserverMoveRequestAcceptComplete(IWebserverMove * const webserverMove);
    virtual void WebserverMoveSendResult(IWebserverMove * const webserverMove);
    virtual void WebserverMoveCloseComplete(IWebserverMove * const webserverMove);
};

Overview

Remarks

Public functions

class IWebserverMkCol {
public:
    virtual ~IWebserverMkCol() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void SetLocation(const char * location);
    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverMkCol {
public:
    virtual ~UWebserverMkCol() {};
    virtual void WebserverMkColRequestAcceptComplete(IWebserverMkCol * const webserverMkCol);
    virtual void WebserverMkColSendResult(IWebserverMkCol * const webserverMkCol);
    virtual void WebserverMkColCloseComplete(IWebserverMkCol * const webserverMkCol);
};

Overview

Remarks

Public functions

class IWebserverCopy {
public:
    virtual ~IWebserverCopy() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverCopy {
public:
    virtual ~UWebserverCopy() {};
    virtual void WebserverCopyRequestAcceptComplete(IWebserverCopy * const webserverCopy);
    virtual void WebserverCopySendResult(IWebserverCopy * const webserverCopy);
    virtual void WebserverCopyCloseComplete(IWebserverCopy * const webserverCopy);
};

Overview

Remarks

Public functions

class IWebserverDelete {
public:
    virtual ~IWebserverDelete() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverDelete {
public:
    virtual ~UWebserverDelete() {};
    virtual void WebserverDeleteRequestAcceptComplete(IWebserverDelete * const webserverDelete);
    virtual void WebserverDeleteSendResult(IWebserverDelete * const webserverDelete);
    virtual void WebserverDeleteCloseComplete(IWebserverDelete * const webserverDelete);
};

Overview

Remarks

Public functions

class IWebserverLock {
public:
    virtual ~IWebserverLock() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetResultCode(ws_webdav_result_t result, size_t dataSize = 0);
    virtual void Recv(void * buffer = nullptr, size_t len = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverLock {
public:
    virtual ~UWebserverLock() {};
    virtual void WebserverLockRequestAcceptComplete(IWebserverLock * const webserverLock);
    virtual void WebserverLockSendResult(IWebserverLock * const webserverLock);
    virtual void WebserverLockRecvResult(IWebserverLock * const webserverLock, void * buffer, size_t len);
    virtual void * WebserverLockRecvBuffer(size_t len)
    {
        return nullptr;
    }
    virtual void WebserverLockCloseComplete(IWebserverLock * const webserverLock);
};

Overview

Remarks

Public functions

class IWebserverUnlock {
public:
    virtual ~IWebserverUnlock() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverUnlock {
public:
    virtual ~UWebserverUnlock() {};
    virtual void WebserverUnlockRequestAcceptComplete(IWebserverUnlock * const webserverUnlock);
    virtual void WebserverUnlockSendResult(IWebserverUnlock * const webserverUnlock);
    virtual void WebserverUnlockCloseComplete(IWebserverUnlock * const webserverUnlock);
};

Overview

Remarks

Public functions

class IWebserverProppatch {
public:
    virtual ~IWebserverProppatch() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();
    virtual const char * GetHeaderFieldValue(const char * fieldName);

    virtual void Cancel(wsr_cancel_type_t reason);
    virtual void SetResultCode(ws_webdav_result_t result, ulong64 dataSize = 0);
    virtual void Recv(void * buffer = nullptr, size_t len = 0);
    virtual void Send(void * buffer, size_t len);
    virtual void Close();
};

Overview

Public functions

class UWebserverProppatch {
public:
    virtual ~UWebserverProppatch() {};
    virtual void WebserverProppatchRequestAcceptComplete(IWebserverProppatch * const webserverProppatch);
    virtual void WebserverProppatchSendResult(IWebserverProppatch * const webserverProppatch);
    virtual void WebserverProppatchRecvResult(IWebserverProppatch * const webserverProppatch, void * buffer, size_t len);
    virtual void * WebserverProppatchRecvBuffer(size_t len)
    {
        return nullptr;
    }
    virtual void WebserverProppatchCloseComplete(IWebserverProppatch * const webserverProppatch);
};

Overview

Remarks

Public functions

class IWebserverOptions {
public:
    virtual ~IWebserverOptions() {}

    virtual const char * GetResourceName();
    virtual const char * GetRegisteredPathForRequest();

    virtual void SetSupportedRequests(dword requestList);
    virtual void Close();
};

Overview

Public functions

class UWebserverOptions {
public:
    virtual ~UWebserverOptions() {}
    virtual void WebserverOptionsRequestAcceptComplete(IWebserverOptions * const webserverOptions)
    {
        webserverOptions->SetSupportedRequests(WS_REQUEST_GET | WS_REQUEST_POST | WS_REQUEST_PUT |
                                               WS_REQUEST_PROPFIND | WS_REQUEST_MOVE | WS_REQUEST_COPY |
                                               WS_REQUEST_MKCOL | WS_REQUEST_DELETE | WS_REQUEST_OPTIONS |
                                               WS_REQUEST_LOCK | WS_REQUEST_UNLOCK | WS_REQUEST_PROPPATCH);
        webserverOptions->Close();
    }

    virtual void WebserverOptionsCloseComplete(IWebserverOptions * const webserverOptions);
};

Overview

Remarks

Public functions

class IWebsocket {
public:
    virtual ~IWebsocket() {}

    virtual const char * GetHost();
    virtual const char * GetPath();
    virtual bool IsSysClientAuthenticated();
    virtual bool IsLocalHost();

    virtual void Send(const void * buffer, size_t len, bool text = true);
    virtual void Recv(void * buf = nullptr, size_t len = 0);
    virtual void Close();
};

Overview

Public functions

class UWebsocket {
public:
    virtual ~UWebsocket() {}
    virtual void WebsocketAcceptComplete(class IWebsocket * websocket);
    virtual void WebsocketSendResult(class IWebsocket * websocket);
    virtual void WebsocketRecvResult(class IWebsocket * websocket, void * buffer, size_t len, bool text, bool isFragmented);
    virtual void * WebsocketRecvBuffer(size_t len) { return nullptr; }
    virtual void WebsocketCloseComplete(class IWebsocket * websocket, ws_close_reason_t reason);
};

Overview

Public functions

class IWebserverPassthrough {
    public:
        virtual ~IWebserverPassthrough() {}
            
        virtual const char * GetResourceName();
        virtual const char * GetRegisteredPathForRequest();
        virtual bool IsEncryptedConnection();
            
        virtual void Send(void * buffer, size_t size);
        virtual void Recv(void * buffer = nullptr, size_t len = 0);
        virtual void Close();
    };

Overview

Remarks

Public functions

class UWebserverPassthrough {
public:
    virtual ~UWebserverPassthrough() {}

    virtual void WebserverPassthroughRequestAcceptComplete(IWebserverPassthrough * const webserverPassthrough);
    virtual void WebserverPassthroughSendResult(IWebserverPassthrough * const webserverPassthrough);
    virtual void WebserverPassthroughRecvResult(IWebserverPassthrough * const webserverPassthrough, void * buffer, size_t len);
    virtual void * WebserverPassthroughRecvBuffer(size_t len) { return nullptr; }
    virtual void WebserverPassthroughCloseComplete(IWebserverPassthrough * const webserverPassthrough);
};

Overview

Remarks

Public functions

Data types

Defines / Statics

wsr_cancel_type_t

typedef enum {
    // Everything from 0 to 15 will be internal types
    WSP_CANCEL_NOT_FOUND = 0x10,
    WSP_CANCEL_BAD_REQUEST,
    WSP_CANCEL_UNAVAILABLE,
    WSP_CANCEL_MISSING_LENGTH,
    WSP_CANCEL_STREAM,
    WSP_CANCEL_ACCESS_DENIED,
    WSP_CANCEL_INTERNAL_ERROR
} wsr_cancel_type_t;

Overview

Values

wsp_path_type_t

typedef enum {
    WSP_PATH_TYPE_HTTP,
    WSP_PATH_TYPE_WEBSOCKET,
    WSP_PATH_TYPE_PASSTHROUGH
} wsp_path_type_t;

Overview

Values

ws_webdav_result_t

typedef enum {
    WEBDAV_RESULT_OK = 0x100,
    WEBDAV_RESULT_CREATED,
    WEBDAV_RESULT_NO_CONTENT,
    WEBDAV_RESULT_MULTIPLE_STATUS,
    WEBDAV_RESULT_FORBIDDEN,
    WEBDAV_RESULT_METHOD_NOT_ALLOWED,
    WEBDAV_RESULT_CONFLICT,
    WEBDAV_RESULT_PRECONDITION_FAILED,
    WEBDAV_RESULT_LOCKED,
    WEBDAV_RESULT_BAD_GATEWAY,
    WEBDAV_RESULT_INSUFFICIENT_STORAGE
} ws_webdav_result_t;

Overview

Values

wsr_type_t

typedef enum {
    // Start of resource file types
    WSP_RESPONSE_NO_TYPE = 0x100,
    WSP_RESPONSE_BINARY,
    WSP_RESPONSE_JAVA,
    WSP_RESPONSE_WAV,
    WSP_RESPONSE_OGG,
    WSP_RESPONSE_MP3,
    WSP_RESPONSE_GIF,
    WSP_RESPONSE_PNG,
    WSP_RESPONSE_BMP,
    WSP_RESPONSE_ICON,
    WSP_RESPONSE_TTF,
    WSP_RESPONSE_EOT,
    WSP_RESPONSE_PDF,
    WSP_RESPONSE_TEXT,
    WSP_RESPONSE_XML,
    WSP_RESPONSE_CSS,
    WSP_RESPONSE_JAVASCRIPT,
    WSP_RESPONSE_JSON,
    WSP_RESPONSE_HTML,
    WSP_RESPONSE_SVG,
    WSP_RESPONSE_WOFF,
    WSP_RESPONSE_G711,
    WSP_RESPONSE_G722,
    WSP_RESPONSE_G729,
    WSP_RESPONSE_JPEG,
    WSP_RESPONSE_MP4,
    WSP_RESPONSE_WEBM,
    WSP_RESPONSE_PEM,
    WSP_RESPONSE_MOBILECONFIG,
    WSP_RESPONSE_CACHE_MANIFEST,
    WSP_RESPONSE_OPUS,
    WSP_RESPONSE_CSV,
} wsr_type_t;

Overview

wsp_close_reason_t

typedef enum {
    WSP_NORMAL_CLOSE,                // The app itself initiated the shutdown
    WSP_REGISTER_PATH_INVALID,       // The given path is invalid
    WSP_WEBSOCKET_PATH_INVALID,      // The given Websocket listen path is invalid.
    WSP_WEBSOCKET_PATH_ALREADY_LISTENING, // Someone alrady is listening to that path for websocekt connections
    WSP_PATH_ALREADY_REGISTERD,      // A data provider already registered to that resource
    WSP_ADDRESS_INVALID,             // The address the application tried to connect to was invalid
    WSP_CONNECTION_ERROR             // An connection error occured (see log, if exists),
} wsp_close_reason_t;

Overview

Values

ws_close_reason_t

typedef enum {
    WSCR_NORMAL_CLOSE,
    WSCR_BUFFER_OVERFLOW,
    WSCR_SOCKET_LOST,
    WSCR_ERROR,
} ws_close_reason_t;

Overview

Values

ws_request_type_t

typedef enum {
    WS_REQUEST_GET          = 0x0001,
    WS_REQUEST_POST         = 0x0002,
    WS_REQUEST_PUT          = 0x0004,
    WS_REQUEST_PASSTHROUGH  = 0x0008,
    WS_REQUEST_PROPFIND     = 0x0010,
    WS_REQUEST_MOVE         = 0x0020,
    WS_REQUEST_COPY         = 0x0040,
    WS_REQUEST_MKCOL        = 0x0080,
    WS_REQUEST_DELETE       = 0x0100,
    WS_REQUEST_OPTIONS      = 0x0200,
    WS_REQUEST_LOCK         = 0x0400,
    WS_REQUEST_UNLOCK       = 0x0800,
    WS_REQUEST_PROPPATCH    = 0x1000
} ws_request_type_t;

Overview

Values

ws_update_auth_result_t

typedef enum {
    WS_AUTH_DECACTIVATED,
    WS_AUTH_DYNAMIC,
    WS_AUTH_STATIC,
    WS_AUTH_ERR_PATH_NOT_LISTENING,
    WS_AUTH_ERR_PATH_INVALID
} ws_update_auth_result_t;

Overview

Values

IWebserverGetRange::range_type_t

class IWebserverGetRange {
public:
    enum range_type_t {
        RANGE_NONE       = 0x00,
        RANGE_START_END  = 0x01,
        RANGE_START_ONLY = 0x02,
        RANGE_LAST_BYTES = 0x03
    } rangeType;
};

Overview

Values

Structures

ws_type_sfx_t

typedef struct {
    const char * sfx;
    wsr_type_t type;
} ws_type_sfx_t;
    
    
static const ws_type_sfx_t suffixes[] = {
    { "html", WSP_RESPONSE_HTML },
    { "htm", WSP_RESPONSE_HTML },
    { "css", WSP_RESPONSE_CSS },
    { "xml", WSP_RESPONSE_XML },
    { "xsl", WSP_RESPONSE_XML },
    { "js", WSP_RESPONSE_JAVASCRIPT },
    { "json", WSP_RESPONSE_JSON },
    { "ico", WSP_RESPONSE_ICON },
    { "bin", WSP_RESPONSE_BINARY },
    { "jar", WSP_RESPONSE_JAVA },
    { "png", WSP_RESPONSE_PNG },
    { "gif", WSP_RESPONSE_GIF },
    { "bmp", WSP_RESPONSE_BMP },
    { "pdf", WSP_RESPONSE_PDF },
    { "wav", WSP_RESPONSE_WAV },
    { "ogg", WSP_RESPONSE_OGG },
    { "mp3", WSP_RESPONSE_MP3 },
    { "txt", WSP_RESPONSE_TEXT },
    { "soap", WSP_RESPONSE_XML },
    { "svg", WSP_RESPONSE_SVG },
    { "ttf", WSP_RESPONSE_TTF },
    { "eot", WSP_RESPONSE_EOT },
    { "woff", WSP_RESPONSE_WOFF },
    { "woff2", WSP_RESPONSE_WOFF },
    { "g711a", WSP_RESPONSE_G711 },
    { "g711u", WSP_RESPONSE_G711 },
    { "g722", WSP_RESPONSE_G722 },
    { "g729", WSP_RESPONSE_G729 },
    { "jpeg", WSP_RESPONSE_JPEG },
    { "mp4", WSP_RESPONSE_MP4 },
    { "webm", WSP_RESPONSE_WEBM },
    { "pem", WSP_RESPONSE_PEM },
    { "mobileconfig", WSP_RESPONSE_MOBILECONFIG },
    { "appcache", WSP_RESPONSE_CACHE_MANIFEST },
    { "opus-nb", WSP_RESPONSE_OPUS },
    { "opus-wb", WSP_RESPONSE_OPUS },
    { "csv", WSP_RESPONSE_CSV },
};

Overview

Values

Code Example

app::app(IIoMux * iomux)
    : iomux(iomux)
{
    this->webserverPlugin = IWebserverPlugin::Create(iomux, this);
    this->webserverPlugin->RegisterForPath("/path/to/webserver", "/demoapp/main");
}

void app::WebserverPluginWebRequest(IWebserverPlugin * plugin, ws_request_type_t requestType, char * resourceName, ulong64 dataSize)
{
    if (requestType != WS_REQUEST_GET || strcmp(resourceName, "myresource.png") != 0)
        plugin->Cancel(WSP_CANCEL_NOT_FOUND);
    else {
        plugin->Accept(new MyGetHandler);
    }
}

// ==== MyGetHandler

class MyGetHandler {
protected:
    char * dataBuffer;
    ulong64 dataSize;
    ulong64 dataSend;

public:
    MyGetHandler() {}
    ~MyGetHandler() {}

    void WebserverGetRequestAcceptComplete(IWebserverGet * const webserverGet)
    {
        // We assume that there is a function that returns the http file instance...
        httpfile * myFile = GetFileForName(webserverGet->GetResourceName());

        dataBuffer = myFile->GetData();
        dataSize = myFile->GetSize();
        dataSend = 0;

        webserverGet->SetTransferInfo(wsr_type_t(myFile->GetResourceType()),
                                      myFile->GetSize(),
                                      wsr_flags_t(myFile->GetFlags()));

        this->SendNextPart(webserverGet);

    }

    void WebserverGetSendResult(IWebserverGet * const webserverGet)
    {
        this->SendNextPart(webserverGet);
    }

    void SendNextPart(IWebserverGet * const webserverGet)
    {
        ulong64 dataSize = staticFile->GetSize();

        if (bytesSend < dataSize) {
            ulong64 dataSizeDiff = dataSize - bytesSend;
            ulong64 sendSize = dataSizeDiff > WS_MAX_DATA_SIZE ? WS_MAX_DATA_SIZE : dataSizeDiff;
            webserverGet->Send((void *)(dataBuffer + bytesSend), sendSize);
            bytesSend += sendSize;
            if (bytesSend == dataSize)
                webserverGet->Close();
        }
    }


    void WebserverGetCloseComplete(IWebserverGet * const webserverGet)
    {
        delete webserverGet;
        delete this;
    }
};

app::app(IIoMux * iomux)
    : iomux(iomux)
{
    this->webserverPlugin = IWebserverPlugin::Create(iomux, this);
    this->webserverPlugin->RegisterForPath("/path/to/webserver", "/demoapp/main");
    this->webserverPlugin->WebsocketListen();
}

void app::WebserverWebsocketListenResult(IWebserverPlugin * plugin, const char * path, const char * host)
{
    if (strcmp(host, "some-bad-host.de") == 0)
        this->webserverPlugin->Accept(nullptr); // Deny conection.
    else
        this->webserverPlugin->Accept(new appWebsocket());
}

// appWebsocket - user for IWebsocket

void appWebsocket::WebsocketAcceptComplete(class IWebsocket * websocket)
{
    this->websocketInst = websocket;
}

void appWebsocket::WebsocketSendResult(class IWebsocket * websocket)
{
    printf("Websocket data sent\n");
    this->websocketInst->Close();
}

void appWebsocket::WebsocketRecvResult(class IWebsocket * websocket, const void * buffer, size_t len, bool text)
{
    printf("Websocket - received data (text = %s)\n", (text ? "true" : "false"));
    debug->HexDump(buffer, len);
    this->websocketInst->Send(buffer, len, text);
}

void appWebsocket::WebsocketCloseComplete(class IWebsocket * websocket, ws_close_reason_t reason)
{
    delete this->websocketInst;
    delete this;
}