diff --git a/openflow/barrier.go b/openflow/barrier.go
index 7b631fe..60f5a2f 100644
--- a/openflow/barrier.go
+++ b/openflow/barrier.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
@@ -26,6 +26,7 @@
 	jsonRequest, _ := json.Marshal(request)
 	log.Printf("handleBarrierRequest called with %s", jsonRequest)
 	reply := ofp.NewBarrierReply()
+	reply.SetVersion(4)
 	reply.SetXid(request.GetXid())
 	client.SendMessage(reply)
 }
diff --git a/openflow/echo.go b/openflow/echo.go
index 51d09df..8e6c0c5 100644
--- a/openflow/echo.go
+++ b/openflow/echo.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
diff --git a/openflow/feature.go b/openflow/feature.go
index 2c01f73..6a22836 100644
--- a/openflow/feature.go
+++ b/openflow/feature.go
@@ -19,9 +19,9 @@
 import (
 	"context"
 	"encoding/json"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"github.com/opencord/voltha-protos/go/common"
 	pb "github.com/opencord/voltha-protos/go/voltha"
-	ofp "github.com/skydive-project/goloxi/of13"
 	"log"
 )
 
@@ -38,6 +38,7 @@
 func createFeaturesRequestReply(xid uint32, device *pb.LogicalDevice) *ofp.FeaturesReply {
 
 	featureReply := ofp.NewFeaturesReply()
+	featureReply.SetVersion(4)
 	featureReply.SetXid(xid)
 	features := device.GetSwitchFeatures()
 	featureReply.SetDatapathId(device.GetDatapathId())
diff --git a/openflow/flowMod.go b/openflow/flowMod.go
index 37e6864..2508bde 100644
--- a/openflow/flowMod.go
+++ b/openflow/flowMod.go
@@ -19,10 +19,11 @@
 import (
 	"context"
 	"encoding/json"
+	"log"
+
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"github.com/opencord/voltha-protos/go/openflow_13"
 	pb "github.com/opencord/voltha-protos/go/voltha"
-	ofp "github.com/skydive-project/goloxi/of13"
-	"log"
 )
 
 var oxmMap = map[string]int32{
@@ -147,6 +148,11 @@
 			var value pb.OfpOxmOfbField_UdpDst
 			value.UdpDst = uint32(udpDst)
 			field.Value = &value
+		case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+			vid := val.(uint16) & 0xfff
+			var value pb.OfpOxmOfbField_VlanVid
+			value.VlanVid = uint32(vid)
+			field.Value = &value
 		}
 		oxmList = append(oxmList, &ofpOxmField)
 	}
@@ -160,18 +166,22 @@
 		instructionType := ofpInstruction.GetType()
 		instruction.Type = uint32(instructionType)
 		switch instructionType {
-		case 1:
+		case ofp.OFPITGotoTable:
 			goToTable := ofpInstruction.(ofp.IInstructionGotoTable)
 			var ofpGoToTable openflow_13.OfpInstruction_GotoTable
+			var oGoToTable openflow_13.OfpInstructionGotoTable
+			ofpGoToTable.GotoTable = &oGoToTable
 			ofpGoToTable.GotoTable.TableId = uint32(goToTable.GetTableId())
 			instruction.Data = &ofpGoToTable
-		case 2:
+		case ofp.OFPITWriteMetadata:
 			writeMetaData := ofpInstruction.(ofp.IInstructionWriteMetadata)
 			var ofpWriteMetadata openflow_13.OfpInstruction_WriteMetadata
+			var writeMetadata openflow_13.OfpInstructionWriteMetadata
+			ofpWriteMetadata.WriteMetadata = &writeMetadata
 			ofpWriteMetadata.WriteMetadata.Metadata = writeMetaData.GetMetadata()
 			ofpWriteMetadata.WriteMetadata.MetadataMask = writeMetaData.GetMetadataMask()
 			instruction.Data = &ofpWriteMetadata
-		case 3:
+		case ofp.OFPITWriteActions:
 			writeAction := ofpInstruction.(ofp.IInstructionWriteActions)
 			var ofpInstructionActions openflow_13.OfpInstruction_Actions
 			var ofpActions []*openflow_13.OfpAction
@@ -182,7 +192,7 @@
 				ofpActions = append(ofpActions, ofpAction)
 			}
 			instruction.Data = &ofpInstructionActions
-		case 4:
+		case ofp.OFPITApplyActions:
 			applyAction := ofpInstruction.(ofp.IInstructionApplyActions)
 			var ofpInstructionActions openflow_13.OfpInstruction_Actions
 			var ofpActions []*openflow_13.OfpAction
@@ -196,7 +206,14 @@
 			actionsHolder.Actions = ofpActions
 			ofpInstructionActions.Actions = &actionsHolder
 			instruction.Data = &ofpInstructionActions
+		case ofp.OFPITMeter:
+			var instructionMeter = ofpInstruction.(ofp.IInstructionMeter)
+			var meterInstruction openflow_13.OfpInstruction_Meter
+			var meter openflow_13.OfpInstructionMeter
 
+			meter.MeterId = instructionMeter.GetMeterId()
+			meterInstruction.Meter = &meter
+			instruction.Data = &meterInstruction
 		}
 		instructions = append(instructions, &instruction)
 	}
@@ -234,50 +251,3 @@
 	log.Printf("handleFlowDeleteStrict called with %s", js)
 
 }
