filter.h

Go to the documentation of this file.

 
 
#pragma once
// This header file is auto-generated!
// Do not make changes to this file or they will be overwritten.
// clang-format off
#include <cx/obj.h>
#include <cx/struct.h>
#include <cx/net/net_shared.h>
#include <cx/net/pool.h>
#include <cx/buffer/bufring.h>
 
CX_C_BEGIN
 
typedef struct NetFilter NetFilter;
typedef struct NetFilter_WeakRef NetFilter_WeakRef;
typedef struct NetFlowFilter NetFlowFilter;
typedef struct NetFlowFilter_WeakRef NetFlowFilter_WeakRef;
typedef struct NetStreamFilter NetStreamFilter;
typedef struct NetStreamFilter_WeakRef NetStreamFilter_WeakRef;
typedef struct NetDatagramFilter NetDatagramFilter;
typedef struct NetDatagramFilter_WeakRef NetDatagramFilter_WeakRef;
saDeclarePtr(NetFilter);
saDeclarePtr(NetFilter_WeakRef);
#define _sti_NetFilter _sti_object
#define SType_NetFilter NetFilter*
#define STStorageType_NetFilter NetFilter*
#define STypeArg_NetFilter(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(NetFilter, val))
#define STypeArgPtr_NetFilter(type, val) (stgeneric*)objInstCheckClassPtr(NetFilter, val)
#define STypeCheckedArg_NetFilter(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_NetFilter(type, val) stType(type), stArgPtr(type, val)
saDeclarePtr(NetFlowFilter);
saDeclarePtr(NetFlowFilter_WeakRef);
#define _sti_NetFlowFilter _sti_object
#define SType_NetFlowFilter NetFlowFilter*
#define STStorageType_NetFlowFilter NetFlowFilter*
#define STypeArg_NetFlowFilter(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(NetFlowFilter, val))
#define STypeArgPtr_NetFlowFilter(type, val) (stgeneric*)objInstCheckClassPtr(NetFlowFilter, val)
#define STypeCheckedArg_NetFlowFilter(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_NetFlowFilter(type, val) stType(type), stArgPtr(type, val)
saDeclarePtr(NetStreamFilter);
saDeclarePtr(NetStreamFilter_WeakRef);
#define _sti_NetStreamFilter _sti_object
#define SType_NetStreamFilter NetStreamFilter*
#define STStorageType_NetStreamFilter NetStreamFilter*
#define STypeArg_NetStreamFilter(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(NetStreamFilter, val))
#define STypeArgPtr_NetStreamFilter(type, val) (stgeneric*)objInstCheckClassPtr(NetStreamFilter, val)
#define STypeCheckedArg_NetStreamFilter(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_NetStreamFilter(type, val) stType(type), stArgPtr(type, val)
saDeclarePtr(NetDatagramFilter);
saDeclarePtr(NetDatagramFilter_WeakRef);
#define _sti_NetDatagramFilter _sti_object
#define SType_NetDatagramFilter NetDatagramFilter*
#define STStorageType_NetDatagramFilter NetDatagramFilter*
#define STypeArg_NetDatagramFilter(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(NetDatagramFilter, val))
#define STypeArgPtr_NetDatagramFilter(type, val) (stgeneric*)objInstCheckClassPtr(NetDatagramFilter, val)
#define STypeCheckedArg_NetDatagramFilter(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_NetDatagramFilter(type, val) stType(type), stArgPtr(type, val)
 
 
 
typedef struct NetFilter_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    NetFlowFilter* (*createFlow)(_In_ void* self, NetSocketType type);
    bool (*canFilter)(_In_ void* self, NetSocketType type);
} NetFilter_ClassIf;
extern NetFilter_ClassIf NetFilter_ClassIf_tmpl;
 
typedef struct NetFlowFilter_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    void (*shutdown)(_In_ void* self);
} NetFlowFilter_ClassIf;
extern NetFlowFilter_ClassIf NetFlowFilter_ClassIf_tmpl;
 
typedef struct NetStreamFilter_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    void (*shutdown)(_In_ void* self);
    // allocates encOut / decOut
    // tears down encOut / decOut
    intptr (*encode)(_In_ void* self, BufRing* src);
    intptr (*decode)(_In_ void* self, BufRing* src);
} NetStreamFilter_ClassIf;
extern NetStreamFilter_ClassIf NetStreamFilter_ClassIf_tmpl;
 
typedef struct NetDatagramFilter_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    void (*shutdown)(_In_ void* self);
    // releases any messages still queued in encOut / decOut back to their pool
    intptr (*encodeMsg)(_In_ void* self, NetMsgQueue* src);
    intptr (*decodeMsg)(_In_ void* self, NetMsgQueue* src);
} NetDatagramFilter_ClassIf;
extern NetDatagramFilter_ClassIf NetDatagramFilter_ClassIf_tmpl;
 
