1 files changed, 26 insertions, 88 deletions

diff --git a/src/gnunet/message/msg_transport.go b/src/gnunet/message/msg_transport.go
index fca651f..410e34c 100644
--- a/src/gnunet/message/msg_transport.go
+++ b/src/gnunet/message/msg_transport.go
@@ -37,9 +37,8 @@ import (
 
 // TransportTCPWelcomeMsg is a welcome message for new TCP connections.
 type TransportTCPWelcomeMsg struct {
-        MsgSize uint16       `order:"big"` // total size of message
-        MsgType uint16       `order:"big"` // TRANSPORT_TCP_WELCOME (61)
-        PeerID  *util.PeerID // Peer identity (EdDSA public key)
+        MsgHeader
+        PeerID *util.PeerID // Peer identity (EdDSA public key)
 }
 
 // NewTransportTCPWelcomeMsg creates a new message for a given peer.
@@ -48,9 +47,8 @@ func NewTransportTCPWelcomeMsg(peerid *util.PeerID) *TransportTCPWelcomeMsg {
                 peerid = util.NewPeerID(nil)
         }
         return &TransportTCPWelcomeMsg{
-                MsgSize: 36,
-                MsgType: TRANSPORT_TCP_WELCOME,
-                PeerID:  peerid,
+                MsgHeader: MsgHeader{36, enums.MSG_TRANSPORT_TCP_WELCOME},
+                PeerID:    peerid,
         }
 }
 
@@ -59,11 +57,6 @@ func (m *TransportTCPWelcomeMsg) String() string {
         return fmt.Sprintf("TransportTcpWelcomeMsg{peer=%s}", m.PeerID)
 }
 