-func extractAction(action ofp.IAction) *openflow_13.OfpAction {
-	var ofpAction openflow_13.OfpAction
-	switch action.GetType() {
-	case 0: // Output
-		var outputAction openflow_13.OfpAction_Output
-		loxiOutputAction := action.(*ofp.ActionOutput)
-		var output openflow_13.OfpActionOutput
-		output.Port = uint32(loxiOutputAction.Port)
-		output.MaxLen = uint32(loxiOutputAction.MaxLen)
-		outputAction.Output = &output
-		ofpAction.Action = &outputAction
-	case 11: //CopyTtlOut
-	case 12: //CopyTtlIn
-	case 15: //SetMplsTtl
-	case 16: //DecMplsTtl
-	case 17: //PushVlan
-		var pushVlan openflow_13.OfpAction_Push
-		loxiPushAction := action.(*ofp.ActionPopVlan)
-		fields := loxiPushAction.GetActionFields()
-		fieldsJS, _ := json.Marshal(fields)
-		log.Printf("\n\nPushVlan fields %s\n\n", fieldsJS)
-		pushVlan.Push.Ethertype = 0x8100 //TODO This should be available in the fields
-		ofpAction.Type = openflow_13.OfpActionType_OFPAT_PUSH_VLAN
-	case 18: //PopVlan
-		ofpAction.Type = openflow_13.OfpActionType_OFPAT_POP_VLAN
-	case 19: //PushMpls
-	case 20: //PopMpls
-	case 21: //SetQueue
-	case 22: //ActionGroup
-	case 23: //SetNwTtl
-	case 24: //DecNwTtl
-	case 25: //SetField
-		var setField openflow_13.OfpAction_SetField
-		loxiSetField := action.(*ofp.ActionSetField)
-		fields := loxiSetField.GetActionFields()
-		fieldsJS, _ := json.Marshal(fields)
-		log.Printf("\n\nSet Fields fields %s\n\n", fieldsJS)
-
-		ofpAction.Action = &setField
-	case 26: //PushPbb
-	case 27: //PopPbb
-	case 65535: //Experimenter
-
-	}
-	return &ofpAction
-
-}
diff --git a/openflow/getConfig.go b/openflow/getConfig.go
index 6d4444f..2ba4ded 100644
--- a/openflow/getConfig.go
+++ b/openflow/getConfig.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
@@ -26,6 +26,7 @@
 	jsonReq, _ := json.Marshal(request)
 	log.Printf("handleGetConfigRequest called with %s", jsonReq)
 	reply := ofp.NewGetConfigReply()
+	reply.SetVersion(4)
 	reply.SetXid(request.GetXid())
 	reply.SetMissSendLen(ofp.OFPCMLNoBuffer)
 	client.SendMessage(reply)
