zebra/zapi: Support some FRRouting messages

The supposed FRRouting version for this patch is 3.0 (tag name is
"frr-3.0").

Note: This patch does not support all messages defined in FRRouting,
and some of message are left on TODO.

Signed-off-by: IWASE Yusuke <iwase.yusuke0@gmail.com>

1 files changed, 440 insertions, 139 deletions

diff --git a/zebra/zapi.go b/zebra/zapi.go
index 0beb3ccc..6998bd4e 100644
--- a/zebra/zapi.go
+++ b/zebra/zapi.go
@@ -103,7 +103,7 @@ const VRF_DEFAULT = 0
 
 func HeaderSize(version uint8) uint16 {
 	switch version {
-	case 3:
+	case 3, 4:
 		return 8
 	default:
 		return 6
@@ -521,8 +521,10 @@ func NewClient(network, address string, typ ROUTE_TYPE, version uint8) (*Client,
 	}
 	outgoing := make(chan *Message)
 	incoming := make(chan *Message, 64)
-	if version != 3 {
+	if version < 2 {
 		version = 2
+	} else if version > 4 {
+		version = 4
 	}
 
 	c := &Client{
@@ -657,10 +659,14 @@ func (c *Client) Send(m *Message) {
 }
 
 func (c *Client) SendCommand(command API_TYPE, vrfId uint16, body Body) error {
+	var marker uint8 = HEADER_MARKER
+	if c.Version >= 4 {
+		marker = FRR_HEADER_MARKER
+	}
 	m := &Message{
 		Header: Header{
 			Len:     HeaderSize(c.Version),
-			Marker:  HEADER_MARKER,
+			Marker:  marker,
 			Version: c.Version,
 			VrfId:   vrfId,
 			Command: command,
@@ -673,29 +679,56 @@ func (c *Client) SendCommand(command API_TYPE, vrfId uint16, body Body) error {
 
 func (c *Client) SendHello() error {
 	if c.redistDefault > 0 {
+		command := HELLO
 		body := &HelloBody{
 			RedistDefault: c.redistDefault,
+			Instance:      0,
+		}
+		if c.Version >= 4 {
+			command = FRR_HELLO
 		}
-		return c.SendCommand(HELLO, VRF_DEFAULT, body)
+		return c.SendCommand(command, VRF_DEFAULT, body)
 	}
 	return nil
 }
 
 func (c *Client) SendRouterIDAdd() error {
-	return c.SendCommand(ROUTER_ID_ADD, VRF_DEFAULT, nil)
+	command := ROUTER_ID_ADD
+	if c.Version >= 4 {
+		command = FRR_ROUTER_ID_ADD
+	}
+	return c.SendCommand(command, VRF_DEFAULT, nil)
 }
 
 func (c *Client) SendInterfaceAdd() error {
-	return c.SendCommand(INTERFACE_ADD, VRF_DEFAULT, nil)
+	command := INTERFACE_ADD
+	if c.Version >= 4 {
+		command = FRR_INTERFACE_ADD
+	}
+	return c.SendCommand(command, VRF_DEFAULT, nil)
 }
 
 func (c *Client) SendRedistribute(t ROUTE_TYPE, vrfId uint16) error {
+	command := REDISTRIBUTE_ADD
 	if c.redistDefault != t {
-		body := &RedistributeBody{
-			Redist: t,
+		bodies := make([]*RedistributeBody, 0)
+		if c.Version <= 3 {
+			bodies = append(bodies, &RedistributeBody{
+				Redist: t,
+			})
+		} else { // version >= 4
+			command = FRR_REDISTRIBUTE_ADD
+			for _, afi := range []AFI{AFI_IP, AFI_IP6} {
+				bodies = append(bodies, &RedistributeBody{
+					Afi:      afi,
+					Redist:   t,
+					Instance: 0,
+				})
+			}
 		}
-		if e := c.SendCommand(REDISTRIBUTE_ADD, vrfId, body); e != nil {
-			return e
+
+		for _, body := range bodies {
+			return c.SendCommand(command, vrfId, body)
 		}
 	}
 
@@ -703,14 +736,15 @@ func (c *Client) SendRedistribute(t ROUTE_TYPE, vrfId uint16) error {
 }
 
 func (c *Client) SendRedistributeDelete(t ROUTE_TYPE) error {
-
 	if t < ROUTE_MAX {
+		command := REDISTRIBUTE_DELETE
+		if c.Version >= 4 {
+			command = FRR_REDISTRIBUTE_DELETE
+		}
 		body := &RedistributeBody{
 			Redist: t,
 		}
-		if e := c.SendCommand(REDISTRIBUTE_DELETE, VRF_DEFAULT, body); e != nil {
-			return e
-		}
+		return c.SendCommand(command, VRF_DEFAULT, body)
 	} else {
 		return fmt.Errorf("unknown route type: %d", t)
 	}
@@ -732,14 +766,17 @@ type Header struct {
 
 func (h *Header) Serialize() ([]byte, error) {
 	buf := make([]byte, HeaderSize(h.Version))
-	binary.BigEndian.PutUint16(buf[0:], h.Len)
+	binary.BigEndian.PutUint16(buf[0:2], h.Len)
 	buf[2] = h.Marker
 	buf[3] = h.Version
-	if h.Version == 3 {
+	switch h.Version {
+	case 2:
+		binary.BigEndian.PutUint16(buf[4:6], uint16(h.Command))
+	case 3, 4:
 		binary.BigEndian.PutUint16(buf[4:6], uint16(h.VrfId))
-		binary.BigEndian.PutUint16(buf[6:], uint16(h.Command))
-	} else {
-		binary.BigEndian.PutUint16(buf[4:], uint16(h.Command))
+		binary.BigEndian.PutUint16(buf[6:8], uint16(h.Command))
+	default:
+		return nil, fmt.Errorf("Unsupported ZAPI version: %d", h.Version)
 	}
 	return buf, nil
 }
@@ -754,11 +791,14 @@ func (h *Header) DecodeFromBytes(data []byte) error {
 	if uint16(len(data)) < HeaderSize(h.Version) {
 		return fmt.Errorf("Not all ZAPI message header")
 	}
-	if h.Version == 3 {
+	switch h.Version {
+	case 2:
+		h.Command = API_TYPE(binary.BigEndian.Uint16(data[4:6]))
+	case 3, 4:
 		h.VrfId = binary.BigEndian.Uint16(data[4:6])
 		h.Command = API_TYPE(binary.BigEndian.Uint16(data[6:8]))
-	} else {
-		h.Command = API_TYPE(binary.BigEndian.Uint16(data[4:6]))
+	default:
+		return fmt.Errorf("Unsupported ZAPI version: %d", h.Version)
 	}
 	return nil
 }
@@ -788,36 +828,68 @@ func (b *UnknownBody) String() string {
 
 type HelloBody struct {
 	RedistDefault ROUTE_TYPE
+	Instance      uint16
 }
 
 func (b *HelloBody) DecodeFromBytes(data []byte, version uint8) error {
 	b.RedistDefault = ROUTE_TYPE(data[0])
+	if version >= 4 {
+		b.Instance = binary.BigEndian.Uint16(data[1:3])
+	}
 	return nil
 }
 
 func (b *HelloBody) Serialize(version uint8) ([]byte, error) {
-	return []byte{uint8(b.RedistDefault)}, nil
+	if version <= 3 {
+		return []byte{uint8(b.RedistDefault)}, nil
+	} else { // version >= 4
+		buf := make([]byte, 3, 3)
+		buf[0] = uint8(b.RedistDefault)
+		binary.BigEndian.PutUint16(buf[1:3], b.Instance)
+		return buf, nil
+
+	}
 }
 
 func (b *HelloBody) String() string {
-	return fmt.Sprintf("route_type: %d", b.RedistDefault)
+	return fmt.Sprintf(
+		"route_type: %s, instance :%d",
+		b.RedistDefault.String(), b.Instance)
 }
 
 type RedistributeBody struct {
-	Redist ROUTE_TYPE
+	Afi      AFI
+	Redist   ROUTE_TYPE
+	Instance uint16
 }
 
 func (b *RedistributeBody) DecodeFromBytes(data []byte, version uint8) error {
-	b.Redist = ROUTE_TYPE(data[0])
+	if version <= 3 {
+		b.Redist = ROUTE_TYPE(data[0])
+	} else { // version >= 4
+		b.Afi = AFI(data[0])
+		b.Redist = ROUTE_TYPE(data[1])
+		b.Instance = binary.BigEndian.Uint16(data[2:4])
+	}
 	return nil
 }
 
 func (b *RedistributeBody) Serialize(version uint8) ([]byte, error) {
-	return []byte{uint8(b.Redist)}, nil
+	if version <= 3 {
+		return []byte{uint8(b.Redist)}, nil
+	} else { // version >= 4
+		buf := make([]byte, 4, 4)
+		buf[0] = uint8(b.Afi)
+		buf[1] = uint8(b.Redist)
+		binary.BigEndian.PutUint16(buf[2:4], b.Instance)
+		return buf, nil
+	}
 }
 
 func (b *RedistributeBody) String() string {
-	return fmt.Sprintf("route_type: %d", b.Redist)
+	return fmt.Sprintf(
+		"afi: %s, route_type: %s, instance :%d",
+		b.Afi.String(), b.Redist.String(), b.Instance)
 }
 
 type InterfaceUpdateBody struct {
@@ -825,7 +897,10 @@ type InterfaceUpdateBody struct {
 	Index        uint32
 	Status       INTERFACE_STATUS
 	Flags        uint64
+	PTMEnable    PTM_ENABLE
+	PTMStatus    PTM_STATUS
 	Metric       uint32
+	Speed        uint32
 	MTU          uint32
 	MTU6         uint32
 	Bandwidth    uint32
@@ -840,17 +915,27 @@ func (b *InterfaceUpdateBody) DecodeFromBytes(data []byte, version uint8) error
 
 	b.Name = strings.Trim(string(data[:INTERFACE_NAMSIZ]), "\u0000")
 	data = data[INTERFACE_NAMSIZ:]
-	b.Index = binary.BigEndian.Uint32(data[:4])
+	b.Index = binary.BigEndian.Uint32(data[0:4])
 	b.Status = INTERFACE_STATUS(data[4])
 	b.Flags = binary.BigEndian.Uint64(data[5:13])
-	b.Metric = binary.BigEndian.Uint32(data[13:17])
-	b.MTU = binary.BigEndian.Uint32(data[17:21])
-	b.MTU6 = binary.BigEndian.Uint32(data[21:25])
-	b.Bandwidth = binary.BigEndian.Uint32(data[25:29])
-	data = data[29:]
-	if version > 2 {
-		b.Linktype = LINK_TYPE(binary.BigEndian.Uint32(data[:4]))
-		data = data[4:]
+	if version >= 4 {
+		b.PTMEnable = PTM_ENABLE(data[13])
+		b.PTMStatus = PTM_STATUS(data[14])
+		b.Metric = binary.BigEndian.Uint32(data[15:19])
+		b.Speed = binary.BigEndian.Uint32(data[19:23])
+		data = data[23:]
+	} else {
+		b.Metric = binary.BigEndian.Uint32(data[13:17])
+		data = data[17:]
+	}
+	b.MTU = binary.BigEndian.Uint32(data[0:4])
+	b.MTU6 = binary.BigEndian.Uint32(data[4:8])
+	b.Bandwidth = binary.BigEndian.Uint32(data[8:12])
+	if version >= 3 {
+		b.Linktype = LINK_TYPE(binary.BigEndian.Uint32(data[12:16]))
+		data = data[16:]
+	} else {
+		data = data[12:]
 	}
 	l := binary.BigEndian.Uint32(data[:4])
 	if l > 0 {
@@ -867,9 +952,11 @@ func (b *InterfaceUpdateBody) Serialize(version uint8) ([]byte, error) {
 }
 
 func (b *InterfaceUpdateBody) String() string {
-	s := fmt.Sprintf("name: %s, idx: %d, status: %s, flags: %s, metric: %d, mtu: %d, mtu6: %d, bandwidth: %d, linktype: %s", b.Name, b.Index, b.Status, intfflag2string(b.Flags), b.Metric, b.MTU, b.MTU6, b.Bandwidth, b.Linktype)
+	s := fmt.Sprintf(
+		"name: %s, idx: %d, status: %s, flags: %s, ptm_enable: %s, ptm_status: %s, metric: %d, speed: %d, mtu: %d, mtu6: %d, bandwidth: %d, linktype: %s",
+		b.Name, b.Index, b.Status.String(), intfflag2string(b.Flags), b.PTMEnable.String(), b.PTMStatus.String(), b.Metric, b.Speed, b.MTU, b.MTU6, b.Bandwidth, b.Linktype.String())
 	if len(b.HardwareAddr) > 0 {
-		return s + fmt.Sprintf(", mac: %s", b.HardwareAddr)
+		return s + fmt.Sprintf(", mac: %s", b.HardwareAddr.String())
 	}
 	return s
 }
@@ -906,7 +993,9 @@ func (b *InterfaceAddressUpdateBody) Serialize(version uint8) ([]byte, error) {
 }
 
 func (b *InterfaceAddressUpdateBody) String() string {
-	return fmt.Sprintf("idx: %d, flags: %d, addr: %s/%d", b.Index, b.Flags, b.Prefix, b.Length)
+	return fmt.Sprintf(
+		"idx: %d, flags: %d, addr: %s/%d",
+		b.Index, b.Flags.String(), b.Prefix.String(), b.Length)
 }
 
 type RouterIDUpdateBody struct {
@@ -935,61 +1024,81 @@ func (b *RouterIDUpdateBody) Serialize(version uint8) ([]byte, error) {
 }
 
 func (b *RouterIDUpdateBody) String() string {
-	return fmt.Sprintf("id: %s/%d", b.Prefix, b.Length)
+	return fmt.Sprintf("id: %s/%d", b.Prefix.String(), b.Length)
 }
 
 type IPRouteBody struct {
-	Type         ROUTE_TYPE
-	Flags        FLAG
-	Message      MESSAGE_FLAG
-	SAFI         SAFI
-	Prefix       net.IP
-	PrefixLength uint8
-	Nexthops     []net.IP
-	Ifindexs     []uint32
-	Distance     uint8
-	Metric       uint32
-	Mtu          uint32
-	Api          API_TYPE
+	Type            ROUTE_TYPE
+	Instance        uint16
+	Flags           FLAG
+	Message         MESSAGE_FLAG
+	SAFI            SAFI
+	Prefix          net.IP
+	PrefixLength    uint8
+	SrcPrefix       net.IP
+	SrcPrefixLength uint8
+	Nexthops        []net.IP
+	Ifindexs        []uint32
+	Distance        uint8
+	Metric          uint32
+	Mtu             uint32
+	Tag             uint32
+	Api             API_TYPE
 }
 
 func (b *IPRouteBody) Serialize(version uint8) ([]byte, error) {
-	buf := make([]byte, 5)
-	buf[0] = uint8(b.Type)
-	buf[1] = uint8(b.Flags)
-	buf[2] = uint8(b.Message)
-	binary.BigEndian.PutUint16(buf[3:], uint16(b.SAFI))
-	bitlen := b.PrefixLength
-	bytelen := (int(b.PrefixLength) + 7) / 8
-	bbuf := make([]byte, bytelen)
-	copy(bbuf, b.Prefix)
-	if bitlen%8 != 0 {
-		mask := 0xff00 >> (bitlen % 8)
-		last_byte_value := bbuf[bytelen-1] & byte(mask)
-		bbuf[bytelen-1] = last_byte_value
-	}
-	buf = append(buf, bitlen)
-	buf = append(buf, bbuf...)
+
+	var buf []byte
+	nhfIPv4 := uint8(NEXTHOP_IPV4)
+	nhfIPv6 := uint8(NEXTHOP_IPV6)
+	nhfIndx := uint8(NEXTHOP_IFINDEX)
+	nhfBlkH := uint8(NEXTHOP_BLACKHOLE)
+	if version <= 3 {
+		buf = make([]byte, 5)
+		buf[0] = uint8(b.Type)
+		buf[1] = uint8(b.Flags)
+		buf[2] = uint8(b.Message)
+		binary.BigEndian.PutUint16(buf[3:5], uint16(b.SAFI))
+	} else { // version >= 4
+		buf = make([]byte, 10)
+		buf[0] = uint8(b.Type)
+		binary.BigEndian.PutUint16(buf[1:3], uint16(b.Instance))
+		binary.BigEndian.PutUint32(buf[3:7], uint32(b.Flags))
+		buf[7] = uint8(b.Message)
+		binary.BigEndian.PutUint16(buf[8:10], uint16(b.SAFI))
+		nhfIPv4 = uint8(FRR_NEXTHOP_IPV4)
+		nhfIPv6 = uint8(FRR_NEXTHOP_IPV6)
+		nhfIndx = uint8(FRR_NEXTHOP_IFINDEX)
+		nhfBlkH = uint8(FRR_NEXTHOP_BLACKHOLE)
+	}
+	byteLen := (int(b.PrefixLength) + 7) / 8
+	buf = append(buf, b.PrefixLength)
+	buf = append(buf, b.Prefix[:byteLen]...)
+	if b.Message&FRR_MESSAGE_SRCPFX > 0 {
+		byteLen = (int(b.SrcPrefixLength) + 7) / 8
+		buf = append(buf, b.SrcPrefixLength)
+		buf = append(buf, b.SrcPrefix[:byteLen]...)
+	}
 
 	if b.Message&MESSAGE_NEXTHOP > 0 {
 		if b.Flags&FLAG_BLACKHOLE > 0 {
-			buf = append(buf, []byte{1, uint8(NEXTHOP_BLACKHOLE)}...)
+			buf = append(buf, []byte{1, nhfBlkH}...)
 		} else {
 			buf = append(buf, uint8(len(b.Nexthops)+len(b.Ifindexs)))
 		}
 
 		for _, v := range b.Nexthops {
 			if v.To4() != nil {
-				buf = append(buf, uint8(NEXTHOP_IPV4))
+				buf = append(buf, nhfIPv4)
 				buf = append(buf, v.To4()...)
 			} else {
-				buf = append(buf, uint8(NEXTHOP_IPV6))
+				buf = append(buf, nhfIPv6)
 				buf = append(buf, v.To16()...)
 			}
 		}
 
 		for _, v := range b.Ifindexs {
-			buf = append(buf, uint8(NEXTHOP_IFINDEX))
+			buf = append(buf, nhfIndx)
 			bbuf := make([]byte, 4)
 			binary.BigEndian.PutUint32(bbuf, v)
 			buf = append(buf, bbuf...)
@@ -1004,46 +1113,86 @@ func (b *IPRouteBody) Serialize(version uint8) ([]byte, error) {
 		binary.BigEndian.PutUint32(bbuf, b.Metric)
 		buf = append(buf, bbuf...)
 	}
-	if b.Message&MESSAGE_MTU > 0 {
-		bbuf := make([]byte, 4)
-		binary.BigEndian.PutUint32(bbuf, b.Mtu)
-		buf = append(buf, bbuf...)
+	if version <= 3 {
+		if b.Message&MESSAGE_MTU > 0 {
+			bbuf := make([]byte, 4)
+			binary.BigEndian.PutUint32(bbuf, b.Mtu)
+			buf = append(buf, bbuf...)
+		}
+		if b.Message&MESSAGE_TAG > 0 {
+			bbuf := make([]byte, 4)
+			binary.BigEndian.PutUint32(bbuf, b.Tag)
+			buf = append(buf, bbuf...)
+		}
+	} else { // version >= 4
+		if b.Message&FRR_MESSAGE_TAG > 0 {
+			bbuf := make([]byte, 4)
+			binary.BigEndian.PutUint32(bbuf, b.Tag)
+			buf = append(buf, bbuf...)
+		}
+		if b.Message&FRR_MESSAGE_MTU > 0 {
+			bbuf := make([]byte, 4)
+			binary.BigEndian.PutUint32(bbuf, b.Mtu)
+			buf = append(buf, bbuf...)
+		}
 	}
 	return buf, nil
 }
 
 func (b *IPRouteBody) DecodeFromBytes(data []byte, version uint8) error {
-
-	isV4 := b.Api == IPV4_ROUTE_ADD || b.Api == IPV4_ROUTE_DELETE
+	isV4 := true
+	if version <= 3 {
+		isV4 = b.Api == IPV4_ROUTE_ADD || b.Api == IPV4_ROUTE_DELETE
+	} else {
+		isV4 = b.Api == FRR_REDISTRIBUTE_IPV4_ADD || b.Api == FRR_REDISTRIBUTE_IPV4_DEL
+	}
 	var addrLen uint8 = net.IPv4len
 	if !isV4 {
 		addrLen = net.IPv6len
 	}
 
 	b.Type = ROUTE_TYPE(data[0])
-	b.Flags = FLAG(data[1])
-	b.Message = MESSAGE_FLAG(data[2])
-	b.PrefixLength = data[3]
+	if version <= 3 {
+		b.Flags = FLAG(data[1])
+		data = data[2:]
+	} else { // version >= 4
+		b.Instance = binary.BigEndian.Uint16(data[1:3])
+		b.Flags = FLAG(binary.BigEndian.Uint32(data[3:7]))
+		data = data[7:]
+	}
+
+	b.Message = MESSAGE_FLAG(data[0])
 	b.SAFI = SAFI(SAFI_UNICAST)
 
+	b.PrefixLength = data[1]
 	if b.PrefixLength > addrLen*8 {
 		return fmt.Errorf("prefix length is greater than %d", addrLen*8)
 	}
-
-	byteLen := int((b.PrefixLength + 7) / 8)
-
-	pos := 4
+	pos := 2
 	buf := make([]byte, addrLen)
+	byteLen := int((b.PrefixLength + 7) / 8)
 	copy(buf, data[pos:pos+byteLen])
-
 	if isV4 {
 		b.Prefix = net.IP(buf).To4()
 	} else {
 		b.Prefix = net.IP(buf).To16()
 	}
-
 	pos += byteLen
 
+	if b.Message&FRR_MESSAGE_SRCPFX > 0 {
+		b.SrcPrefixLength = data[pos]
+		pos += 1
+		buf = make([]byte, addrLen)
+		byteLen = int((b.SrcPrefixLength + 7) / 8)
+		copy(buf, data[pos:pos+byteLen])
+		if isV4 {
+			b.SrcPrefix = net.IP(buf).To4()
+		} else {
+			b.SrcPrefix = net.IP(buf).To16()
+		}
+		pos += byteLen
+	}
+
 	rest := 0
 	var numNexthop int
 	if b.Message&MESSAGE_NEXTHOP > 0 {
@@ -1051,20 +1200,32 @@ func (b *IPRouteBody) DecodeFromBytes(data []byte, version uint8) error {
 		// rest = numNexthop(1) + (nexthop(4 or 16) + placeholder(1) + ifindex(4)) * numNexthop
 		rest += 1 + numNexthop*(int(addrLen)+5)
 	}
-
 	if b.Message&MESSAGE_DISTANCE > 0 {
 		// distance(1)
 		rest += 1
 	}
-
 	if b.Message&MESSAGE_METRIC > 0 {
 		// metric(4)
 		rest += 4
 	}
-
-	if b.Message&MESSAGE_MTU > 0 {
-		// mtu(4)
-		rest += 4
+	if version <= 3 {
+		if b.Message&MESSAGE_MTU > 0 {
+			// mtu(4)
+			rest += 4
+		}
+		if b.Message&MESSAGE_TAG > 0 {
+			// tag(4)
+			rest += 4
+		}
+	} else { // version >= 4
+		if b.Message&FRR_MESSAGE_TAG > 0 {
+			// tag(4)
+			rest += 4
+		}
+		if b.Message&FRR_MESSAGE_MTU > 0 {
+			// mtu(4)
+			rest += 4
+		}
 	}
 
 	if len(data[pos:]) != rest {
@@ -1102,23 +1263,48 @@ func (b *IPRouteBody) DecodeFromBytes(data []byte, version uint8) error {
 		b.Metric = binary.BigEndian.Uint32(data[pos : pos+4])
 		pos += 4
 	}
-	if b.Message&MESSAGE_MTU > 0 {
-		b.Mtu = binary.BigEndian.Uint32(data[pos : pos+4])
-		pos += 4
+	if version <= 3 {
+		if b.Message&MESSAGE_MTU > 0 {
+			b.Mtu = binary.BigEndian.Uint32(data[pos : pos+4])
+			pos += 4
+		}
+		if b.Message&MESSAGE_TAG > 0 {
+			b.Tag = binary.BigEndian.Uint32(data[pos : pos+4])
+			pos += 4
+		}
+	} else {
+		if b.Message&FRR_MESSAGE_TAG > 0 {
+			b.Tag = binary.BigEndian.Uint32(data[pos : pos+4])
+			pos += 4
+		}
+		if b.Message&FRR_MESSAGE_MTU > 0 {
+			b.Mtu = binary.BigEndian.Uint32(data[pos : pos+4])
+			pos += 4
+		}
 	}
 
 	return nil
 }
 
 func (b *IPRouteBody) String() string {
-	s := fmt.Sprintf("type: %s, flags: %s, message: %d, prefix: %s, length: %d, nexthop: %s, distance: %d, metric: %d, mtu: %d",
-		b.Type.String(), b.Flags.String(), b.Message, b.Prefix.String(), b.PrefixLength, b.Nexthops[0].String(), b.Distance, b.Metric, b.Mtu)
-	return s
+	s := fmt.Sprintf(
+		"type: %s, instance: %d, flags: %s, message: %d, safi: %s, prefix: %s/%d, src_prefix: %s/%d",
+		b.Type.String(), b.Instance, b.Flags.String(), b.Message, b.SAFI.String(), b.Prefix.String(), b.PrefixLength, b.SrcPrefix.String(), b.SrcPrefixLength)
+	for i, nh := range b.Nexthops {
+		s += fmt.Sprintf(", nexthops[%d]: %s", i, nh.String())
+	}
+	for i, idx := range b.Ifindexs {
+		s += fmt.Sprintf(", ifindex[%d]: %d", i, idx)
+	}
+	return s + fmt.Sprintf(
+		", distance: %d, metric: %d, mtu: %d, tag: %d",
+		b.Distance, b.Metric, b.Mtu, b.Tag)
 }
 
 type NexthopLookupBody struct {
 	Api      API_TYPE
 	Addr     net.IP
+	Distance uint8
 	Metric   uint32
 	Nexthops []*Nexthop
 }
@@ -1131,34 +1317,63 @@ type Nexthop struct {
 }
 
 func (n *Nexthop) String() string {
-	s := fmt.Sprintf("type: %s, addr: %s, ifindex: %d, ifname: %s", n.Type.String(), n.Addr.String(), n.Ifindex, n.Ifname)
+	s := fmt.Sprintf(
+		"type: %s, addr: %s, ifindex: %d, ifname: %s",
+		n.Type.String(), n.Addr.String(), n.Ifindex, n.Ifname)
 	return s
 }
 
-func serializeNexthops(nexthops []*Nexthop, isV4 bool) ([]byte, error) {
+func serializeNexthops(nexthops []*Nexthop, isV4 bool, version uint8) ([]byte, error) {
 	buf := make([]byte, 0)
 	if len(nexthops) == 0 {
 		return buf, nil
 	}
 	buf = append(buf, byte(len(nexthops)))
 
+	nhIfindex := NEXTHOP_IFINDEX
+	nhIfname := NEXTHOP_IFNAME
+	nhIPv4 := NEXTHOP_IPV4
+	nhIPv4Ifindex := NEXTHOP_IPV4_IFINDEX
+	nhIPv4Ifname := NEXTHOP_IPV4_IFNAME
+	nhIPv6 := NEXTHOP_IPV6
+	nhIPv6Ifindex := NEXTHOP_IPV6_IFINDEX
+	nhIPv6Ifname := NEXTHOP_IPV6_IFNAME
+	if version >= 4 {
+		nhIfindex = FRR_NEXTHOP_IFINDEX
+		nhIfname = NEXTHOP_FLAG(0)
+		nhIPv4 = FRR_NEXTHOP_IPV4
+		nhIPv4Ifindex = FRR_NEXTHOP_IPV4_IFINDEX
+		nhIPv4Ifname = NEXTHOP_FLAG(0)
+		nhIPv6 = FRR_NEXTHOP_IPV6
+		nhIPv6Ifindex = FRR_NEXTHOP_IPV6_IFINDEX
+		nhIPv6Ifname = NEXTHOP_FLAG(0)
+	}
+
 	for _, nh := range nexthops {
 		buf = append(buf, byte(nh.Type))
 
 		switch nh.Type {
-		case NEXTHOP_IFINDEX, NEXTHOP_IFNAME:
+		case nhIfindex, nhIfname:
 			bbuf := make([]byte, 4)
 			binary.BigEndian.PutUint32(bbuf, nh.Ifindex)
 			buf = append(buf, bbuf...)
 
-		case NEXTHOP_IPV4, NEXTHOP_IPV6:
+		case nhIPv4, nhIPv6:
 			if isV4 {
 				buf = append(buf, nh.Addr.To4()...)
 			} else {
 				buf = append(buf, nh.Addr.To16()...)
 			}
+			if version >= 4 {
+				// On FRRouting version 3.0 or later, NEXTHOP_IPV4 and
+				// NEXTHOP_IPV6 have the same structure with
+				// NEXTHOP_TYPE_IPV4_IFINDEX and NEXTHOP_TYPE_IPV6_IFINDEX.
+				bbuf := make([]byte, 4)
+				binary.BigEndian.PutUint32(bbuf, nh.Ifindex)
+				buf = append(buf, bbuf...)
+			}
 
-		case NEXTHOP_IPV4_IFINDEX, NEXTHOP_IPV4_IFNAME, NEXTHOP_IPV6_IFINDEX, NEXTHOP_IPV6_IFNAME:
+		case nhIPv4Ifindex, nhIPv4Ifname, nhIPv6Ifindex, nhIPv6Ifname:
 			if isV4 {
 				buf = append(buf, nh.Addr.To4()...)
 			} else {
@@ -1173,11 +1388,29 @@ func serializeNexthops(nexthops []*Nexthop, isV4 bool) ([]byte, error) {
 	return buf, nil
 }
 
-func decodeNexthopsFromBytes(nexthops *[]*Nexthop, data []byte, isV4 bool) (int, error) {
+func decodeNexthopsFromBytes(nexthops *[]*Nexthop, data []byte, isV4 bool, version uint8) (int, error) {
 	addrLen := net.IPv4len
 	if !isV4 {
 		addrLen = net.IPv6len
 	}
+	nhIfindex := NEXTHOP_IFINDEX
+	nhIfname := NEXTHOP_IFNAME
+	nhIPv4 := NEXTHOP_IPV4
+	nhIPv4Ifindex := NEXTHOP_IPV4_IFINDEX
+	nhIPv4Ifname := NEXTHOP_IPV4_IFNAME
+	nhIPv6 := NEXTHOP_IPV6
+	nhIPv6Ifindex := NEXTHOP_IPV6_IFINDEX
+	nhIPv6Ifname := NEXTHOP_IPV6_IFNAME
+	if version >= 4 {
+		nhIfindex = FRR_NEXTHOP_IFINDEX
+		nhIfname = NEXTHOP_FLAG(0)
+		nhIPv4 = FRR_NEXTHOP_IPV4
+		nhIPv4Ifindex = FRR_NEXTHOP_IPV4_IFINDEX
+		nhIPv4Ifname = NEXTHOP_FLAG(0)
+		nhIPv6 = FRR_NEXTHOP_IPV6
+		nhIPv6Ifindex = FRR_NEXTHOP_IPV6_IFINDEX
+		nhIPv6Ifname = NEXTHOP_FLAG(0)
+	}
 
 	numNexthop := int(data[0])
 	offset := 1
@@ -1188,19 +1421,26 @@ func decodeNexthopsFromBytes(nexthops *[]*Nexthop, data []byte, isV4 bool) (int,
 		offset += 1
 
 		switch nh.Type {
-		case NEXTHOP_IFINDEX, NEXTHOP_IFNAME:
+		case nhIfindex, nhIfname:
 			nh.Ifindex = binary.BigEndian.Uint32(data[offset : offset+4])
 			offset += 4
 
-		case NEXTHOP_IPV4, NEXTHOP_IPV6:
+		case nhIPv4, nhIPv6:
 			if isV4 {
 				nh.Addr = net.IP(data[offset : offset+addrLen]).To4()
 			} else {
 				nh.Addr = net.IP(data[offset : offset+addrLen]).To16()
 			}
 			offset += addrLen
+			if version >= 4 {
+				// On FRRouting version 3.0 or later, NEXTHOP_IPV4 and
+				// NEXTHOP_IPV6 have the same structure with
+				// NEXTHOP_TYPE_IPV4_IFINDEX and NEXTHOP_TYPE_IPV6_IFINDEX.
+				nh.Ifindex = binary.BigEndian.Uint32(data[offset : offset+4])
+				offset += 4
+			}
 
-		case NEXTHOP_IPV4_IFINDEX, NEXTHOP_IPV4_IFNAME, NEXTHOP_IPV6_IFINDEX, NEXTHOP_IPV6_IFNAME:
+		case nhIPv4Ifindex, nhIPv4Ifname, nhIPv6Ifindex, nhIPv6Ifname:
 			if isV4 {
 				nh.Addr = net.IP(data[offset : offset+addrLen]).To4()
 			} else {
@@ -1217,8 +1457,13 @@ func decodeNexthopsFromBytes(nexthops *[]*Nexthop, data []byte, isV4 bool) (int,
 }
 
 func (b *NexthopLookupBody) Serialize(version uint8) ([]byte, error) {
+	isV4 := false
+	if version <= 3 {
+		isV4 = b.Api == IPV4_NEXTHOP_LOOKUP
+	} else { // version >= 4
+		isV4 = b.Api == FRR_IPV4_NEXTHOP_LOOKUP_MRIB
+	}
 
-	isV4 := b.Api == IPV4_NEXTHOP_LOOKUP
 	buf := make([]byte, 0)
 
 	if isV4 {
@@ -1230,8 +1475,12 @@ func (b *NexthopLookupBody) Serialize(version uint8) ([]byte, error) {
 }
 
 func (b *NexthopLookupBody) DecodeFromBytes(data []byte, version uint8) error {
-
-	isV4 := b.Api == IPV4_NEXTHOP_LOOKUP
+	isV4 := false
+	if version <= 3 {
+		isV4 = b.Api == IPV4_NEXTHOP_LOOKUP
+	} else { // version >= 4
+		isV4 = b.Api == FRR_IPV4_NEXTHOP_LOOKUP_MRIB
+	}
 	addrLen := net.IPv4len
 	if !isV4 {
 		addrLen = net.IPv6len
@@ -1251,11 +1500,16 @@ func (b *NexthopLookupBody) DecodeFromBytes(data []byte, version uint8) error {
 		b.Addr = net.IP(buf).To16()
 	}
 
+	if version >= 4 {
+		b.Distance = data[pos]
+		pos++
+	}
+
 	if len(data[pos:]) > int(1+addrLen) {
 		b.Metric = binary.BigEndian.Uint32(data[pos : pos+4])
 		pos += 4
 		b.Nexthops = []*Nexthop{}
-		if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[pos:], isV4); err != nil {
+		if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[pos:], isV4, version); err != nil {
 			return err
 		} else {
 			pos += nexthopsByteLen
@@ -1266,7 +1520,9 @@ func (b *NexthopLookupBody) DecodeFromBytes(data []byte, version uint8) error {
 }
 
 func (b *NexthopLookupBody) String() string {
-	s := fmt.Sprintf("addr: %s, metric: %d", b.Addr, b.Metric)
+	s := fmt.Sprintf(
+		"addr: %s, distance:%d, metric: %d",
+		b.Addr.String(), b.Distance, b.Metric)
 	if len(b.Nexthops) > 0 {
 		for _, nh := range b.Nexthops {
 			s = s + fmt.Sprintf(", nexthop:{%s}", nh.String())
@@ -1312,7 +1568,7 @@ func (b *ImportLookupBody) DecodeFromBytes(data []byte, version uint8) error {
 		b.Metric = binary.BigEndian.Uint32(data[pos : pos+4])
 		pos += 4
 		b.Nexthops = []*Nexthop{}
-		if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[pos:], isV4); err != nil {
+		if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[pos:], isV4, version); err != nil {
 			return err
 		} else {
 			pos += nexthopsByteLen
@@ -1323,7 +1579,9 @@ func (b *ImportLookupBody) DecodeFromBytes(data []byte, version uint8) error {
 }
 
 func (b *ImportLookupBody) String() string {
-	s := fmt.Sprintf("addr: %s, metric: %d", b.Addr, b.Metric)
+	s := fmt.Sprintf(
+		"prefix: %s/%d, addr: %s, metric: %d",
+		b.Prefix.String(), b.PrefixLength, b.Addr.String(), b.Metric)
 	if len(b.Nexthops) > 0 {
 		for _, nh := range b.Nexthops {
 			s = s + fmt.Sprintf(", nexthop:{%s}", nh.String())
@@ -1400,7 +1658,9 @@ func (n *RegisteredNexthop) DecodeFromBytes(data []byte) error {
 }
 
 func (n *RegisteredNexthop) String() string {
-	return fmt.Sprintf("connected: %d, family: %d, prefix: %s", n.Connected, n.Family, n.Prefix.String())
+	return fmt.Sprintf(
+		"connected: %d, family: %d, prefix: %s",
+		n.Connected, n.Family, n.Prefix.String())
 }
 
 type NexthopRegisterBody struct {
@@ -1461,6 +1721,7 @@ type NexthopUpdateBody struct {
 	// - 32 if Address Family is AF_INET
 	// - 128 if Address Family is AF_INET6
 	Prefix   net.IP
+	Distance uint8
 	Metric   uint32
 	Nexthops []*Nexthop
 }
@@ -1504,9 +1765,16 @@ func (b *NexthopUpdateBody) DecodeFromBytes(data []byte, version uint8) error {
 	}
 	offset += addrLen
 
+	// Distance (1 byte) (if version>=4)
 	// Metric (4 bytes)
 	// Number of Nexthops (1 byte)
-	if len(data[offset:]) < 4+1 {
+	if version >= 4 {
+		if len(data[offset:]) < 6 {
+			return fmt.Errorf("invalid message length: missing distance(1 byte), metric(4 bytes) or nexthops(1 byte): %d<6", len(data[offset:]))
+		}
+		b.Distance = data[offset]
+		offset += 1
+	} else if len(data[offset:]) < 5 {
 		return fmt.Errorf("invalid message length: missing metric(4 bytes) or nexthops(1 byte): %d<5", len(data[offset:]))
 	}
 	b.Metric = binary.BigEndian.Uint32(data[offset : offset+4])
@@ -1514,7 +1782,7 @@ func (b *NexthopUpdateBody) DecodeFromBytes(data []byte, version uint8) error {
 
 	// List of Nexthops
 	b.Nexthops = []*Nexthop{}
-	if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[offset:], isV4); err != nil {
+	if nexthopsByteLen, err := decodeNexthopsFromBytes(&b.Nexthops, data[offset:], isV4, version); err != nil {
 		return err
 	} else {
 		offset += nexthopsByteLen
@@ -1524,7 +1792,9 @@ func (b *NexthopUpdateBody) DecodeFromBytes(data []byte, version uint8) error {
 }
 
 func (b *NexthopUpdateBody) String() string {
-	s := fmt.Sprintf("family: %d, prefix: %s, metric: %d", b.Family, b.Prefix.String(), b.Metric)
+	s := fmt.Sprintf(
+		"family: %d, prefix: %s, distance: %d, metric: %d",
+		b.Family, b.Prefix.String(), b.Distance, b.Metric)
 	for _, nh := range b.Nexthops {
 		s = s + fmt.Sprintf(", nexthop:{%s}", nh.String())
 	}
@@ -1553,9 +1823,7 @@ func (m *Message) Serialize() ([]byte, error) {
 	return append(hdr, body...), nil
 }
 
-func ParseMessage(hdr *Header, data []byte) (*Message, error) {
-	m := &Message{Header: *hdr}
-
+func (m *Message) parseMessage(data []byte) error {
 	switch m.Header.Command {
 	case INTERFACE_ADD, INTERFACE_DELETE, INTERFACE_UP, INTERFACE_DOWN:
 		m.Body = &InterfaceUpdateBody{}
@@ -1565,31 +1833,64 @@ func ParseMessage(hdr *Header, data []byte) (*Message, error) {
 		m.Body = &RouterIDUpdateBody{}
 	case IPV4_ROUTE_ADD, IPV6_ROUTE_ADD, IPV4_ROUTE_DELETE, IPV6_ROUTE_DELETE:
 		m.Body = &IPRouteBody{Api: m.Header.Command}
-		log.WithFields(log.Fields{
-			"Topic": "Zebra",
-		}).Debugf("ipv4/v6 route add/delete message received: %v", data)
 	case IPV4_NEXTHOP_LOOKUP, IPV6_NEXTHOP_LOOKUP:
 		m.Body = &NexthopLookupBody{Api: m.Header.Command}
-		log.WithFields(log.Fields{
-			"Topic": "Zebra",
-		}).Debugf("ipv4/v6 nexthop lookup received: %v", data)
 	case IPV4_IMPORT_LOOKUP:
 		m.Body = &ImportLookupBody{Api: m.Header.Command}
-		log.WithFields(log.Fields{
-			"Topic": "Zebra",
-		}).Debugf("ipv4 import lookup message received: %v", data)
 	case NEXTHOP_UPDATE:
 		m.Body = &NexthopUpdateBody{Api: m.Header.Command}
-		log.WithFields(log.Fields{
-			"Topic": "Zebra",
-		}).Debugf("nexthop update message received: %v", data)
 	default:
 		m.Body = &UnknownBody{}
-		log.WithFields(log.Fields{
-			"Topic": "Zebra",
-		}).Debugf("unknown message received: %v", data)
 	}
-	err := m.Body.DecodeFromBytes(data, m.Header.Version)
+	return m.Body.DecodeFromBytes(data, m.Header.Version)
+}
+
+func (m *Message) parseFrrMessage(data []byte) error {
+	switch m.Header.Command {
+	case FRR_INTERFACE_ADD, FRR_INTERFACE_DELETE, FRR_INTERFACE_UP, FRR_INTERFACE_DOWN:
+		m.Body = &InterfaceUpdateBody{}
+	case FRR_INTERFACE_ADDRESS_ADD, FRR_INTERFACE_ADDRESS_DELETE:
+		m.Body = &InterfaceAddressUpdateBody{}
+	case FRR_ROUTER_ID_UPDATE:
+		m.Body = &RouterIDUpdateBody{}
+	case FRR_NEXTHOP_UPDATE:
+		m.Body = &NexthopUpdateBody{}
+	case FRR_INTERFACE_NBR_ADDRESS_ADD, FRR_INTERFACE_NBR_ADDRESS_DELETE:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_INTERFACE_BFD_DEST_UPDATE:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_IMPORT_CHECK_UPDATE:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_BFD_DEST_REPLAY:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_REDISTRIBUTE_IPV4_ADD, FRR_REDISTRIBUTE_IPV4_DEL, FRR_REDISTRIBUTE_IPV6_ADD, FRR_REDISTRIBUTE_IPV6_DEL:
+		m.Body = &IPRouteBody{Api: m.Header.Command}
+	case FRR_INTERFACE_VRF_UPDATE:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_INTERFACE_LINK_PARAMS:
+		// TODO
+		m.Body = &UnknownBody{}
+	case FRR_PW_STATUS_UPDATE:
+		// TODO
+		m.Body = &UnknownBody{}
+	default:
+		m.Body = &UnknownBody{}
+	}
+	return m.Body.DecodeFromBytes(data, m.Header.Version)
+}
+
+func ParseMessage(hdr *Header, data []byte) (m *Message, err error) {
+	m = &Message{Header: *hdr}
+	if m.Header.Version == 4 {
+		err = m.parseFrrMessage(data)
+	} else {
+		err = m.parseMessage(data)
+	}
 	if err != nil {
 		return nil, err
 	}