func (fastdp *FastDatapath) getVxlanVportID(udpPort int) (odp.VportID, error) {
	fastdp.lock.Lock()
	defer fastdp.lock.Unlock()

	if vxlanVportID, present := fastdp.vxlanVportIDs[udpPort]; present {
		return vxlanVportID, nil
	}

	vxlanVportID, err := fastdp.dp.CreateVport(
		odp.NewVxlanVportSpec(fmt.Sprintf("vxlan-%d", udpPort), uint16(udpPort)))
	if err != nil {
		return 0, err
	}

	fastdp.vxlanVportIDs[udpPort] = vxlanVportID
	fastdp.missHandlers[vxlanVportID] = func(fks odp.FlowKeys, lock *fastDatapathLock) FlowOp {
		tunnel := fks[odp.OVS_KEY_ATTR_TUNNEL].(odp.TunnelFlowKey)
		tunKey := tunnel.Key()

		lock.relock()
		consumer := fastdp.overlayConsumer
		if consumer == nil {
			return vetoFlowCreationFlowOp{}
		}

		srcPeer, dstPeer := fastdp.extractPeers(tunKey.TunnelId)
		if srcPeer == nil || dstPeer == nil {
			return vetoFlowCreationFlowOp{}
		}

		lock.unlock()
		pk := flowKeysToPacketKey(fks)
		var zeroMAC MAC
		if pk.SrcMAC == zeroMAC && pk.DstMAC == zeroMAC {
			return vxlanSpecialPacketFlowOp{
				fastdp:  fastdp,
				srcPeer: srcPeer,
				sender: &net.UDPAddr{
					IP:   net.IP(tunKey.Ipv4Src[:]),
					Port: udpPort,
				},
			}
		}

		key := ForwardPacketKey{
			SrcPeer:   srcPeer,
			DstPeer:   dstPeer,
			PacketKey: pk,
		}

		var tunnelFlowKey odp.TunnelFlowKey
		tunnelFlowKey.SetTunnelId(tunKey.TunnelId)
		tunnelFlowKey.SetIpv4Src(tunKey.Ipv4Src)
		tunnelFlowKey.SetIpv4Dst(tunKey.Ipv4Dst)

		return NewMultiFlowOp(false, odpFlowKey(tunnelFlowKey), consumer(key))
	}

	return vxlanVportID, nil
}

func printTunnelOptions(fk odp.TunnelFlowKey, prefix string) {
	k := fk.Key()
	m := fk.Mask()

	printBytesOption(prefix+"id", k.TunnelId[:], m.TunnelId[:], hex.EncodeToString)
	printBytesOption(prefix+"ipv4-src", k.Ipv4Src[:], m.Ipv4Src[:], ipv4ToString)
	printBytesOption(prefix+"ipv4-dst", k.Ipv4Dst[:], m.Ipv4Dst[:], ipv4ToString)
	printByteOption(prefix+"tos", k.Tos, m.Tos)
	printByteOption(prefix+"ttl", k.Ttl, m.Ttl)

	if m.Df {
		fmt.Printf(" --%sdf=%t", prefix, k.Df)
	}

	if m.Csum {
		fmt.Printf(" --%scsum=%t", prefix, k.Csum)
	}
}

func parseTunnelFlags(tf *tunnelFlags) (odp.TunnelFlowKey, error) {
	var fk odp.TunnelFlowKey

	if tf.id != "" {
		tunnelId, err := parseTunnelId(tf.id)
		if err != nil {
			return fk, err
		}

		fk.SetTunnelId(tunnelId)
	}

	if tf.ipv4Src != "" {
		addr, err := parseIpv4(tf.ipv4Src)
		if err != nil {
			return fk, err
		}

		fk.SetIpv4Src(addr)
	}

	if tf.ipv4Dst != "" {
		addr, err := parseIpv4(tf.ipv4Dst)
		if err != nil {
			return fk, err
		}

		fk.SetIpv4Dst(addr)
	}

	if tf.tos >= 0 {
		fk.SetTos(uint8(tf.tos))
	}

	if tf.ttl >= 0 {
		fk.SetTtl(uint8(tf.ttl))
	}

	if tf.df != "" {
		df, err := parseBool(tf.df)
		if err != nil {
			return fk, err
		}

		fk.SetDf(df)
	}

	if tf.csum != "" {
		csum, err := parseBool(tf.csum)
		if err != nil {
			return fk, err
		}

		fk.SetCsum(csum)
	}

	if tf.tpsrc >= 0 {
		fk.SetTpSrc(uint16(tf.tpsrc))
	}

	if tf.tpdst >= 0 {
		fk.SetTpDst(uint16(tf.tpdst))
	}

	return fk, nil
}