diff --git a/openflow/meter.go b/openflow/meter.go
new file mode 100644
index 0000000..43d690e
--- /dev/null
+++ b/openflow/meter.go
@@ -0,0 +1,88 @@
+/*
+   Copyright 2017 the original author or authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+package openflow
+
+import (
+	"encoding/json"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
+	"github.com/opencord/voltha-protos/go/openflow_13"
+	"golang.org/x/net/context"
+	"log"
+)
+
+func handleMeterModRequest(request *ofp.MeterMod, client *Client) {
+	jsonRequest, _ := json.Marshal(request)
+	log.Printf("handleMeterModRequest called with %s", jsonRequest)
+
+	var meterModUpdate openflow_13.MeterModUpdate
+	meterModUpdate.Id = client.DeviceId
+	var meterMod openflow_13.OfpMeterMod
+	meterMod.MeterId = request.MeterId
+	meterMod.Flags = uint32(request.Flags)
+	command := openflow_13.OfpMeterModCommand(request.Command)
+	meterMod.Command = command
+	var bands []*openflow_13.OfpMeterBandHeader
+	ofpBands := request.GetMeters()
+	for i := 0; i < len(ofpBands); i++ {
+		ofpBand := ofpBands[i]
+
+		bandType := ofpBand.GetType()
+		var band openflow_13.OfpMeterBandHeader
+		switch bandType {
+		case ofp.OFPMBTDrop:
+			ofpDrop := ofpBand.(ofp.IMeterBandDrop)
+			band.BurstSize = ofpDrop.GetBurstSize()
+			band.Type = openflow_13.OfpMeterBandType_OFPMBT_DROP
+			band.Rate = ofpDrop.GetRate()
+			var meterBandHeaderDrop openflow_13.OfpMeterBandHeader_Drop
+			var drop openflow_13.OfpMeterBandDrop
+			meterBandHeaderDrop.Drop = &drop
+			band.Data = &meterBandHeaderDrop
+		case ofp.OFPMBTDSCPRemark:
+			ofpDscpRemark := ofpBand.(ofp.IMeterBandDscpRemark)
+			var dscpRemark openflow_13.OfpMeterBandDscpRemark
+			band.Type = openflow_13.OfpMeterBandType_OFPMBT_DSCP_REMARK
+			band.BurstSize = ofpDscpRemark.GetBurstSize()
+			band.Rate = ofpDscpRemark.GetRate()
+			dscpRemark.PrecLevel = uint32(ofpDscpRemark.GetPrecLevel())
+			var meterBandHeaderDscp openflow_13.OfpMeterBandHeader_DscpRemark
+			meterBandHeaderDscp.DscpRemark = &dscpRemark
+			band.Data = &meterBandHeaderDscp
+		case ofp.OFPMBTExperimenter:
+			ofpExperimenter := ofpBand.(ofp.IMeterBandExperimenter)
+			var experimenter openflow_13.OfpMeterBandExperimenter
+			experimenter.Experimenter = ofpExperimenter.GetExperimenter()
+			band.Type = openflow_13.OfpMeterBandType_OFPMBT_EXPERIMENTER
+			band.BurstSize = ofpExperimenter.GetBurstSize()
+			band.Rate = ofpExperimenter.GetRate()
+			var meterBandHeaderExperimenter openflow_13.OfpMeterBandHeader_Experimenter
+			meterBandHeaderExperimenter.Experimenter = &experimenter
+			band.Data = &meterBandHeaderExperimenter
+		}
+		bands = append(bands, &band)
+	}
+	meterMod.Bands = bands
+	meterModUpdate.MeterMod = &meterMod
+	grpcClient := *getGrpcClient()
+	meterModJS, _ := json.Marshal(meterModUpdate)
+	log.Printf("METER MOD UPDATE %s", meterModJS)
+	empty, err := grpcClient.UpdateLogicalDeviceMeterTable(context.Background(), &meterModUpdate)
+	if err != nil {
+		log.Printf("ERROR DOING METER MOD ADD %v", err)
+	}
+	emptyJs, _ := json.Marshal(empty)
+	log.Printf("METER MOD RESPONSE %s", emptyJs)
+}
diff --git a/openflow/ofError.go b/openflow/ofError.go
index c4329e1..2ca5b81 100644
--- a/openflow/ofError.go
+++ b/openflow/ofError.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
diff --git a/openflow/openflowClient.go b/openflow/openflowClient.go
index b07e36d..f7e3b72 100644
--- a/openflow/openflowClient.go
+++ b/openflow/openflowClient.go
@@ -21,9 +21,9 @@
 	"fmt"
 	"time"
 
+	"github.com/donNewtonAlpha/goloxi"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	pb "github.com/opencord/voltha-protos/go/voltha"
-	"github.com/skydive-project/goloxi"
-	ofp "github.com/skydive-project/goloxi/of13"
 
 	"log"
 	"net"
@@ -138,80 +138,66 @@
 
 	log.Printf("parseHeader called with type %d", header.GetType())
 	switch header.GetType() {
-	case 0:
+	case ofp.OFPTHello:
 		x := header.(*ofp.Hello)
 		log.Printf("helloMessage : %+v", x)
-		//nothing real to do
-	case 1:
+	case ofp.OFPTError:
 		errMsg := header.(*ofp.ErrorMsg)
 		go handleErrMsg(errMsg)
-	case 2:
+	case ofp.OFPTEchoRequest:
 		echoReq := header.(*ofp.EchoRequest)
 		go handleEchoRequest(echoReq, client)
-	case 3:
-		//EchoReply
-	case 4:
-		//Expirementer
-	case 5:
+	case ofp.OFPTEchoReply:
+	case ofp.OFPTExperimenter:
+	case ofp.OFPTFeaturesRequest:
 		featReq := header.(*ofp.FeaturesRequest)
 		go handleFeatureRequest(featReq, client.DeviceId, client)
-	case 6:
-		//feature reply
-	case 7:
+	case ofp.OFPTFeaturesReply:
+	case ofp.OFPTGetConfigRequest:
 		configReq := header.(*ofp.GetConfigRequest)
 		go handleGetConfigRequest(configReq, client)
-	case 8:
-		//GetConfigReply
-	case 9:
+	case ofp.OFPTGetConfigReply:
+	case ofp.OFPTSetConfig:
 		setConf := header.(*ofp.SetConfig)
 		go handleSetConfig(setConf)
-	case 10:
-		//packetIn := header.(*ofp.PacketIn)
-		//go handlePacketIn(packetIn)
-	case 11:
-		//FlowRemoved
-	case 12:
-		//portStatus
-	case 13:
+	case ofp.OFPTPacketIn:
+	case ofp.OFPTFlowRemoved:
+	case ofp.OFPTPortStatus:
+	case ofp.OFPTPacketOut:
 		packetOut := header.(*ofp.PacketOut)
 		go handlePacketOut(packetOut, client.DeviceId)
-	case 14:
+	case ofp.OFPTFlowMod:
 		flowModType := uint8(buf[25])
 		switch flowModType {
-		case 0:
+		case ofp.OFPFCAdd:
 			flowAdd := header.(*ofp.FlowAdd)
 			go handleFlowAdd(flowAdd, client.DeviceId)
-			//return DecodeFlowAdd(_flowmod, decoder)
-		case 1:
+		case ofp.OFPFCModify:
 			flowMod := header.(*ofp.FlowMod)
 			go handleFlowMod(flowMod, client.DeviceId)
-			//return DecodeFlowModify(_flowmod, decoder)
-		case 2:
+		case ofp.OFPFCModifyStrict:
 			flowModStrict := header.(*ofp.FlowModifyStrict)
 			go handleFlowModStrict(flowModStrict, client.DeviceId)
-			//return DecodeFlowModifyStrict(_flowmod, decoder)
-		case 3:
+		case ofp.OFPFCDelete:
 			flowDelete := header.(*ofp.FlowDelete)
 			go handleFlowDelete(flowDelete, client.DeviceId)
-			//return DecodeFlowDelete(_flowmod, decoder)
-		case 4:
+		case ofp.OFPFCDeleteStrict:
 			flowDeleteStrict := header.(*ofp.FlowDeleteStrict)
 			go handleFlowDeleteStrict(flowDeleteStrict, client.DeviceId)
-			//return DecodeFlowDeleteStrict(_flowmod, decoder)
-		default:
-			//return nil, fmt.Errorf("Invalid type '%d' for 'FlowMod'", _flowmod.Command)
-
 		}
-	case 18:
+	case ofp.OFPTStatsRequest:
 		var statType = uint16(buf[8])<<8 + uint16(buf[9])
 		log.Println("statsType", statType)
 		go handleStatsRequest(header, statType, client.DeviceId, client)
-	case 20:
+	case ofp.OFPTBarrierRequest:
 		barRequest := header.(*ofp.BarrierRequest)
 		go handleBarrierRequest(barRequest, client)
-	case 24:
+	case ofp.OFPTRoleRequest:
 		roleReq := header.(*ofp.RoleRequest)
 		go handleRoleRequest(roleReq, client)
+	case ofp.OFPTMeterMod:
+		meterMod := header.(*ofp.MeterMod)
+		go handleMeterModRequest(meterMod, client)
 
 	}
 }
@@ -227,7 +213,8 @@
 	enc := goloxi.NewEncoder()
 	message.Serialize(enc)
 	jMessage, _ := json.Marshal(message)
-	log.Printf("message after serialize %s", jMessage)
+	bytes := enc.Bytes()
+	log.Printf("message after serialize %d for message %s", bytes, jMessage)
 
 	for {
 		if conn == nil {
@@ -237,10 +224,12 @@
 			break
 		}
 	}
-	_, err := conn.Write(enc.Bytes())
+	_, err := conn.Write(bytes)
 	if err != nil {
-		log.Printf("SendMessage had error %s", err)
+		log.Printf("SendMessage had error %v \n %s\n********", err, jMessage)
 		return err
+	} else {
+		log.Printf("message after send %s", jMessage)
 	}
 	return nil
 }
diff --git a/openflow/packet.go b/openflow/packet.go
index 2bd46cd..66949cd 100644
--- a/openflow/packet.go
+++ b/openflow/packet.go
@@ -18,8 +18,8 @@
 
 import (
 	"encoding/json"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	pb "github.com/opencord/voltha-protos/go/voltha"
-	ofp "github.com/skydive-project/goloxi/of13"
 	"log"
 )
 
@@ -33,12 +33,18 @@
 	inActions := packetOut.GetActions()
 	for i := 0; i < len(inActions); i++ {
 		action := inActions[i]
-		var newAction = pb.OfpAction{}
+		newAction := extractAction(action)
+		/*var newAction = pb.OfpAction{}
 		newAction.Type = pb.OfpActionType(action.GetType())
-		actions = append(actions, &newAction)
+		action.
+
+		*/
+		actions = append(actions, newAction)
 	}
 	pktOut.Actions = actions
 	pktOut.Data = packetOut.GetData()