-// Header returns the message header in a separate instance.
-func (m *TransportTCPWelcomeMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_PING
 //
@@ -75,8 +68,7 @@ func (m *TransportTCPWelcomeMsg) Header() *Header {
 
 // TransportPingMsg is a PING request message
 type TransportPingMsg struct {
-        MsgSize   uint16       `order:"big"` // total size of message
-        MsgType   uint16       `order:"big"` // TRANSPORT_PING (372)
+        MsgHeader
         Challenge uint32       // Challenge code (to ensure fresh reply)
         Target    *util.PeerID // EdDSA public key (long-term) of target peer
         Address   []byte       `size:"*"` // encoded address
@@ -89,8 +81,7 @@ func NewTransportPingMsg(target *util.PeerID, a *util.Address) *TransportPingMsg
                 target = util.NewPeerID(nil)
         }
         m := &TransportPingMsg{
-                MsgSize:   uint16(40),
-                MsgType:   TRANSPORT_PING,
+                MsgHeader: MsgHeader{40, enums.MSG_TRANSPORT_PING},
                 Challenge: util.RndUInt32(),
                 Target:    target,
                 Address:   nil,
@@ -114,11 +105,6 @@ func (m *TransportPingMsg) String() string {
                 m.Target, a, m.Challenge)
 }
 
-// Header returns the message header in a separate instance.
-func (m *TransportPingMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_PONG
 //
@@ -160,8 +146,7 @@ func NewSignedAddress(a *util.Address) *SignedAddress {
 
 // TransportPongMsg is a response message for a PING request
 type TransportPongMsg struct {
-        MsgSize     uint16         `order:"big"` // total size of message
-        MsgType     uint16         `order:"big"` // TRANSPORT_PING (372)
+        MsgHeader
         Challenge   uint32         // Challenge code (to ensure fresh reply)
         Signature   []byte         `size:"64"` // Signature of address
         SignedBlock *SignedAddress // signed block of data
@@ -171,8 +156,7 @@ type TransportPongMsg struct {
 // peer wants to be reached.
 func NewTransportPongMsg(challenge uint32, a *util.Address) *TransportPongMsg {
         m := &TransportPongMsg{
-                MsgSize:     72,
-                MsgType:     TRANSPORT_PONG,
+                MsgHeader:   MsgHeader{72, enums.MSG_TRANSPORT_PONG},
                 Challenge:   challenge,
                 Signature:   make([]byte, 64),
                 SignedBlock: new(SignedAddress),
@@ -195,11 +179,6 @@ func (m *TransportPongMsg) String() string {
         return fmt.Sprintf("TransportPongMsg{addr=<unknown>,%d}", m.Challenge)
 }
 
-// Header returns the message header in a separate instance.
-func (m *TransportPongMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 // Sign the address block of a pong message.
 func (m *TransportPongMsg) Sign(prv *ed25519.PrivateKey) error {
         data, err := data.Marshal(m.SignedBlock)
@@ -233,15 +212,13 @@ func (m *TransportPongMsg) Verify(pub *ed25519.PublicKey) (bool, error) {
 
 // SessionAckMsg is a message to acknowledge a session request
 type SessionAckMsg struct {
-        MsgSize uint16 `order:"big"` // total size of message
-        MsgType uint16 `order:"big"` // TRANSPORT_SESSION_ACK (377)
+        MsgHeader
 }
 
 // NewSessionAckMsg creates an new message (no body required).
 func NewSessionAckMsg() *SessionAckMsg {
         return &SessionAckMsg{
-                MsgSize: 16,
-                MsgType: TRANSPORT_SESSION_ACK,
+                MsgHeader: MsgHeader{4, enums.MSG_TRANSPORT_SESSION_ACK},
         }
 }
 
@@ -250,19 +227,13 @@ func (m *SessionAckMsg) String() string {
         return "SessionAck{}"
 }
 
-// Header returns the message header in a separate instance.
-func (m *SessionAckMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_SESSION_SYN
 //----------------------------------------------------------------------
 
 // SessionSynMsg is a synchronization request message for sessions
 type SessionSynMsg struct {
-        MsgSize   uint16            `order:"big"` // total size of message
-        MsgType   uint16            `order:"big"` // TRANSPORT_SESSION_SYN (375)
+        MsgHeader
         Reserved  uint32            `order:"big"` // reserved (=0)
         Timestamp util.AbsoluteTime // usec epoch
 }
@@ -270,8 +241,7 @@ type SessionSynMsg struct {
 // NewSessionSynMsg creates a SYN request for the a session
 func NewSessionSynMsg() *SessionSynMsg {
         return &SessionSynMsg{
-                MsgSize:   16,
-                MsgType:   TRANSPORT_SESSION_SYN,
+                MsgHeader: MsgHeader{16, enums.MSG_TRANSPORT_SESSION_SYN},
                 Reserved:  0,
                 Timestamp: util.AbsoluteTimeNow(),
         }
@@ -282,19 +252,13 @@ func (m *SessionSynMsg) String() string {
         return fmt.Sprintf("SessionSyn{timestamp=%s}", m.Timestamp)
 }
 
-// Header returns the message header in a separate instance.
-func (m *SessionSynMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_SESSION_SYN_ACK
 //----------------------------------------------------------------------
 
 // SessionSynAckMsg responds to a SYN request message
 type SessionSynAckMsg struct {
-        MsgSize   uint16            `order:"big"` // total size of message
-        MsgType   uint16            `order:"big"` // TRANSPORT_SESSION_SYN_ACK (376)
+        MsgHeader
         Reserved  uint32            `order:"big"` // reserved (=0)
         Timestamp util.AbsoluteTime // usec epoch
 }
@@ -302,8 +266,7 @@ type SessionSynAckMsg struct {
 // NewSessionSynAckMsg is an ACK for a SYN request
 func NewSessionSynAckMsg() *SessionSynAckMsg {
         return &SessionSynAckMsg{
-                MsgSize:   16,
-                MsgType:   TRANSPORT_SESSION_SYN_ACK,
+                MsgHeader: MsgHeader{16, enums.MSG_TRANSPORT_SESSION_SYN_ACK},
                 Reserved:  0,
                 Timestamp: util.AbsoluteTimeNow(),
         }
@@ -314,28 +277,22 @@ func (m *SessionSynAckMsg) String() string {
         return fmt.Sprintf("SessionSynAck{timestamp=%s}", m.Timestamp)
 }
 
-// Header returns the message header in a separate instance.
-func (m *SessionSynAckMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_SESSION_QUOTA
 //----------------------------------------------------------------------
 
 // SessionQuotaMsg is a message to announce quotas for a session
 type SessionQuotaMsg struct {
-        MsgSize uint16 `order:"big"` // total size of message
-        MsgType uint16 `order:"big"` // TRANSPORT_SESSION_QUOTA (379)
-        Quota   uint32 `order:"big"` // Quota in bytes per second
+        MsgHeader
+        Quota uint32 `order:"big"` // Quota in bytes per second
 }
 
 // NewSessionQuotaMsg announces a session quota to the other end of the session.
 func NewSessionQuotaMsg(quota uint32) *SessionQuotaMsg {
         m := new(SessionQuotaMsg)
+        m.MsgSize = 8
+        m.MsgType = enums.MSG_TRANSPORT_SESSION_QUOTA
         if quota > 0 {
-                m.MsgSize = 8
-                m.MsgType = TRANSPORT_SESSION_QUOTA
                 m.Quota = quota
         }
         return m
@@ -346,28 +303,21 @@ func (m *SessionQuotaMsg) String() string {
         return fmt.Sprintf("SessionQuotaMsg{%sB/s}", util.Scale1024(uint64(m.Quota)))
 }
 
-// Header returns the message header in a separate instance.
-func (m *SessionQuotaMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_SESSION_KEEPALIVE
 //----------------------------------------------------------------------
 
 // SessionKeepAliveMsg is a message send by peers to keep a session alive.
 type SessionKeepAliveMsg struct {
-        MsgSize uint16 `order:"big"` // total size of message
-        MsgType uint16 `order:"big"` // TRANSPORT_SESSION_KEEPALIVE (381)
-        Nonce   uint32
+        MsgHeader
+        Nonce uint32
 }
 
 // NewSessionKeepAliveMsg creates a new request to keep a session.
 func NewSessionKeepAliveMsg() *SessionKeepAliveMsg {
         m := &SessionKeepAliveMsg{
-                MsgSize: 8,
-                MsgType: TRANSPORT_SESSION_KEEPALIVE,
-                Nonce:   util.RndUInt32(),
+                MsgHeader: MsgHeader{8, enums.MSG_TRANSPORT_SESSION_KEEPALIVE},
+                Nonce:     util.RndUInt32(),
         }
         return m
 }
@@ -377,28 +327,21 @@ func (m *SessionKeepAliveMsg) String() string {
         return fmt.Sprintf("SessionKeepAliveMsg{%d}", m.Nonce)
 }
 
-// Header returns the message header in a separate instance.
-func (m *SessionKeepAliveMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}
-
 //----------------------------------------------------------------------
 // TRANSPORT_SESSION_KEEPALIVE_RESPONSE
 //----------------------------------------------------------------------
 
 // SessionKeepAliveRespMsg is a response for a peer to a "keep-alive" request.
 type SessionKeepAliveRespMsg struct {
-        MsgSize uint16 `order:"big"` // total size of message
-        MsgType uint16 `order:"big"` // TRANSPORT_SESSION_KEEPALIVE_RESPONSE (382)
-        Nonce   uint32
+        MsgHeader
+        Nonce uint32
 }
 
 // NewSessionKeepAliveRespMsg is a response message for a "keep session" request.
 func NewSessionKeepAliveRespMsg(nonce uint32) *SessionKeepAliveRespMsg {
         m := &SessionKeepAliveRespMsg{
-                MsgSize: 8,
-                MsgType: TRANSPORT_SESSION_KEEPALIVE_RESPONSE,
-                Nonce:   nonce,
+                MsgHeader: MsgHeader{8, enums.MSG_TRANSPORT_SESSION_KEEPALIVE_RESPONSE},
+                Nonce:     nonce,
         }
         return m
 }
@@ -407,8 +350,3 @@ func NewSessionKeepAliveRespMsg(nonce uint32) *SessionKeepAliveRespMsg {
 func (m *SessionKeepAliveRespMsg) String() string {
         return fmt.Sprintf("SessionKeepAliveRespMsg{%d}", m.Nonce)
 }
-
-// Header returns the message header in a separate instance.
-func (m *SessionKeepAliveRespMsg) Header() *Header {
-        return &Header{m.MsgSize, m.MsgType}
-}