func printSetTunnelOptions(a odp.SetTunnelAction) {
	var fk odp.TunnelFlowKey
	if a.Present.TunnelId {
		fk.SetTunnelId(a.TunnelId)
	}
	if a.Present.Ipv4Src {
		fk.SetIpv4Src(a.Ipv4Src)
	}
	if a.Present.Ipv4Dst {
		fk.SetIpv4Dst(a.Ipv4Dst)
	}
	if a.Present.Tos {
		fk.SetTos(a.Tos)
	}
	if a.Present.Ttl {
		fk.SetTtl(a.Ttl)
	}
	if a.Present.Df {
		fk.SetDf(a.Df)
	}
	if a.Present.Csum {
		fk.SetCsum(a.Csum)
	}
	if a.Present.TpSrc {
		fk.SetTpSrc(a.TpSrc)
	}
	if a.Present.TpDst {
		fk.SetTpDst(a.TpDst)
	}
	printTunnelOptions(fk, "set-tunnel-")
}

func (fastdp *FastDatapath) getVxlanVportID(udpPort int) (odp.VportID, error) {
	fastdp.lock.Lock()
	defer fastdp.lock.Unlock()

	if vxlanVportID, present := fastdp.vxlanVportIDs[udpPort]; present {
		return vxlanVportID, nil
	}

	name := fmt.Sprintf("vxlan-%d", udpPort)
	vxlanVportID, err := fastdp.dp.CreateVport(
		odp.NewVxlanVportSpec(name, uint16(udpPort)))
	if err != nil {
		return 0, err
	}

	// If a netdev for the vxlan vport exists, we need to do an extra check
	// to bypass the kernel bug which makes the vxlan creation to complete
	// successfully regardless whether there were any errors when binding
	// to the given UDP port.
	if link, err := netlink.LinkByName(name); err == nil {
		if link.Attrs().Flags&net.FlagUp == 0 {
			// The netdev interface is down, so most likely bringing it up
			// has failed due to the UDP port being in use.
			if err := fastdp.dp.DeleteVport(vxlanVportID); err != nil {
				log.Warning("Unable to remove vxlan vport %d: %s", vxlanVportID, err)
			}
			return 0, odp.NetlinkError(syscall.EADDRINUSE)
		}
	}

	fastdp.vxlanVportIDs[udpPort] = vxlanVportID
	fastdp.missHandlers[vxlanVportID] = func(fks odp.FlowKeys, lock *fastDatapathLock) FlowOp {
		log.Debug("ODP miss: ", fks, " on port ", vxlanVportID)
		tunnel := fks[odp.OVS_KEY_ATTR_TUNNEL].(odp.TunnelFlowKey)
		tunKey := tunnel.Key()

		lock.relock()
		consumer := fastdp.overlayConsumer
		if consumer == nil {
			return vetoFlowCreationFlowOp{}
		}

		srcPeer, dstPeer := fastdp.extractPeers(tunKey.TunnelId)
		if srcPeer == nil || dstPeer == nil {
			return vetoFlowCreationFlowOp{}
		}

		lock.unlock()
		pk := flowKeysToPacketKey(fks)
		var zeroMAC MAC
		if pk.SrcMAC == zeroMAC && pk.DstMAC == zeroMAC {
			return vxlanSpecialPacketFlowOp{
				fastdp:  fastdp,
				srcPeer: srcPeer,
				sender: &net.UDPAddr{
					IP:   net.IP(tunKey.Ipv4Src[:]),
					Port: udpPort,
				},
			}
		}

		key := ForwardPacketKey{
			SrcPeer:   srcPeer,
			DstPeer:   dstPeer,
			PacketKey: pk,
		}

		var tunnelFlowKey odp.TunnelFlowKey
		tunnelFlowKey.SetTunnelId(tunKey.TunnelId)
		tunnelFlowKey.SetIpv4Src(tunKey.Ipv4Src)
		tunnelFlowKey.SetIpv4Dst(tunKey.Ipv4Dst)

		return NewMultiFlowOp(false, odpFlowKey(tunnelFlowKey), consumer(key))
	}

	return vxlanVportID, nil
}