+	js, _ := json.Marshal(pktOut)
+	log.Printf("PacketOut %s", js)
 	pbPacketOut := pb.PacketOut{}
 	pbPacketOut.PacketOut = &pktOut
 	pbPacketOut.Id = deviceId
diff --git a/openflow/parseGrpcReturn.go b/openflow/parseGrpcReturn.go
new file mode 100644
index 0000000..706e9a7
--- /dev/null
+++ b/openflow/parseGrpcReturn.go
@@ -0,0 +1,184 @@
+/*
+   Copyright 2017 the original author or authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+package openflow
+
+import (
+	"encoding/json"
+	"github.com/donNewtonAlpha/goloxi"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
+	"github.com/opencord/voltha-protos/go/openflow_13"
+	pb "github.com/opencord/voltha-protos/go/voltha"
+	"log"
+	"unsafe"
+)
+
+func parseOxm(ofbField *openflow_13.OfpOxmOfbField) (goloxi.IOxm, uint16) {
+	switch ofbField.Type {
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+		ofpInPort := ofp.NewOxmInPort()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_Port)
+		ofpInPort.Value = ofp.Port(val.Port)
+		return ofpInPort, 4
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+		ofpEthType := ofp.NewOxmEthType()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_EthType)
+		ofpEthType.Value = ofp.EthernetType(val.EthType)
+		return ofpEthType, 2
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
+		ofpInPhyPort := ofp.NewOxmInPhyPort()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
+		ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
+		return ofpInPhyPort, 4
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+		ofpIpProto := ofp.NewOxmIpProto()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_IpProto)
+		ofpIpProto.Value = ofp.IpPrototype(val.IpProto)
+		return ofpIpProto, 1
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+		ofpUdpSrc := ofp.NewOxmUdpSrc()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpSrc)
+		ofpUdpSrc.Value = uint16(val.UdpSrc)
+		return ofpUdpSrc, 2
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+		ofpUdpDst := ofp.NewOxmUdpDst()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
+		ofpUdpDst.Value = uint16(val.UdpDst)
+		return ofpUdpDst, 2
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+		ofpVlanVid := ofp.NewOxmVlanVid()
+		val := ofbField.GetValue()
+		if val != nil {
+			vlanId := val.(*openflow_13.OfpOxmOfbField_VlanVid)
+			ofpVlanVid.Value = uint16(vlanId.VlanVid) + 0x1000
+		} else {
+			ofpVlanVid.Value = uint16(0)
+		}
+		return ofpVlanVid, 2
+	case pb.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+		ofpMetadata := ofp.NewOxmMetadata()
+		val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_TableMetadata)
+		ofpMetadata.Value = val.TableMetadata
+		return ofpMetadata, 8
+	default:
+		log.Printf("handleFlowStatsRequest   Unhandled OxmField %v", ofbField.Type)
+	}
+	return nil, 0
+}
+func parseInstructions(ofpInstruction *openflow_13.OfpInstruction) (ofp.IInstruction, uint16) {
+	instType := ofpInstruction.Type
+	data := ofpInstruction.GetData()
+	switch instType {
+	case ofp.OFPITWriteMetadata:
+		instruction := ofp.NewInstructionWriteMetadata()
+		instruction.Len = 24
+		metadata := data.(*openflow_13.OfpInstruction_WriteMetadata).WriteMetadata
+		instruction.Metadata = uint64(metadata.Metadata)
+		return instruction, 24
+	case ofp.OFPITMeter:
+		instruction := ofp.NewInstructionMeter()
+		instruction.Len = 8
+		meter := data.(*openflow_13.OfpInstruction_Meter).Meter
+		instruction.MeterId = meter.MeterId
+		return instruction, 8
+	case ofp.OFPITGotoTable:
+		instruction := ofp.NewInstructionGotoTable()
+		instruction.Len = 8
+		gotoTable := data.(*openflow_13.OfpInstruction_GotoTable).GotoTable
+		instruction.TableId = uint8(gotoTable.TableId)
+		return instruction, 8
+	case ofp.OFPITApplyActions:
+		instruction := ofp.NewInstructionApplyActions()
+		var instructionSize uint16
+		instructionSize = 8
+		ofpActions := ofpInstruction.GetActions().Actions
+		var actions []goloxi.IAction
+		for i := 0; i < len(ofpActions); i++ {
+			ofpAction := ofpActions[i]
+			action, actionSize := parseAction(ofpAction)
+			js, _ := json.Marshal(action)
+			log.Printf("ACTION size(%d) value %s", actionSize, js)
+			actions = append(actions, action)
+			instructionSize += actionSize
+			mySize := unsafe.Sizeof(*instruction)
+			log.Printf("Calculated Size %d Measured size %d", instructionSize, mySize)
+
+		}
+		instruction.Actions = actions
+		instruction.SetLen(instructionSize)
+		js, _ := json.Marshal(instruction)
+		log.Printf("INSTRUCTION %s", js)
+		return instruction, instructionSize
+	}
+	//shouldn't have reached here :<
+	js, _ := json.Marshal(ofpInstruction)
+	log.Printf("Parse Instruction Failed ofpInstruction : %s", js)
+	return nil, 0
+}
+func parseAction(ofpAction *openflow_13.OfpAction) (goloxi.IAction, uint16) {
+	js, _ := json.Marshal(ofpAction)
+	log.Printf("ACTION BEFORE %s", js)
+	switch ofpAction.Type {
+	case openflow_13.OfpActionType_OFPAT_OUTPUT:
+		ofpOutputAction := ofpAction.GetOutput()
+		outputAction := ofp.NewActionOutput()
+		outputAction.Port = ofp.Port(ofpOutputAction.Port)
+		outputAction.MaxLen = uint16(ofpOutputAction.MaxLen)
+		outputAction.Len = 16
+		return outputAction, 16
+	case openflow_13.OfpActionType_OFPAT_PUSH_VLAN:
+		ofpPushVlanAction := ofp.NewActionPushVlan()
+		ofpPushVlanAction.Ethertype = uint16(ofpAction.GetPush().Ethertype)
+		ofpPushVlanAction.Len = 8
+		return ofpPushVlanAction, 8
+	case openflow_13.OfpActionType_OFPAT_POP_VLAN:
+		ofpPopVlanAction := ofp.NewActionPopVlan()
+		ofpPopVlanAction.Len = 8
+		return ofpPopVlanAction, 8
+	case openflow_13.OfpActionType_OFPAT_SET_FIELD:
+		ofpActionSetField := ofpAction.GetSetField()
+		setFieldAction := ofp.NewActionSetField()
+
+		iOxm, _ := parseOxm(ofpActionSetField.GetField().GetOfbField())
+		setFieldAction.Field = iOxm
+		setFieldAction.Len = 10
+		return setFieldAction, 10
+	default:
+		js, _ := json.Marshal(ofpAction)
+		log.Printf("UNKNOWN ACTION %s", js)
+	}
+	return nil, 0
+}
+func parsePortStats(port *pb.LogicalPort) ofp.PortStatsEntry {
+	stats := port.OfpPortStats
+	port.OfpPort.GetPortNo()
+	var entry ofp.PortStatsEntry
+	entry.SetPortNo(ofp.Port(port.OfpPort.GetPortNo()))
+	entry.SetRxPackets(stats.GetRxPackets())
+	entry.SetTxPackets(stats.GetTxPackets())
+	entry.SetRxBytes(stats.GetRxBytes())
+	entry.SetTxBytes(stats.GetTxBytes())
+	entry.SetRxDropped(stats.GetRxDropped())
+	entry.SetTxDropped(stats.GetTxDropped())
+	entry.SetRxErrors(stats.GetRxErrors())
+	entry.SetTxErrors(stats.GetTxErrors())
+	entry.SetRxFrameErr(stats.GetRxFrameErr())
+	entry.SetRxOverErr(stats.GetRxOverErr())
+	entry.SetRxCrcErr(stats.GetRxCrcErr())
+	entry.SetCollisions(stats.GetCollisions())
+	entry.SetDurationSec(stats.GetDurationSec())
+	entry.SetDurationNsec(stats.GetDurationNsec())
+	return entry
+}
diff --git a/openflow/role.go b/openflow/role.go
index 08cf457..0620321 100644
--- a/openflow/role.go
+++ b/openflow/role.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
diff --git a/openflow/setConfig.go b/openflow/setConfig.go
index c429f46..69a6ab2 100644
--- a/openflow/setConfig.go
+++ b/openflow/setConfig.go
@@ -18,7 +18,7 @@
 
 import (
 	"encoding/json"
-	ofp "github.com/skydive-project/goloxi/of13"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"log"
 )
 
diff --git a/openflow/stats.go b/openflow/stats.go
index 46fe2f2..0218463 100644
--- a/openflow/stats.go
+++ b/openflow/stats.go
@@ -19,15 +19,16 @@
 import (
 	"context"
 	"encoding/json"
-	"github.com/opencord/voltha-protos/go/openflow_13"
-	"github.com/skydive-project/goloxi"
+
 	"log"
 	"net"
 	"unsafe"
 
+	"github.com/opencord/voltha-protos/go/openflow_13"
+
+	"github.com/donNewtonAlpha/goloxi"
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
 	"github.com/opencord/voltha-protos/go/common"
-	pb "github.com/opencord/voltha-protos/go/voltha"
-	ofp "github.com/skydive-project/goloxi/of13"
 )
 
 func handleStatsRequest(request ofp.IHeader, statType uint16, deviceId string, client *Client) error {
@@ -36,7 +37,7 @@
 	var id = common.ID{Id: deviceId}
 
 	switch statType {
-	case 0:
+	case ofp.OFPSTDesc:
 		statsReq := request.(*ofp.DescStatsRequest)
 		response, err := handleDescStatsRequest(statsReq, id)
 		if err != nil {
@@ -44,29 +45,32 @@
 		}
 		client.SendMessage(response)
 
-	case 1:
+	case ofp.OFPSTFlow:
 		statsReq := request.(*ofp.FlowStatsRequest)
 		response, _ := handleFlowStatsRequest(statsReq, id)
+		response.Length = uint16(unsafe.Sizeof(*response))
+		jResponse, _ := json.Marshal(response)
+		log.Printf("HANDLE FLOW STATS REQUEST response\n\n\n %s \n\n\n", jResponse)
 		err := client.SendMessage(response)
 		if err != nil {
 			return err
 		}
 
-	case 2:
+	case ofp.OFPSTAggregate:
 		statsReq := request.(*ofp.AggregateStatsRequest)
 		aggregateStatsReply, err := handleAggregateStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(aggregateStatsReply)
-	case 3:
+	case ofp.OFPSTTable:
 		statsReq := request.(*ofp.TableStatsRequest)
 		tableStatsReply, e := handleTableStatsRequest(statsReq, id)
 		if e != nil {
 			return e
 		}
 		client.SendMessage(tableStatsReply)
-	case 4:
+	case ofp.OFPSTPort:
 		statsReq := request.(*ofp.PortStatsRequest)
 		response, err := handlePortStatsRequest(statsReq, id)
 		if err != nil {
@@ -74,63 +78,66 @@
 		}
 		client.SendMessage(response)
 
-	case 5:
+	case ofp.OFPSTQueue:
 		statsReq := request.(*ofp.QueueStatsRequest)
 		response, err := handleQueueStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 6:
+	case ofp.OFPSTGroup:
 		statsReq := request.(*ofp.GroupStatsRequest)
 		response, err := handleGroupStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
+
 		client.SendMessage(response)
-	case 7:
+	case ofp.OFPSTGroupDesc:
 		statsReq := request.(*ofp.GroupDescStatsRequest)
 		response, err := handleGroupStatsDescRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 8:
+
+	case ofp.OFPSTGroupFeatures:
 		statsReq := request.(*ofp.GroupFeaturesStatsRequest)
 		response, err := handleGroupFeatureStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 9:
+	case ofp.OFPSTMeter:
 		statsReq := request.(*ofp.MeterStatsRequest)
 		response, err := handleMeterStatsRequest(statsReq, id)
 		if err != nil {
+			log.Printf("ERROR HANDLE METER STATS REQUEST %v", err)
 			return err
 		}
 		client.SendMessage(response)
-	case 10:
+	case ofp.OFPSTMeterConfig:
 		statsReq := request.(*ofp.MeterConfigStatsRequest)
 		response, err := handleMeterConfigStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 11:
+	case ofp.OFPSTMeterFeatures:
 		statsReq := request.(*ofp.MeterFeaturesStatsRequest)
 		response, err := handleMeterFeatureStatsRequest(statsReq)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 12:
+	case ofp.OFPSTTableFeatures:
 		statsReq := request.(*ofp.TableFeaturesStatsRequest)
 		response, err := handleTableFeaturesStatsRequest(statsReq, id)
 		if err != nil {
 			return err
 		}
 		client.SendMessage(response)
-	case 13:
+	case ofp.OFPSTPortDesc:
 		statsReq := request.(*ofp.PortDescStatsRequest)
 		response, err := handlePortDescStatsRequest(statsReq, deviceId)
 		if err != nil {
@@ -138,7 +145,7 @@
 		}
 		client.SendMessage(response)
 
-	case 65535:
+	case ofp.OFPSTExperimenter:
 		statsReq := request.(*ofp.ExperimenterStatsRequest)
 		response, err := handleExperimenterStatsRequest(statsReq, id)
 		if err != nil {
@@ -153,6 +160,8 @@
 	response := ofp.NewDescStatsReply()
 	response.SetXid(request.GetXid())
 	response.SetVersion(request.GetVersion())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+
 	client := *getGrpcClient()
 	resp, err := client.GetLogicalDevice(context.Background(), &id)
 	if err != nil {
@@ -165,33 +174,30 @@
 	response.SetSwDesc(PadString(desc.GetSwDesc(), 256))
 	response.SetSerialNum(PadString(desc.GetSerialNum(), 32))
 	response.SetDpDesc(PadString(desc.GetDpDesc(), 256))
-	//jsonRes,_ := json.Marshal(response)
-	//log.Printf("handleDescStatsRequest response : %s",jsonRes)
 	return response, nil
 }
 func handleFlowStatsRequest(request *ofp.FlowStatsRequest, id common.ID) (*ofp.FlowStatsReply, error) {
 	log.Println("****************************************\n***********************************")
 	response := ofp.NewFlowStatsReply()
 	response.SetXid(request.GetXid())
-	response.SetVersion(request.GetVersion())
+	response.SetVersion(4)
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	client := *getGrpcClient()
 	resp, err := client.ListLogicalDeviceFlows(context.Background(), &id)
 	if err != nil {
-		log.Println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 		log.Printf("err in handleFlowStatsRequest calling ListLogicalDeviceFlows %v", err)
 		return nil, err
 	}
-	log.Println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-	js, _ := json.Marshal(resp.GetItems())
-	log.Printf("||||||||||||||||||||||||||||||||||||HandFlowStat %s|||||||||||||||||||||||||||||||||||||||||", js)
+	js, _ := json.Marshal(resp)
+	log.Printf("HandleFlowStats response: %s", js)
 	var flow []*ofp.FlowStatsEntry
 	items := resp.GetItems()
 
 	for i := 0; i < len(items); i++ {
-		item := items[1]
-		var entry ofp.FlowStatsEntry
+		item := items[i]
+		entry := ofp.NewFlowStatsEntry()
 
-		entry.SetTableId(uint8(item.GetId()))
+		entry.SetTableId(uint8(item.GetTableId()))
 		entry.SetDurationSec(item.GetDurationSec())
 		entry.SetDurationNsec(item.GetDurationNsec())
 		entry.SetPriority(uint16(item.GetPriority()))
@@ -201,86 +207,55 @@
 		entry.SetCookie(item.GetCookie())
 		entry.SetPacketCount(item.GetPacketCount())
 		entry.SetByteCount(item.GetByteCount())
-		var match ofp.Match
+		var entrySize uint16
+		entrySize = 48
+		match := ofp.NewMatchV3()
 		pbMatch := item.GetMatch()
-
 		var fields []goloxi.IOxm
 		match.SetType(uint16(pbMatch.GetType()))
 		oxFields := pbMatch.GetOxmFields()
+		var size uint16
+		size = 4
 		for i := 0; i < len(oxFields); i++ {
-			js, _ := json.Marshal(oxFields[i])
-			log.Printf("oxfields %s", js)
 			oxmField := oxFields[i]
 			field := oxmField.GetField()
 			ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
-			switch ofbField.Type {
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
-				ofpInPort := ofp.NewOxmInPort()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_Port)
-				ofpInPort.Value = ofp.Port(val.Port)
-				fields = append(fields, ofpInPort)
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
-				ofpInPhyPort := ofp.NewOxmInPhyPort()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
-				ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
-				fields = append(fields, ofpInPhyPort)
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
-				ofpIpProto := ofp.NewOxmIpProto()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_IpProto)
-				ofpIpProto.Value = ofp.IpPrototype(val.IpProto)
-				fields = append(fields, ofpIpProto)
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
-				ofpUdpSrc := ofp.NewOxmUdpSrc()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpSrc)
-				ofpUdpSrc.Value = uint16(val.UdpSrc)
-				fields = append(fields, ofpUdpSrc)
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
-				ofpUdpDst := ofp.NewOxmUdpSrc()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
-				ofpUdpDst.Value = uint16(val.UdpDst)
-				fields = append(fields, ofpUdpDst)
-			case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
-				ofpVlanVid := ofp.NewOxmVlanVid()
-				val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_VlanVid)
-				ofpVlanVid.Value = uint16(val.VlanVid)
-				fields = append(fields, ofpVlanVid)
-			default:
-				log.Printf("handleFlowStatsRequest   Unhandled OxmField %v", ofbField.Type)
+			iOxm, oxmSize := parseOxm(ofbField)
+			log.Printf("OXMSIZE %d", oxmSize)
+			fields = append(fields, iOxm)
+			if oxmSize > 0 {
+				size += 4 //header for oxm
 			}
-
+			size += oxmSize
+			log.Printf("SIZE %d", size)
 		}
+
+		log.Printf("entrySize %d += size %d", entrySize, size)
+		log.Printf("new entrySize %d", entrySize)
 		match.OxmList = fields
-		match.Length = uint16(unsafe.Sizeof(match))
-		entry.SetMatch(match)
+		match.Length = uint16(size)
+		//account for 8 byte alignment
+		log.Printf("Size was %d", size)
+		if size%8 != 0 {
+			size = ((size / 8) + 1) * 8
+		}
+		log.Printf("Size is %d", size)
+		entrySize += size
+		entry.SetMatch(*match)
 		var instructions []ofp.IInstruction
 		ofpInstructions := item.Instructions
 		for i := 0; i < len(ofpInstructions); i++ {
-			ofpInstruction := ofpInstructions[i]
-			instType := ofpInstruction.Type
-			switch instType {
-			case uint32(openflow_13.OfpInstructionType_OFPIT_APPLY_ACTIONS):
-				ofpActions := ofpInstruction.GetActions().Actions
-				for i := 0; i < len(ofpActions); i++ {
-					ofpAction := ofpActions[i]
-					var actions []*ofp.Action
-					switch ofpAction.Type {
-					case openflow_13.OfpActionType_OFPAT_OUTPUT:
-						ofpOutputAction := ofpAction.GetOutput()
-						outputAction := ofp.NewActionOutput()
-						outputAction.Port = ofp.Port(ofpOutputAction.Port)
-						outputAction.MaxLen = uint16(ofpOutputAction.MaxLen)
-						actions = append(actions, outputAction.Action)
-					}
-				}
-				instruction := ofp.NewInstruction(uint16(instType))
-				instructions = append(instructions, instruction)
-			}
-
+			instruction, size := parseInstructions(ofpInstructions[i])
+			instructions = append(instructions, instruction)
+			entrySize += size
 		}
 		entry.Instructions = instructions
-		entry.Length = uint16(unsafe.Sizeof(entry))
-		flow = append(flow, &entry)
-
+		log.Printf("entrysize was %d", entrySize)
+		entrySizeMeasured := uint16(unsafe.Sizeof(*entry))
+		log.Printf("entrysize measure %d", entrySizeMeasured)
+		entry.Length = entrySize
+		entrySize = 0
+		flow = append(flow, entry)
 	}
 	response.SetEntries(flow)
 	return response, nil
@@ -289,6 +264,7 @@
 	response := ofp.NewAggregateStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	response.SetFlowCount(0)
 	//TODO wire this to voltha core when it implements
 	return response, nil
@@ -297,6 +273,7 @@
 	response := ofp.NewGroupStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	client := *getGrpcClient()
 	reply, err := client.ListLogicalDeviceFlowGroups(context.Background(), &id)
 	if err != nil {
@@ -333,6 +310,7 @@
 	response := ofp.NewGroupDescStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	client := *getGrpcClient()
 	reply, err := client.ListLogicalDeviceFlowGroups(context.Background(), &id)
 	if err != nil {
@@ -362,6 +340,7 @@
 	response := ofp.NewGroupFeaturesStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	//TODO wire this to voltha core when it implements
 	return response, nil
 }
@@ -369,38 +348,70 @@
 	response := ofp.NewMeterStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
-	//TODO wire this to voltha core when it implements
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+	client := *getGrpcClient()
+	resp, err := client.ListLogicalDeviceMeters(context.Background(), &id)
+	if err != nil {
+		return nil, err
+	}
+	size := uint16(40)
+	items := resp.Items
+	var meterStats []*ofp.MeterStats
+	for i := 0; i < len(items); i++ {
+		meterStat := ofp.NewMeterStats()
+		item := items[i]
+		stats := item.Stats
+		meterStat.DurationNsec = stats.DurationNsec
+		meterStat.DurationSec = stats.DurationSec
+		meterStat.ByteInCount = stats.ByteInCount
+		meterStat.FlowCount = stats.FlowCount
+		meterStat.MeterId = stats.MeterId
+		var bandStats []*ofp.MeterBandStats
+		bStats := stats.BandStats
+		for j := 0; j < len(bStats); j++ {
+			bStat := bStats[j]
+			bandStat := ofp.NewMeterBandStats()
+			bandStat.ByteBandCount = bStat.ByteBandCount
+			bandStat.PacketBandCount = bStat.PacketBandCount
+			bandStats = append(bandStats, bandStat)
+			size += 16
+		}
+		meterStat.SetBandStats(bandStats)
+		meterStat.Len = size
+		meterStats = append(meterStats, meterStat)
+	}
+	response.SetEntries(meterStats)
 	return response, nil
 }
-
-//statsReq := request.(*ofp.MeterConfigStatsRequest)
 func handleMeterConfigStatsRequest(request *ofp.MeterConfigStatsRequest, id common.ID) (*ofp.MeterConfigStatsReply, error) {
 	response := ofp.NewMeterConfigStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	//TODO wire this to voltha core when it implements
 	return response, nil
 }
-
-//statsReq := request.(*ofp.TableFeaturesStatsRequest)
 func handleTableFeaturesStatsRequest(request *ofp.TableFeaturesStatsRequest, id common.ID) (*ofp.TableFeaturesStatsReply, error) {
 	response := ofp.NewTableFeaturesStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	//TODO wire this to voltha core when it implements
 	return response, nil
 }
 func handleTableStatsRequest(request *ofp.TableStatsRequest, id common.ID) (*ofp.TableStatsReply, error) {
-	var tableStatsReply = ofp.NewTableStatsReply()
-	tableStatsReply.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
-	tableStatsReply.SetVersion(request.GetVersion())
-	tableStatsReply.SetXid(request.GetXid())
-	return tableStatsReply, nil
+	var response = ofp.NewTableStatsReply()
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+	response.SetVersion(request.GetVersion())
+	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+	return response, nil
 }
 func handleQueueStatsRequest(request *ofp.QueueStatsRequest, id common.ID) (*ofp.QueueStatsReply, error) {
 	response := ofp.NewQueueStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	//TODO wire this to voltha core when it implements
 	return response, nil
 }
@@ -409,7 +420,7 @@
 	response := ofp.NewPortStatsReply()
 	response.SetXid(request.GetXid())
 	response.SetVersion(request.GetVersion())
-	//response.SetFlags(ofp.flagsrequest.GetFlags())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	client := *getGrpcClient()
 	reply, err := client.ListLogicalDevicePorts(context.Background(), &id)
 	//reply,err := client.GetLogicalDevicePort(context.Background(),&id)
@@ -441,30 +452,12 @@
 	return response, nil
 
 }
-func parsePortStats(port *pb.LogicalPort) ofp.PortStatsEntry {
-	stats := port.OfpPortStats
-	var entry ofp.PortStatsEntry
-	entry.SetPortNo(ofp.Port(stats.GetPortNo()))
-	entry.SetRxPackets(stats.GetRxPackets())
-	entry.SetTxPackets(stats.GetTxPackets())
-	entry.SetRxBytes(stats.GetRxBytes())
-	entry.SetTxBytes(stats.GetTxBytes())
-	entry.SetRxDropped(stats.GetRxDropped())
-	entry.SetTxDropped(stats.GetTxDropped())
-	entry.SetRxErrors(stats.GetRxErrors())
-	entry.SetTxErrors(stats.GetTxErrors())
-	entry.SetRxFrameErr(stats.GetRxFrameErr())
-	entry.SetRxOverErr(stats.GetRxOverErr())
-	entry.SetRxCrcErr(stats.GetRxCrcErr())
-	entry.SetCollisions(stats.GetCollisions())
-	entry.SetDurationSec(stats.GetDurationSec())
-	entry.SetDurationNsec(stats.GetDurationNsec())
-	return entry
-}
+
 func handlePortDescStatsRequest(request *ofp.PortDescStatsRequest, deviceId string) (*ofp.PortDescStatsReply, error) {
 	response := ofp.NewPortDescStatsReply()
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	var grpcClient = *getGrpcClient()
 	var id = common.ID{Id: deviceId}
 	logicalDevice, err := grpcClient.GetLogicalDevice(context.Background(), &id)
@@ -507,12 +500,21 @@
 	response := ofp.NewMeterFeaturesStatsReply()
 	response.SetXid(request.GetXid())
 	response.SetVersion(request.GetVersion())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+	meterFeatures := ofp.NewMeterFeatures()
+	meterFeatures.Capabilities = ofp.OFPMFKbps
+	meterFeatures.BandTypes = ofp.OFPMBTDrop
+	meterFeatures.MaxMeter = 0xffffffff
+	meterFeatures.MaxBands = 0xff
+	meterFeatures.MaxColor = 0xff
+	response.Features = *meterFeatures
 	return response, nil
 }
 func handleExperimenterStatsRequest(request *ofp.ExperimenterStatsRequest, id common.ID) (*ofp.ExperimenterStatsReply, error) {
 	response := ofp.NewExperimenterStatsReply(request.GetExperimenter())
 	response.SetVersion(request.GetVersion())
 	response.SetXid(request.GetXid())
+	response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
 	//TODO wire this to voltha core when it implements
 	return response, nil
 }
diff --git a/openflow/utils.go b/openflow/utils.go
index 160b2ab..aba7400 100644
--- a/openflow/utils.go
+++ b/openflow/utils.go
@@ -17,9 +17,14 @@
 package openflow
 
 import (
+	"encoding/json"
 	"fmt"
+	"log"
 	"strings"
 	"sync"
+
+	ofp "github.com/donNewtonAlpha/goloxi/of13"
+	"github.com/opencord/voltha-protos/go/openflow_13"
 )
 
 var mu sync.Mutex
@@ -38,3 +43,73 @@
 	padded := strings.Repeat(null, nullsNeeded)
 	return fmt.Sprintf("%s%s", value, padded)
 }
+
+func extractAction(action ofp.IAction) *openflow_13.OfpAction {
+	var ofpAction openflow_13.OfpAction
+	switch action.GetType() {
+	case ofp.OFPATOutput:
+		var outputAction openflow_13.OfpAction_Output
+		loxiOutputAction := action.(*ofp.ActionOutput)
+		var output openflow_13.OfpActionOutput
+		output.Port = uint32(loxiOutputAction.Port)
+		output.MaxLen = uint32(loxiOutputAction.MaxLen)
+		outputAction.Output = &output
+		ofpAction.Action = &outputAction
+		ofpAction.Type = openflow_13.OfpActionType_OFPAT_OUTPUT
+	case ofp.OFPATCopyTtlOut: //CopyTtltOut
+	case ofp.OFPATCopyTtlIn: //CopyTtlIn
+	case ofp.OFPATSetMplsTtl: //SetMplsTtl
+	case ofp.OFPATDecMplsTtl: //DecMplsTtl
+	case ofp.OFPATPushVLAN: //PushVlan
+		var pushVlan openflow_13.OfpAction_Push
+		loxiPushAction := action.(*ofp.ActionPushVlan)
+		fields := loxiPushAction.GetActionFields()
+		fieldsJS, _ := json.Marshal(fields)
+		log.Printf("\n\nPushVlan fields %s\n\n", fieldsJS)
+		var push openflow_13.OfpActionPush
+		push.Ethertype = uint32(loxiPushAction.Ethertype) //TODO This should be available in the fields
+		pushVlan.Push = &push
+		ofpAction.Type = openflow_13.OfpActionType_OFPAT_PUSH_VLAN
+		ofpAction.Action = &pushVlan
+	case ofp.OFPATPopVLAN: //PopVlan
+		ofpAction.Type = openflow_13.OfpActionType_OFPAT_POP_VLAN
+	case ofp.OFPATPushMpls: //PushMpls
+	case ofp.OFPATPopMpls: //PopMpls
+	case ofp.OFPATSetQueue: //SetQueue
+	case ofp.OFPATGroup: //ActionGroup
+	case ofp.OFPATSetNwTtl: //SetNwTtl
+	case ofp.OFPATDecNwTtl: //DecNwTtl
+	case ofp.OFPATSetField: //SetField
+		ofpAction.Type = openflow_13.OfpActionType_OFPAT_SET_FIELD
+		var ofpAction_SetField openflow_13.OfpAction_SetField
+		var ofpActionSetField openflow_13.OfpActionSetField
+		var ofpOxmField openflow_13.OfpOxmField
+		ofpOxmField.OxmClass = openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+		var ofpOxmField_OfbField openflow_13.OfpOxmField_OfbField
+		var ofpOxmOfbField openflow_13.OfpOxmOfbField
+		loxiSetField := action.(*ofp.ActionSetField)
+		oxmName := loxiSetField.Field.GetOXMName()
+		switch oxmName {
+		case "vlan_vid":
+			ofpOxmOfbField.Type = openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID
+			var vlanVid openflow_13.OfpOxmOfbField_VlanVid
+			var VlanVid = loxiSetField.Field.GetOXMValue().(uint16)
+			vlanVid.VlanVid = uint32(VlanVid)
+
+			ofpOxmOfbField.Value = &vlanVid
+		default:
+			log.Printf("UNHANDLED SET FIELD %s", oxmName)
+		}
+		ofpOxmField_OfbField.OfbField = &ofpOxmOfbField
+		ofpOxmField.Field = &ofpOxmField_OfbField
+		ofpActionSetField.Field = &ofpOxmField
+		ofpAction_SetField.SetField = &ofpActionSetField
+		ofpAction.Action = &ofpAction_SetField
+	case ofp.OFPATPushPbb: //PushPbb
+	case ofp.OFPATPopPbb: //PopPbb
+	case ofp.OFPATExperimenter: //Experimenter
+
+	}
+	return &ofpAction
+
+}