uwUFetch_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 UWUFETCH_CMN_HDR_H
#define UWUFETCH_CMN_HDR_H
 
#include <mmac.h>
#include <module.h>
#include <packet.h>
 
#define HDR_TRIGGER_UFETCH(p)    \
    (hdr_TRIGGER_UFETCH::access( \
            p)) 
#define HDR_RTS_UFETCH(p) \
    (hdr_RTS_UFETCH::access(p)) 
#define HDR_CTS_UFETCH(p) \
    (hdr_CTS_UFETCH::access(p)) 
#define HDR_BEACON_UFETCH(p)    \
    (hdr_BEACON_UFETCH::access( \
            p)) 
#define HDR_PROBE_UFETCH(p)    \
    (hdr_PROBE_UFETCH::access( \
            p)) 
#define HDR_POLL_UFETCH(p)                                             \
    (hdr_POLL_UFETCH::access(p)) 
#define HDR_CBEACON_UFETCH(p)    \
    (hdr_CBEACON_UFETCH::access( \
            p)) 
extern packet_t PT_BEACON_UFETCH; 
extern packet_t PT_POLL_UFETCH; 
extern packet_t PT_CBEACON_UFETCH; 
extern packet_t PT_RTS_UFETCH; 
extern packet_t PT_PROBE_UFETCH; 
extern packet_t PT_TRIGGER_UFETCH; 
extern packet_t PT_CTS_UFETCH; 
static const int v_speed_sound =
        1500; 
static const int BIT_RATE_SERVICE = 1000;
static const int BIT_RATE_INSTANT = 10000;
 
typedef struct hdr_TRIGGER_UFETCH {
    int t_min_; 
    int t_max_; 
    int
            max_pck_want_rx_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    t_min()
    {
        return (t_min_);
    }
 
    int &
    t_max()
    {
        return (t_max_);
    }
 
    int &
    max_pck_want_rx()
    {
        return (max_pck_want_rx_);
    }
 
    inline static hdr_TRIGGER_UFETCH *
    access(const Packet *p)
    {
        return (hdr_TRIGGER_UFETCH *) p->access(offset_);
    }
} hdr_TRIGGER_UFETCH;
 
typedef struct hdr_RTS_UFETCH {
    int num_DATA_pcks_; 
    int
            backoff_time_RTS_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    num_DATA_pcks()
    {
        return num_DATA_pcks_;
    }
 
    int &
    backoff_time_RTS()
    {
        return backoff_time_RTS_;
    }
 
    inline static hdr_RTS_UFETCH *
    access(const Packet *p)
    {
        return (hdr_RTS_UFETCH *) p->access(offset_);
    }
} hdr_RTS_UFETCH;
 
typedef struct hdr_CTS_UFETCH {
    int num_DATA_pcks_MAX_rx_; 
    int mac_addr_HN_ctsed_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    num_DATA_pcks_MAX_rx()
    {
        return num_DATA_pcks_MAX_rx_;
    }
 
    int &
    mac_addr_HN_ctsed()
    {
        return mac_addr_HN_ctsed_;
    }
 
    inline static hdr_CTS_UFETCH *
    access(const Packet *p)
    {
        return (hdr_CTS_UFETCH *) p->access(offset_);
    }
} hdr_CTS_UFETCH;
 
typedef struct hdr_BEACON_UFETCH {
    int t_min_bc_; 
    int t_max_bc_; 
    int num_Max_CBEACON_tx_by_HN_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    t_min_bc()
    {
        return t_min_bc_;
    }
 
    int &
    t_max_bc()
    {
        return t_max_bc_;
    }
 
    int &
    num_Max_CBEACON_tx_by_HN()
    {
        return num_Max_CBEACON_tx_by_HN_;
    }
 
    inline static hdr_BEACON_UFETCH *
    access(const Packet *p)
    {
        return (hdr_BEACON_UFETCH *) p->access(offset_);
    }
} hdr_BEACON_UFETCH;
 
typedef struct hdr_PROBE_UFETCH {
    int
            n_DATA_pcks_Node_tx_; 
    int
            backoff_time_PROBE_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    n_DATA_pcks_Node_tx()
    {
        return n_DATA_pcks_Node_tx_;
    }
 
    int &
    backoff_time_PROBE()
    {
        return backoff_time_PROBE_;
    }
 
    inline static hdr_PROBE_UFETCH *
    access(const Packet *p)
    {
        return (hdr_PROBE_UFETCH *) p->access(offset_);
    }
} hdr_PROBE_UFETCH;
 
typedef struct hdr_POLL_UFETCH {
    int num_DATA_pcks_MAX_rx_; 
    int mac_addr_Node_polled_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    num_DATA_pcks_MAX_rx()
    {
        return num_DATA_pcks_MAX_rx_;
    }
 
    int &
    mac_addr_Node_polled()
    {
        return mac_addr_Node_polled_;
    };
 
    inline static struct hdr_POLL_UFETCH *
    access(const Packet *p)
    {
        return (struct hdr_POLL_UFETCH *) p->access(offset_);
    }
} hdr_POLL_UFETCH;
 
typedef struct hdr_CBEACON_UFETCH {
    int t_min_bc_; 
    int t_max_bc_; 
    int num_Max_CBEACON_tx_by_HN_; 
    static int offset_; 
    inline static int &
    offset()
    {
        return offset_;
    }
 
    int &
    t_min_bc()
    {
        return t_min_bc_;
    }
 
    int &
    t_max_bc()
    {
        return t_max_bc_;
    }
 
    int &
    num_Max_CBEACON_tx_by_HN()
    {
        return num_Max_CBEACON_tx_by_HN_;
    }
 
    inline static hdr_CBEACON_UFETCH *
    access(const Packet *p)
    {
        return (hdr_CBEACON_UFETCH *) p->access(offset_);
    }
} hdr_CBEACON_UFETCH;
#endif