netgsource.c

Go to the documentation of this file.

#include <projectcommon.h>
#include <memory.h>
#include <glib.h>
#include <frameset.h>
#include <netgsource.h>

DEBUGDECLARATIONS


FSTATIC gboolean _netgsource_prepare(GSource* source, gint* timeout);
FSTATIC gboolean _netgsource_check(GSource* source);
FSTATIC gboolean _netgsource_dispatch(GSource* source, GSourceFunc callback, gpointer user_data);
FSTATIC void     _netgsource_finalize(GSource* source);
FSTATIC void    _netgsource_addListener(NetGSource*, guint16, Listener*);
FSTATIC void    _netgsource_del_listener(gpointer);
FSTATIC void    _netgsource_sendaframeset(NetGSource*,const NetAddr*, FrameSet*);
FSTATIC void    _netgsource_sendframesets(NetGSource*,const NetAddr*, GSList*);

static GSourceFuncs _netgsource_gsourcefuncs = {
        _netgsource_prepare,
        _netgsource_check,
        _netgsource_dispatch,
        _netgsource_finalize,
        NULL,
        NULL
};
FSTATIC void
_netgsource_del_listener(gpointer lptr)
{
        Listener*       lobj;
        if (lptr) {
                lobj = CASTTOCLASS(Listener, lptr);
                UNREF(lobj);
        }
}

NetGSource*
netgsource_new(NetIO* iosrc,                    
               GDestroyNotify notify,           
               gint priority,                   

               gboolean can_recurse,            
               GMainContext* context,           
               gsize objsize,                   
               gpointer userdata                
               )
{
        GSource*        gsret;
        NetGSource*     ret;
        GSourceFuncs*   gsf;

        BINDDEBUG(NetGSource);
        if (objsize < sizeof(NetGSource)) {
                objsize = sizeof(NetGSource);
        }
        gsf  = MALLOCBASECLASS(GSourceFuncs);
        *gsf = _netgsource_gsourcefuncs;
        
        gsret = g_source_new(gsf, objsize);
        if (gsret == NULL) {
                FREECLASSOBJ(gsf);
                g_return_val_if_reached(NULL);
        }
        proj_class_register_object(gsret, "GSource");
        proj_class_register_subclassed(gsret, "NetGSource");
        ret = CASTTOCLASS(NetGSource, gsret);

        ret->_gsfuncs = gsf;
        ret->_userdata = userdata;
        ret->_netio = iosrc;
        iosrc->setblockio(iosrc, FALSE);
        ret->_socket = iosrc->getfd(iosrc);
        ret->_finalize = notify;
        ret->_gfd.fd = ret->_socket;
        ret->_gfd.events = G_IO_IN|G_IO_ERR|G_IO_HUP;
        ret->_gfd.revents = 0;
        ret->addListener = _netgsource_addListener;
        ret->sendframesets = _netgsource_sendframesets;
        ret->sendaframeset = _netgsource_sendaframeset;

        g_source_add_poll(gsret, &ret->_gfd);
        g_source_set_priority(gsret, priority);
        g_source_set_can_recurse(gsret, can_recurse);

        ret->_gsourceid = g_source_attach(gsret, context);

        if (ret->_gsourceid == 0) {
                FREECLASSOBJ(gsf);
                g_source_remove_poll(gsret, &ret->_gfd);
                memset(ret, 0, sizeof(*ret));
                g_source_unref(gsret);
                gsret = NULL;
                ret = NULL;
                g_return_val_if_reached(NULL);
        }
        // REF(ret->_netio);
        ret->_dispatchers = g_hash_table_new_full(NULL, NULL, NULL, _netgsource_del_listener);
        return ret;
}

FSTATIC gboolean
_netgsource_prepare(GSource* source,    
                    gint* timeout)      
{
        (void)source; (void)timeout;
        return _netgsource_check(source);
}

FSTATIC gboolean
_netgsource_check(GSource* gself)       
{
        NetGSource*     self = CASTTOCLASS(NetGSource, gself);
        // revents: received events...
        // @todo: probably should check for errors in revents
        return ((0 != self->_gfd.revents) || self->_netio->input_queued(self->_netio));
}
FSTATIC gboolean
_netgsource_dispatch(GSource* gself,                    
                     GSourceFunc ignore_callback,       
                     gpointer ignore_userdata)          
{
        NetGSource*     self = CASTTOCLASS(NetGSource, gself);
        GSList*         gsl;
        NetAddr*        srcaddr;
        (void)ignore_callback; (void)ignore_userdata;
        if ((self->_gfd.revents & (G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL|G_IO_PRI)) == 0) {
                DEBUGMSG("%s.%d: Dispatched due to UNKNOWN REASON: 0x%04x"
                ,       __FUNCTION__, __LINE__, self->_gfd.revents);
        }
        while(NULL != (gsl = self->_netio->recvframesets(self->_netio, &srcaddr))) {
                for (; NULL != gsl; gsl = gsl->next) {
                        Listener*       disp = NULL;
                        FrameSet*               fs = CASTTOCLASS(FrameSet, gsl->data);
                        disp = g_hash_table_lookup(self->_dispatchers, GUINT_TO_POINTER((size_t)fs->fstype));
                        if (NULL == disp) {
                                disp = CASTTOCLASS(Listener, g_hash_table_lookup(self->_dispatchers, NULL));
                        }
                        if (NULL != disp) {
                                disp->got_frameset(disp, fs, srcaddr);
                        }else{ 
                                g_warning("No dispatcher for FrameSet type %d", fs->fstype);
                        }
                }
                UNREF(srcaddr);
        }
        return TRUE;
}

FSTATIC void
_netgsource_finalize(GSource* gself)    
{
#ifndef __FUNCTION__
#       define __FUNCTION__ "_netgsource_finalize"
#endif
        NetGSource*     self = CASTTOCLASS(NetGSource, gself);
        DEBUGMSG("%s(%p) FINALIZING!", __FUNCTION__, self);
        if (self->_finalize) {
                DEBUGMSG("%s: finalizing object at %p with %p", __FUNCTION__, self->_userdata
                ,       self->_finalize);
                self->_finalize(self->_userdata);
        }else{
                if (self->_userdata) {
                        FREECLASSOBJ(self->_userdata);
                        self->_userdata = NULL;
                        DEBUGMSG("%s: FREECLASSOBJ(%p)", __FUNCTION__, self->_userdata);
                }
        }
        if (self->_gsfuncs) {
                FREECLASSOBJ(self->_gsfuncs);
                self->_gsfuncs = NULL;
        }
        // UNREF(self->_netio);
        g_hash_table_unref(self->_dispatchers);
        proj_class_dissociate(gself);// Avoid dangling reference in class system
}
FSTATIC void
_netgsource_sendaframeset(NetGSource*           self,   
                          const NetAddr*        addr,   
                          FrameSet*             fs)     
{
        NetIO* nio = self->_netio;
        nio->sendaframeset(nio, addr, fs);
}
FSTATIC void
_netgsource_sendframesets(NetGSource*           self,   
                          const NetAddr*        addr,   
                          GSList*               fslist) 
{
        NetIO* nio = self->_netio;
        nio->sendframesets(nio, addr, fslist);
}
FSTATIC void
_netgsource_addListener(NetGSource* self,       
                        guint16 fstype,         
                        Listener* disp)         
{
        if (disp) {
                REF(disp);
        }
        g_hash_table_replace(self->_dispatchers, GUINT_TO_POINTER((size_t)fstype), disp);
}