typedef struct NetFilter {
    union {
        NetFilter_ClassIf* _;
        void* _is_NetFilter;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
} NetFilter;
extern ObjClassInfo NetFilter_clsinfo;
#define NetFilter(inst) objInstCheckClass(NetFilter, inst)
#define NetFilterNone ((NetFilter*)NULL)
 
typedef struct NetFilter_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_NetFilter_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} NetFilter_WeakRef;
#define NetFilter_WeakRef(inst) objWeakRefCheckClass(NetFilter, inst)
 
#define netfilterCreateFlow(self, type) (self)->_->createFlow(NetFilter(self), type)
#define netfilterCanFilter(self, type) (self)->_->canFilter(NetFilter(self), type)
 
typedef struct NetFlowFilter {
    union {
        NetFlowFilter_ClassIf* _;
        void* _is_NetFlowFilter;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    // Pending out-of-band notification, or NFN_None. Written by notify() and cleared by the
    // data-plane driver once it delivers the matching NET_FilterNotify event; concrete filters
    // never read or write this directly.
    NetFilterNotify pendingNotify;
} NetFlowFilter;
extern ObjClassInfo NetFlowFilter_clsinfo;
#define NetFlowFilter(inst) objInstCheckClass(NetFlowFilter, inst)
#define NetFlowFilterNone ((NetFlowFilter*)NULL)
 
typedef struct NetFlowFilter_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_NetFlowFilter_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} NetFlowFilter_WeakRef;
#define NetFlowFilter_WeakRef(inst) objWeakRefCheckClass(NetFlowFilter, inst)
 
void NetFlowFilter_notify(_In_ NetFlowFilter* self, NetFilterNotify note);
#define netflowfilterNotify(self, note) NetFlowFilter_notify(NetFlowFilter(self), note)
 
#define netflowfilterShutdown(self) (self)->_->shutdown(NetFlowFilter(self))
 
typedef struct NetStreamFilter {
    union {
        NetStreamFilter_ClassIf* _;
        void* _is_NetStreamFilter;
        void* _is_NetFlowFilter;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    // Pending out-of-band notification, or NFN_None. Written by notify() and cleared by the
    // data-plane driver once it delivers the matching NET_FilterNotify event; concrete filters
    // never read or write this directly.
    NetFilterNotify pendingNotify;
    BufRing encOut;        
    BufRing decOut;        
} NetStreamFilter;
extern ObjClassInfo NetStreamFilter_clsinfo;
#define NetStreamFilter(inst) objInstCheckClass(NetStreamFilter, inst)
#define NetStreamFilterNone ((NetStreamFilter*)NULL)
 
typedef struct NetStreamFilter_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_NetStreamFilter_WeakRef;
        void* _is_NetFlowFilter_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} NetStreamFilter_WeakRef;
#define NetStreamFilter_WeakRef(inst) objWeakRefCheckClass(NetStreamFilter, inst)
 
#define netstreamfilterNotify(self, note) NetFlowFilter_notify(NetFlowFilter(self), note)
 
#define netstreamfilterShutdown(self) (self)->_->shutdown(NetStreamFilter(self))
//
// allocates encOut / decOut
// tears down encOut / decOut
#define netstreamfilterEncode(self, src) (self)->_->encode(NetStreamFilter(self), src)
#define netstreamfilterDecode(self, src) (self)->_->decode(NetStreamFilter(self), src)
 
typedef struct NetDatagramFilter {
    union {
        NetDatagramFilter_ClassIf* _;
        void* _is_NetDatagramFilter;
        void* _is_NetFlowFilter;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    // Pending out-of-band notification, or NFN_None. Written by notify() and cleared by the
    // data-plane driver once it delivers the matching NET_FilterNotify event; concrete filters
    // never read or write this directly.
    NetFilterNotify pendingNotify;
    NetMsgQueue encOut;        
    NetMsgQueue decOut;        
    NetPool* pool;
} NetDatagramFilter;
extern ObjClassInfo NetDatagramFilter_clsinfo;
#define NetDatagramFilter(inst) objInstCheckClass(NetDatagramFilter, inst)
#define NetDatagramFilterNone ((NetDatagramFilter*)NULL)
 
typedef struct NetDatagramFilter_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_NetDatagramFilter_WeakRef;
        void* _is_NetFlowFilter_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} NetDatagramFilter_WeakRef;
#define NetDatagramFilter_WeakRef(inst) objWeakRefCheckClass(NetDatagramFilter, inst)
 
#define netdatagramfilterNotify(self, note) NetFlowFilter_notify(NetFlowFilter(self), note)
 
#define netdatagramfilterShutdown(self) (self)->_->shutdown(NetDatagramFilter(self))
//
// releases any messages still queued in encOut / decOut back to their pool
#define netdatagramfilterEncodeMsg(self, src) (self)->_->encodeMsg(NetDatagramFilter(self), src)
#define netdatagramfilterDecodeMsg(self, src) (self)->_->decodeMsg(NetDatagramFilter(self), src)
 
CX_C_END