/*
 * Copyright 2008-2013, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */

/*! Provides the networking stack notification service. */

#include <net_notifications.h>

#include <kernel.h>
#include <generic_syscall.h>
#include <Notifications.h>
#include <util/KMessage.h>

//#define TRACE_NOTIFICATIONS
#ifdef TRACE_NOTIFICATIONS
#       define TRACE(x...) dprintf("\33[32mnet_notifications:\33[0m " x)
#else
#       define TRACE(x...) ;
#endif


class NetNotificationService : public DefaultUserNotificationService {
public:
                                                                NetNotificationService();
        virtual                                         ~NetNotificationService();

                        void                            Notify(const KMessage& event);

protected:
        virtual void                            LastReferenceReleased();
        virtual void                            FirstAdded();
        virtual void                            LastRemoved();
};


static NetNotificationService sNotificationService;


//      #pragma mark - NetNotificationService


NetNotificationService::NetNotificationService()
        :
        DefaultUserNotificationService("network")
{
}


NetNotificationService::~NetNotificationService()
{
}


void
NetNotificationService::Notify(const KMessage& event)
{
        uint32 opcode = event.GetInt32("opcode", 0);
        if (opcode == 0)
                return;

        TRACE("notify for %lx\n", opcode);

        DefaultUserNotificationService::Notify(event, opcode);
}


void
NetNotificationService::LastReferenceReleased()
{
        // don't delete us here
}


void
NetNotificationService::FirstAdded()
{
        // The reference counting doesn't work for us, as we'll have to
        // ensure our module stays loaded.
        module_info* dummy;
        get_module(NET_NOTIFICATIONS_MODULE_NAME, &dummy);
}


void
NetNotificationService::LastRemoved()
{
        // Give up the reference _AddListener()
        put_module(NET_NOTIFICATIONS_MODULE_NAME);
}


//      #pragma mark - User generic syscall


static status_t
net_notifications_control(const char *subsystem, uint32 function, void *buffer,
        size_t bufferSize)
{
        struct net_notifications_control control;
        if (bufferSize != sizeof(struct net_notifications_control)
                || function != NET_NOTIFICATIONS_CONTROL_WATCHING)
                return B_BAD_VALUE;
        if (!IS_USER_ADDRESS(buffer) || user_memcpy(&control, buffer,
                        sizeof(struct net_notifications_control)) < B_OK)
                return B_BAD_ADDRESS;

        if (control.flags != 0) {
                return sNotificationService.UpdateUserListener(control.flags,
                        control.port, control.token);
        }

        return sNotificationService.RemoveUserListeners(control.port,
                control.token);
}


//      #pragma mark - exported module API


static status_t
send_notification(const KMessage* event)
{
        sNotificationService.Notify(*event);
        return B_OK;
}


static status_t
notifications_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                {
                        TRACE("init\n");

                        new(&sNotificationService) NetNotificationService();
                        status_t result = sNotificationService.Register();
                        if (result != B_OK)
                                return result;

                        register_generic_syscall(NET_NOTIFICATIONS_SYSCALLS,
                                net_notifications_control, 1, 0);
                        return B_OK;
                }
                case B_MODULE_UNINIT:
                        TRACE("uninit\n");

                        unregister_generic_syscall(NET_NOTIFICATIONS_SYSCALLS, 1);

                        // TODO: due to the way the locking in the notification
                        // manager works, there's a potential race condition here
                        // where someone attempts to add a listener right as
                        // we're uninitializing. Needs to be looked at/resolved.
                        sNotificationService.Unregister();

                        // we need to release the reference that was acquired
                        // on our behalf by the NotificationManager.
                        sNotificationService.ReleaseReference();
                        sNotificationService.~NetNotificationService();
                        return B_OK;

                default:
                        return B_ERROR;
        }
}


net_notifications_module_info sNotificationsModule = {
        {
                NET_NOTIFICATIONS_MODULE_NAME,
                0,
                notifications_std_ops
        },

        send_notification
};

module_info* modules[] = {
        (module_info*)&sNotificationsModule,
        NULL
};