selector.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net


#ifndef __LIBXORP_SELECTOR_HH__
#define __LIBXORP_SELECTOR_HH__

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include "libxorp/xorp.h"

#ifndef USE_WIN_DISPATCHER

#include "callback.hh"
#include "ioevents.hh"
#include "task.hh"

class ClockBase;
class SelectorList;
class TimeVal;


enum SelectorMask {
    SEL_NONE    = 0x0,              // No events
    SEL_RD  = 0x01,             // Read events
    SEL_WR  = 0x02,             // Write events
    SEL_EX  = 0x04,             // Exception events
    SEL_ALL = SEL_RD | SEL_WR | SEL_EX  // All events
};

class SelectorTag;

typedef ref_ptr<SelectorTag> Selector;

class SelectorListObserverBase {
public:
    virtual ~SelectorListObserverBase();

private:
    virtual void notify_added(XorpFd fd, const SelectorMask& mask) = 0;

    virtual void notify_removed(XorpFd fd, const SelectorMask& mask) = 0;

    SelectorList * _observed;

    friend class SelectorList;
};

class SelectorList :
    public NONCOPYABLE
{
public:

    SelectorList(ClockBase* clock);

    virtual ~SelectorList();

    void set_debug(bool v) { _is_debug = v;}
    bool is_debug() const { return (_is_debug); }

     bool add_ioevent_cb(XorpFd     fd, 
             IoEventType    type, 
             const IoEventCb& cb,
             int        priority = XorpTask::PRIORITY_DEFAULT);

    void remove_ioevent_cb(XorpFd fd, IoEventType type = IOT_ANY);

    bool ready();

    int get_ready_priority(bool force);

    int wait_and_dispatch(TimeVal& timeout);

    int wait_and_dispatch(int millisecs);

    size_t descriptor_count() const { return _descriptor_count; }

     void get_fd_set(SelectorMask selected_mask, fd_set& fds) const;

     int get_max_fd() const;

     void set_observer(SelectorListObserverBase& obs);

     void remove_observer();


protected:
    void callback_bad_descriptors();

private:
    int do_select(struct timeval* to, bool force);

private:
    enum {
    // correspond to SelectorMask; correspondence checked with
    // x_static_assert
    SEL_RD_IDX  = 0,
    SEL_WR_IDX  = 1,
    SEL_EX_IDX  = 2,
    SEL_MAX_IDX = 3
    };

    #define GOOD_NODE_MAGIC 0x12345678
    struct Node {
    int magic; // catch memory errors.
    int     _mask[SEL_MAX_IDX];
    IoEventCb   _cb[SEL_MAX_IDX];
    // Reverse mapping of legacy UNIX event to IoEvent
    IoEventType _iot[SEL_MAX_IDX];
    int     _priority[SEL_MAX_IDX];

    Node();
    ~Node();
    Node(const Node& rhs); // copy constructor
    Node& operator=(const Node& rhs); // operator= overload

    bool        add_okay(SelectorMask m, IoEventType type,
                 const IoEventCb& cb, int priority);
    int     run_hooks(SelectorMask m, XorpFd fd);
    void        clear(SelectorMask m);
    bool        is_empty();
    };

    ClockBase*      _clock;
    SelectorListObserverBase * _observer;
    fd_set      _fds[SEL_MAX_IDX];
    fd_set      _testfds[SEL_MAX_IDX];
    int         _testfds_n;
    int         _maxpri_fd;
    int         _maxpri_sel;
    int         _last_served_fd;
    int         _last_served_sel;

    vector<Node>    _selector_entries;
    int         _maxfd;
    size_t      _descriptor_count;
    bool        _is_debug;
};
#endif // USE_WIN_DISPATCHER
#endif // __LIBXORP_SELECTOR_HH__