realtimescheduler.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// 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.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef __REALTIMESCHEDULER_H__
#define __REALTIMESCHEDULER_H__

#define WANT_WINSOCK2
#include <platdep/sockets.h>
#include <omnetpp.h>
#include <list>
#include <climits>


class PacketBufferEntry {
public:
    char* data;
    int32_t length;
    sockaddr* addr;
    socklen_t addrlen;
    enum fdCommand {
        PACKET_DATA = 0,
        PACKET_FD_NEW = 1,
        PACKET_FD_CLOSE = 2,
        PACKET_APPTUN_DATA = 3
    } func;
    SOCKET fd;
    PacketBufferEntry(char* buf, int32_t len) :
        data(buf), length(len), addr(0), addrlen(0), func(PACKET_DATA), fd(0) {};
    PacketBufferEntry(char* buf, int32_t len, sockaddr* ad, socklen_t al) :
        data(buf), length(len), addr(ad), addrlen(al), func(PACKET_DATA), fd(0) {};
    PacketBufferEntry(char* buf, int32_t len, fdCommand fc, int _fd) :
        data(buf), length(len), addr(0), addrlen(0), func(fc), fd(_fd) {};
    PacketBufferEntry(char* buf, int32_t len, sockaddr* ad, socklen_t al,
                      fdCommand fc, int _fd) :
                          data(buf), length(len), addr(ad), addrlen(al), func(fc), fd(_fd) {};
};

typedef std::list<PacketBufferEntry> PacketBuffer;

class RealtimeScheduler : public cScheduler
{


protected:
    class SocketContext {
    public:
        SocketContext() {};
        SocketContext(cModule* mod, cMessage* notifMsg, PacketBuffer* buffer,
                      size_t mtu) : mod(mod), notifMsg(notifMsg), buffer(buffer),
                      mtu(mtu) {};

        cModule* mod;
        cMessage* notifMsg;
        PacketBuffer* buffer;
        size_t mtu;
    };

    std::map<SOCKET, SocketContext> socketContextMap;

    // FD set with all file descriptors
    fd_set all_fds;
    SOCKET maxfd;

    // Buffer, module and FD for network communication
    SOCKET netw_fd;
    SOCKET apptun_fd;
    cModule *module;
    cMessage *notificationMsg;
    PacketBuffer *packetBuffer;
    size_t buffersize;

    // ... for realworldapp communication
    cModule *appModule;
    cMessage *appNotificationMsg;
    PacketBuffer *appPacketBuffer;
    size_t appBuffersize;
    int appConnectionLimit;

    SOCKET additional_fd; // Can be used by concrete implementations of this class

    // state
    timeval baseTime;

    virtual int initializeNetwork() = 0;

    virtual void additionalFD() {};

    virtual bool receiveWithTimeout(long usec);

    virtual int receiveUntil(const timeval& targetTime);

public:
    RealtimeScheduler();

    virtual ~RealtimeScheduler();

    virtual void startRun();

    virtual void endRun();

    virtual void executionResumed();

    virtual void setInterfaceModule(cModule *module,
                                    cMessage *notificationMsg,
                                    PacketBuffer* buffer,
                                    int mtu,
                                    bool isApp = false);

    void registerSocket(SOCKET fd, cModule *mod, cMessage *notifMsg,
                        PacketBuffer* buffer, int mtu);


    virtual cMessage *getNextEvent();

    void sendNotificationMsg(cMessage* msg, cModule* mod);

    virtual ssize_t sendBytes(const char *buf,
                              size_t numBytes,
                              sockaddr* addr = 0,
                              socklen_t addrlen = 0,
                              bool isApp = false,
                              SOCKET fd = INVALID_SOCKET);

    void closeAppSocket(SOCKET fd);

    virtual SOCKET getAppTunFd() { return apptun_fd; };

};

#endif