authlistener.c

Go to the documentation of this file.

#include <projectcommon.h>
#include <memory.h>
#include <glib.h>
#include <frame.h>
#include <frameset.h>
#define IS_LISTENER_SUBCLASS
#include <authlistener.h>
FSTATIC void _authlistener_finalize(AssimObj * self);
FSTATIC gboolean _authlistener_got_frameset(Listener* self, FrameSet*, NetAddr*);
FSTATIC void _authlistener_associate(Listener* self, NetGSource* transport);
FSTATIC void _authlistener_dissociate(Listener* self);

DEBUGDECLARATIONS

#define ONESEC  1000000

FSTATIC gboolean
_authlistener_got_frameset(Listener* self, FrameSet* fs, NetAddr* addr)
{
        AuthListener*           aself = CASTTOCLASS(AuthListener, self);
        AuthListenerAction      action;

        action = g_hash_table_lookup(aself->actionmap, GINT_TO_POINTER((int)fs->fstype));

        if (NULL == action) {
                g_warning("%s received FrameSet of unrecognized type %u", __FUNCTION__, fs->fstype);
                goto returnout;
        }
        action(aself, fs, addr);
        


returnout:
        if (aself->autoack) {
                DUMP3("_authlistener_got_frameset: AutoACKing FrameSet", &fs->baseclass, NULL);
                self->transport->_netio->ackmessage(self->transport->_netio, addr, fs);
        }
        UNREF(fs);
        return TRUE;
}
FSTATIC void
_authlistener_associate(Listener* lself, NetGSource* transport)
{
        AuthListener*   self = CASTTOCLASS(AuthListener, lself);
        GHashTableIter  iter;
        gpointer        key;
        gpointer        value;
        if (lself->transport) {
                lself->dissociate(lself);
        }
        g_hash_table_iter_init(&iter, self->actionmap);
        while (g_hash_table_iter_next(&iter, &key, &value)) {
                guint16 fstype = GPOINTER_TO_INT(key);
                transport->addListener(transport, fstype, lself);
        }
        lself->transport = transport;
}
FSTATIC void
_authlistener_dissociate(Listener* lself)
{
        AuthListener*   self = CASTTOCLASS(AuthListener, lself);
        GHashTableIter  iter;
        gpointer        key;
        gpointer        value;
        if (!lself->transport) {
                return;
        }
        g_hash_table_iter_init(&iter, self->actionmap);
        while (g_hash_table_iter_next(&iter, &key, &value)) {
                guint16 fstype = GPOINTER_TO_INT(key);
                lself->transport->addListener(lself->transport, fstype, NULL);
        }
        lself->transport = NULL;
}

FSTATIC void
_authlistener_finalize(AssimObj * aself) 
{
        AuthListener*           self = CASTTOCLASS(AuthListener, aself);
        self->baseclass.dissociate(&self->baseclass);
        if (self->actionmap) {
                g_hash_table_destroy(self->actionmap);
                self->actionmap = NULL;
        }
        _listener_finalize(aself);
}


AuthListener*
authlistener_new(gsize objsize,          
                 ObeyFrameSetTypeMap*map,
                 ConfigContext* config,  
                 gboolean autoack)       
{
        AuthListener * newlistener;
        BINDDEBUG(AuthListener);
        if (objsize < sizeof(AuthListener)) {
                objsize = sizeof(AuthListener);
        }
        newlistener = NEWSUBCLASS(AuthListener, listener_new(config, objsize));
        if (newlistener != NULL) {
                GHashTable* hash;
                newlistener->baseclass.baseclass._finalize = _authlistener_finalize;
                newlistener->baseclass.got_frameset = _authlistener_got_frameset;
                newlistener->baseclass.associate = _authlistener_associate;
                newlistener->baseclass.dissociate = _authlistener_dissociate;
                hash = g_hash_table_new(NULL, NULL);
                for (; map->action; ++map) {
                        g_hash_table_insert(hash, GINT_TO_POINTER(map->framesettype), map->action);
                }
                newlistener->actionmap = hash;
                newlistener->autoack = autoack;
                
                
        }
        return newlistener;
}