uwpolling_cmn_hdr.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 UWPOLLING_CMN_HDR_H
#define UWPOLLING_CMN_HDR_H
 
#include <mmac.h>
#include <module.h>
#include <packet.h>
 
#include <list>
 
#define HDR_PROBE(p) \
    (hdr_PROBE::access(p)) 
#define HDR_TRIGGER(p)                                                       \
    (hdr_TRIGGER::access(p)) 
#define HDR_POLL(p) \
    (hdr_POLL::access(p)) 
#define HDR_AUV_MULE(p)    \
    (hdr_AUV_MULE::access( \
            p)) 
#define HDR_ACK_SINK(p)                                                 \
    (hdr_ACK_SINK::access(p)) 
#define HDR_PROBE_SINK(p)    \
    (hdr_PROBE_SINK::access( \
            p)) 
extern packet_t PT_TRIGGER;
extern packet_t PT_POLL;
extern packet_t PT_PROBE;
extern packet_t PT_PROBE_SINK;
extern packet_t PT_AUV_MULE;
extern packet_t PT_ACK_SINK;
 
static const int MAX_POLLED_NODE = 4000; 
static const double MIN_T_POLL = 5; 
static const double MIN_T_DATA = 5; 
static const int MAX_BUFFER_SIZE =
        100; 
static const int prop_speed =
        1500; 
typedef struct POLL_ID {
    int id_; 
    double t_wait_; 
} id_poll;
 
typedef struct hdr_TRIGGER {
    uint16_t t_in_; 
    uint16_t t_fin_; 
    uint TRIGGER_uid_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    uint16_t &
    t_in()
    {
        return (t_in_);
    }
 
    uint16_t &
    t_fin()
    {
        return (t_fin_);
    }
    uint &
    TRIGGER_uid()
    {
        return (TRIGGER_uid_);
    }
 
    inline static struct hdr_TRIGGER *
    access(const Packet *p)
    {
        return (struct hdr_TRIGGER *) p->access(offset_);
    }
} hdr_TRIGGER;
 
typedef struct hdr_POLL {
    int id_; 
    uint POLL_uid_; 
    uint16_t POLL_time_; 
    static int offset_; 
    int &
    ID()
    {
        return (id_);
    }
 
    uint &
    POLL_uid()
    {
        return (POLL_uid_);
    }
 
    uint16_t &
    POLL_time()
    {
        return (POLL_time_);
    }
 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    inline static struct hdr_POLL *
    access(const Packet *p)
    {
        return (struct hdr_POLL *) p->access(offset_);
    }
} hdr_POLL;
 
typedef struct hdr_PROBE {
    // uint16_t backoff_time_; /**< Backoff time chosen by the node */
    uint16_t ts_; 
    int n_pkts_; 
    uint id_node_; 
    uint PROBE_uid_; 
    static int offset_; 
    uint16_t &
    ts()
    {
        return (ts_);
    }
 
    /*  uint16_t &
        backoff_time()
        {
            return (backoff_time_);
        }*/
 
    int &
    n_pkts()
    {
        return (n_pkts_);
    }
 
    uint &
    id_node()
    {
        return (id_node_);
    }
 
    uint &
    PROBE_uid()
    {
        return (PROBE_uid_);
    }
 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    inline static struct hdr_PROBE *
    access(const Packet *p)
    {
        return (struct hdr_PROBE *) p->access(offset_);
    }
} hdr_PROBE;
 
typedef struct hdr_PROBE_SINK {
    uint id_sink_; 
    uint PROBE_uid_; 
    uint16_t id_ack_; 
    static int offset_; 
    uint &
    id_sink()
    {
        return (id_sink_);
    }
 
    uint &
    PROBE_uid()
    {
        return (PROBE_uid_);
    }
 
    uint16_t &
    id_ack()
    {
        return (id_ack_);
    }
 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    inline static struct hdr_PROBE_SINK *
    access(const Packet *p)
    {
        return (struct hdr_PROBE_SINK *) p->access(offset_);
    }
} hdr_PROBE_SINK;
 
typedef struct hdr_AUV_MULE {
    uint16_t
            pkt_uid_; 
    uint16_t last_pkt_uid_; 
    static int offset_; 
    uint16_t &
    pkt_uid()
    {
        return (pkt_uid_);
    }
 
    uint16_t &
    last_pkt_uid()
    {
        return (last_pkt_uid_);
    }
 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    inline static struct hdr_AUV_MULE *
    access(const Packet *p)
    {
        return (struct hdr_AUV_MULE *) p->access(offset_);
    }
} hdr_AUV_MULE;
 
typedef struct hdr_ACK_SINK {
    std::vector<uint16_t> id_ack_; 
    static int offset_; 
    std::vector<uint16_t> &
    id_ack()
    {
        return (id_ack_);
    }
 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    inline static struct hdr_ACK_SINK *
    access(const Packet *p)
    {
        return (struct hdr_ACK_SINK *) p->access(offset_);
    }
} hdr_ACK_SINK;
 
#endif