uwApplication_module.h

Go to the documentation of this file.

//
// Copyright (c) 2017 Regents of the SIGNET lab, University of Padova.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the University of Padova (SIGNET lab) nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
 
#ifndef UWAPPLICATION_MODULE_H
#define UWAPPLICATION_MODULE_H
 
#include <uwip-module.h>
#include <uwudp-module.h>
 
#include <module.h>
#include <iostream>
#include <sstream>
#include <climits>
#include <time.h>
#include <math.h>
#include <assert.h>
#include <errno.h>
#include <stddef.h>
 
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#include <signal.h>
 
#include <unistd.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
 
#include <arpa/inet.h>
#include <deque>
#include <list>
#include <queue>
#include <rng.h>
#include <fstream>
#include <ostream>
#include <chrono>
 
#define UWAPPLICATION_DROP_REASON_UNKNOWN_TYPE \
    "DPUT" 
#define UWAPPLICATION_DROP_REASON_DUPLICATED_PACKET \
    "DPD" 
#define UWAPPLICATION_DROP_REASON_OUT_OF_SEQUENCE \
    "DOOS" 
extern packet_t
        PT_DATA_APPLICATION; 
class uwApplicationModule : public Module
{
    // friend class uwSendTimerAppl;
public:
    uwApplicationModule();
    virtual ~uwApplicationModule();
    virtual int command(int argc, const char *const *argv);
 
    virtual int crLayCommand(ClMessage *m);
 
    virtual void handleTCPclient(int clnSock);
 
    // virtual void handleUDPclient(int clnSock);
 
    virtual void
    incrPktsPushQueue()
    {
        pkts_push_queue++;
    }
 
    inline unsigned long int
    getEpoch()
    {
      unsigned long int timestamp =
          (unsigned long int) (std::chrono::duration_cast<std::chrono::milliseconds>(
              std::chrono::system_clock::now().time_since_epoch()).count() );
      return timestamp;
    }
 
    int servSockDescr; 
    int clnSockDescr; 
    struct sockaddr_in servAddr; 
    struct sockaddr_in clnAddr; 
    int servPort; 
    std::queue<Packet *>
            queuePckReadTCP; 
    std::queue<Packet *>
            queuePckReadUDP; 
    std::ofstream out_log; 
    bool logging;
    int node_id;
    int exp_id;
 
    static uint MAX_READ_LEN;
 
protected:
    class uwSendTimerAppl : public TimerHandler
    {
    public:
        uwSendTimerAppl(uwApplicationModule *m)
            : TimerHandler()
        {
            m_ = m;
        }
 
        virtual ~uwSendTimerAppl()
        {
        }
 
    protected:
        virtual void expire(Event *e);
        uwApplicationModule *m_;
    }; // End uwSendTimer class
 
    /**************************************************************************
     *                          METHODS                                       *
     **************************************************************************/
    virtual void recv(Packet *);
    virtual void statistics(Packet *p);
    // virtual void start_generation_pck_wth_socket();
    virtual void start_generation();
    // virtual void initialize_DATA_pck_wth_socket();
    virtual void init_Packet();
    virtual int openConnectionTCP();
    // virtual void initialize_DATA_pck_wth_TCP();
    virtual void init_Packet_TCP();
    virtual int openConnectionUDP();
    // virtual void initialize_DATA_pck_wth_UDP();
    virtual void init_Packet_UDP();
    virtual void stop();
    // virtual bool withoutSocket() {bool test;SOCKET_CMN == 0 ? test = true :
    // test = false; return test;}
    // virtual bool withoutSocket() {bool test; socket_active == false ? test =
    // true : test = false; return test;}
    virtual bool
    withoutSocket()
    {
        bool test;
        socket_active == false ? test = true : test = false;
        return test;
    }
    // virtual bool useTCP() {bool test;TCP_CMN == 1 ? test = true : test =
    // false; return test;}
    virtual bool
    useTCP()
    {
        bool test;
        tcp_udp == 1 ? test = true : test = false;
        return test;
    }
    virtual inline bool
    usePoissonTraffic()
    {
        bool test;
        poisson_traffic == 1 ? test = true : test = false;
        return test;
    }
    virtual inline bool
    useDropOutOfOrder()
    {
        bool test;
        drop_out_of_order == 1 ? test = true : test = false;
        return test;
    }
 
    /**************************************************************************
     *                       METHODS GET and SET                              *
     **************************************************************************/
    virtual inline void
    incrPktSent()
    {
        txsn++;
    }
    virtual inline void
    incrPktLost(const int &npkts)
    {
        pkts_lost += npkts;
    }
    virtual inline void
    incrPktRecv()
    {
        pkts_recv++;
    }
    virtual inline void
    incrPktOoseq()
    {
        pkts_ooseq++;
    }
    virtual inline void
    incrPktInvalid()
    {
        pkts_invalid++;
    }
    virtual inline int
    getPktSent()
    {
        return txsn - 1;
    }
    virtual inline int
    getPktLost()
    {
        return pkts_lost;
    }
    virtual inline int
    getPktRecv()
    {
        return pkts_recv;
    }
    virtual inline int
    getPktsOOSequence()
    {
        return pkts_ooseq;
    }
    virtual inline int
    getPktsInvalidRx()
    {
        return pkts_invalid;
    }
    virtual inline int
    getPktsPushQueue()
    {
        return pkts_push_queue;
    }
    virtual inline double
    getPeriod()
    {
        return PERIOD;
    }
    virtual inline int
    getpayloadsize()
    {
        return payloadsize;
    }
 
    virtual double getTimeBeforeNextPkt();
    virtual double GetRTT() const;
    virtual double GetRTTstd() const;
    virtual void updateRTT(const double &rtt);
    virtual double GetFTT() const;
    virtual double GetFTTstd() const;
    virtual double GetPER() const;
    virtual double GetTHR() const;
    virtual void updateFTT(const double &ftt);
    virtual void updateThroughput(const int &bytes, const double &dt);
 
    /**************************************************************************
     *                          VARIABLES                                     *
     **************************************************************************/
    // TCL VARIABLES
    int debug_; 
    double PERIOD; 
    // int SOCKET_CMN; /**< Enable or not the communication with socket <i>1</i>
    // enabled <i>0</i> not enabled*/
    int poisson_traffic; 
    int payloadsize; 
    int port_num; 
    int drop_out_of_order; 
    // int TCP_CMN; /**< Enable or not the use of TCP protocol when is used the
    // socket communication <i>1</i> use TCP <i>0</i> use UDP*/
    uint8_t dst_addr; 
    // TIMER VARIABLES
    uwSendTimerAppl
            chkTimerPeriod; 
    // STATISTICAL VARIABLES
    bool socket_active;
    string socket_protocol;
    int tcp_udp; // 1 for tcp, 0 for udp, -1 for none
    bool *sn_check; 
    int uidcnt; 
    int txsn; 
    int rftt; 
    int pkts_lost; 
    int pkts_recv; 
    int pkts_ooseq; 
    int pkts_invalid; 
    int pkts_push_queue; 
    int pkts_last_reset; 
    double lrtime; 
    double sumrtt; 
    double sumrtt2; 
    int rttsamples; 
    double sumftt; 
    double sumftt2; 
    int fttsamples; 
    uint32_t esn; 
    double sumbytes; 
    double sumdt; 
    int hrsn; 
}; // end uwApplication_module class
#endif /* UWAPPLICATION_MODULE_H */
extern "C" {
void *read_process_TCP(void *arg);
}
 
extern "C" {
void *read_process_UDP(void *arg);
}