/Users/yzchen/ns/ns-allinone-2.33/ns-2.33/um-olsr-0.8.8/backup/OLSR_pkt.h

/***************************************************************************
 *   Copyright (C) 2004 by Francisco J. Ros                                *
 *   fjrm@dif.um.es                                                        *
 *                                                                         *
 *   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 __OLSR_pkt_h__
#define __OLSR_pkt_h__

#include <packet.h>

/********** Message types **********/

#define OLSR_HELLO_MSG          1

#define OLSR_TC_MSG             2

#define OLSR_MID_MSG            3

/********** Packets stuff **********/

#define PKT_OLSR(p)             OLSR_pkt::access(p)

#ifdef OLSR_IPv6
#define ADDR_SIZE       16
#else
#define ADDR_SIZE       4
#endif

#define OLSR_MAX_MSGS           4

#define OLSR_MAX_HELLOS         12

#define OLSR_MAX_ADDRS          64

#define OLSR_PKT_HDR_SIZE       4

#define OLSR_MSG_HDR_SIZE       12

#define OLSR_HELLO_HDR_SIZE     4

#define OLSR_HELLO_MSG_HDR_SIZE 4

#define OLSR_TC_HDR_SIZE        4

typedef struct OLSR_hello_msg {

        u_int8_t        link_code_;
        u_int8_t        reserved_;
        u_int16_t       link_msg_size_;
        nsaddr_t        nb_iface_addrs_[OLSR_MAX_ADDRS];
        int             count;
        
        inline u_int8_t&        link_code()             { return link_code_; }
        inline u_int8_t&        reserved()              { return reserved_; }
        inline u_int16_t&       link_msg_size()         { return link_msg_size_; }
        inline nsaddr_t&        nb_iface_addr(int i)    { return nb_iface_addrs_[i]; }
        
        inline u_int32_t size() { return OLSR_HELLO_MSG_HDR_SIZE + count*ADDR_SIZE; }

} OLSR_hello_msg;

typedef struct OLSR_hello {

        u_int16_t       reserved_;
        u_int8_t        htime_;
        u_int8_t        willingness_;
        OLSR_hello_msg  hello_body_[OLSR_MAX_HELLOS];
        int             count;
        
        inline u_int16_t&       reserved()              { return reserved_; }
        inline u_int8_t&        htime()                 { return htime_; }
        inline u_int8_t&        willingness()           { return willingness_; }
        inline OLSR_hello_msg&  hello_msg(int i)        { return hello_body_[i]; }
        
        inline u_int32_t size() {
                u_int32_t sz = OLSR_HELLO_HDR_SIZE;
                for (int i = 0; i < count; i++)
                        sz += hello_msg(i).size();
                return sz;
        }
        
} OLSR_hello;

typedef struct OLSR_tc {

        u_int16_t       ansn_;
        u_int16_t       reserved_;
        nsaddr_t        nb_main_addrs_[OLSR_MAX_ADDRS];
        int             count;
        
        inline  u_int16_t&      ansn()                  { return ansn_; }
        inline  u_int16_t&      reserved()              { return reserved_; }
        inline  nsaddr_t&       nb_main_addr(int i)     { return nb_main_addrs_[i]; }
        
        inline  u_int32_t size() { return OLSR_TC_HDR_SIZE + count*ADDR_SIZE; }

} OLSR_tc;

typedef struct OLSR_mid {

        nsaddr_t        iface_addrs_[OLSR_MAX_ADDRS];
        int             count;
        
        inline nsaddr_t&        iface_addr(int i)       { return iface_addrs_[i]; }
        
        inline u_int32_t        size()                  { return count*ADDR_SIZE; }
        
} OLSR_mid;

typedef struct OLSR_msg {

        u_int8_t        msg_type_;      
        u_int8_t        vtime_;         
        u_int16_t       msg_size_;      
        nsaddr_t        orig_addr_;     
        u_int8_t        ttl_;           
        u_int8_t        hop_count_;     
        u_int16_t       msg_seq_num_;   
        union {
                OLSR_hello      hello_;
                OLSR_tc         tc_;
                OLSR_mid        mid_;
        } msg_body_;                    
        
        inline  u_int8_t&       msg_type()      { return msg_type_; }
        inline  u_int8_t&       vtime()         { return vtime_; }
        inline  u_int16_t&      msg_size()      { return msg_size_; }
        inline  nsaddr_t&       orig_addr()     { return orig_addr_; }
        inline  u_int8_t&       ttl()           { return ttl_; }
        inline  u_int8_t&       hop_count()     { return hop_count_; }
        inline  u_int16_t&      msg_seq_num()   { return msg_seq_num_; }
        inline  OLSR_hello&     hello()         { return msg_body_.hello_; }
        inline  OLSR_tc&        tc()            { return msg_body_.tc_; }
        inline  OLSR_mid&       mid()           { return msg_body_.mid_; }
        
        inline u_int32_t size() {
                u_int32_t sz = OLSR_MSG_HDR_SIZE;
                if (msg_type() == OLSR_HELLO_MSG)
                        sz += hello().size();
                else if (msg_type() == OLSR_TC_MSG)
                        sz += tc().size();
                else if (msg_type() == OLSR_MID_MSG)
                        sz += mid().size();
                return sz;
        }

} OLSR_msg;

typedef struct OLSR_pkt {

        u_int16_t       pkt_len_;                       
        u_int16_t       pkt_seq_num_;                   
        OLSR_msg        pkt_body_[OLSR_MAX_MSGS];       
        int             count;                          
        
        inline  u_int16_t&      pkt_len()       { return pkt_len_; }
        inline  u_int16_t&      pkt_seq_num()   { return pkt_seq_num_; }
        inline  OLSR_msg&       msg(int i)      { return pkt_body_[i]; }
        
        static int offset_;
        inline static int& offset() { return offset_; }
        inline static struct OLSR_pkt* access(const Packet* p) {
                return (struct OLSR_pkt*)p->access(offset_);
        }

} OLSR_pkt;

#endif