hbsender.c

Go to the documentation of this file.

#include <memory.h>
#include <glib.h>
#include <frameset.h>
#include <frame.h>
#include <hbsender.h>
FSTATIC void _hbsender_notify_function(gpointer data);
FSTATIC void _hbsender_finalize(HbSender * self);
FSTATIC void _hbsender_ref(HbSender * self);
FSTATIC void _hbsender_unref(HbSender * self);
FSTATIC void _hbsender_addlist(HbSender* self);
FSTATIC void _hbsender_dellist(HbSender* self);
FSTATIC void _hbsender_sendheartbeat(HbSender* self);
FSTATIC gboolean _hbsender_gsourcefunc(gpointer);

DEBUGDECLARATIONS


static GSList*  _hb_senders = NULL;
static gint     _hb_sender_count = 0;

#define ONESEC  1000000

FSTATIC void
_hbsender_addlist(HbSender* self)       
{
        _hb_senders = g_slist_prepend(_hb_senders, self);
        _hb_sender_count += 1;
}

FSTATIC void
_hbsender_dellist(HbSender* self)       
{
        if (g_slist_find(_hb_senders, self) != NULL) {
                _hb_senders = g_slist_remove(_hb_senders, self);
                _hb_sender_count -= 1;
                return;
        }
        g_warn_if_reached();
}

FSTATIC gboolean
_hbsender_gsourcefunc(gpointer gself) 
{
        HbSender* self = CASTTOCLASS(HbSender, gself);
        _hbsender_sendheartbeat(self);
        return TRUE;
}


FSTATIC void
_hbsender_ref(HbSender* self)   
{
        self->_refcount += 1;
}

FSTATIC void
_hbsender_unref(HbSender* self) 
{
        g_return_if_fail(self->_refcount > 0);
        self->_refcount -= 1;
        if (self->_refcount == 0) {
                _hbsender_dellist(self);
                self->_finalize(self);
                self = NULL;
        }
}
// Callback function from the GSource world - notifying us when we're getting shut down from their end
FSTATIC void
_hbsender_notify_function(gpointer data)
{
        HbSender* self = CASTTOCLASS(HbSender, data);
        self->timeout_source = 0;
}

FSTATIC void
_hbsender_finalize(HbSender * self) 
{
        if (self->_sendaddr) {
                UNREF(self->_sendaddr);
        }
        if (self->timeout_source != 0) {
                g_source_remove(self->timeout_source);
        }
        memset(self, 0x00, sizeof(*self));
        FREECLASSOBJ(self);
}


HbSender*
hbsender_new(NetAddr* sendaddr,         
             NetGSource* outmethod,     
             guint  interval,           
             gsize objsize)             
{
        HbSender * newsender;
        BINDDEBUG(HbSender);
        if (objsize < sizeof(HbSender)) {
                objsize = sizeof(HbSender);
        }
        newsender = MALLOCCLASS(HbSender, objsize);
        if (newsender != NULL) {
                newsender->_sendaddr = sendaddr;
                REF(sendaddr);
                newsender->_refcount = 1;
                newsender->ref = _hbsender_ref;
                newsender->_outmethod = outmethod;
                newsender->unref = _hbsender_unref;
                newsender->_finalize = _hbsender_finalize;
                newsender->_expected_interval = interval;
                if (interval < 500000) {
                        interval = 1000000;
                }
                newsender->timeout_source = g_timeout_add_seconds_full
                                            (G_PRIORITY_HIGH, (interval/1000000), _hbsender_gsourcefunc
                                        ,    newsender, _hbsender_notify_function);
                DEBUGMSG3("Sender %p timeout source is: %d, interval is %d", newsender
                ,         newsender->timeout_source, interval);
                _hbsender_addlist(newsender);
                // Avoid Martian packets - don't send the first one right away...
                //      _hbsender_sendheartbeat(newsender);
        }
        return newsender;
}


void
hbsender_stopsend(NetAddr* sendaddr)
{
        GSList*         obj;
        for (obj = _hb_senders; obj != NULL; obj=obj->next) {
                HbSender* sender = CASTTOCLASS(HbSender, obj->data);
                if (sendaddr->equal(sendaddr, sender->_sendaddr)) {
                        sender->unref(sender);
                        return;
                }
        }
}
FSTATIC void
_hbsender_sendheartbeat(HbSender* self)
{
        FrameSet*       heartbeat = frameset_new(FRAMESETTYPE_HEARTBEAT);
        //g_debug("Sending a heartbeat...");
        self->_outmethod->sendaframeset(self->_outmethod, self->_sendaddr, heartbeat);
        UNREF(heartbeat);
}
void
hbsender_stopallsenders(void)
{
        while (_hb_senders) {
                HbSender* sender = CASTTOCLASS(HbSender, _hb_senders->data);
                sender->unref(sender);
        }
}