David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 1 | /* |
| 2 | Copyright 2020 the original author or authors. |
| 3 | |
| 4 | Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | you may not use this file except in compliance with the License. |
| 6 | You may obtain a copy of the License at |
| 7 | |
| 8 | http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | |
| 10 | Unless required by applicable law or agreed to in writing, software |
| 11 | distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | See the License for the specific language governing permissions and |
| 14 | limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package openflow |
| 18 | |
| 19 | import ( |
| 20 | "context" |
Andrea Campanella | 3034262 | 2020-03-05 20:48:26 +0100 | [diff] [blame] | 21 | "encoding/binary" |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 22 | "encoding/json" |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 23 | "net" |
David K. Bainbridge | e05cf0c | 2021-08-19 03:16:50 +0000 | [diff] [blame] | 24 | |
| 25 | ofp "github.com/opencord/goloxi/of13" |
| 26 | "github.com/opencord/voltha-lib-go/v7/pkg/log" |
| 27 | "github.com/opencord/voltha-protos/v5/go/openflow_13" |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 28 | ) |
| 29 | |
| 30 | var oxmMap = map[string]int32{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 31 | "in_port": 0, |
| 32 | "in_phy_port": 1, |
| 33 | "metadata": 2, |
| 34 | "eth_dst": 3, |
| 35 | "eth_src": 4, |
| 36 | "eth_type": 5, |
| 37 | "vlan_vid": 6, |
| 38 | "vlan_pcp": 7, |
| 39 | "ip_dscp": 8, |
| 40 | "ip_ecn": 9, |
| 41 | "ip_proto": 10, |
| 42 | "ipv4_src": 11, |
| 43 | "ipv4_dst": 12, |
| 44 | "tcp_src": 13, |
| 45 | "tcp_dst": 14, |
| 46 | "udp_src": 15, |
| 47 | "udp_dst": 16, |
| 48 | "sctp_src": 17, |
| 49 | "sctp_dst": 18, |
| 50 | "icmpv4_type": 19, |
| 51 | "icmpv4_code": 20, |
| 52 | "arp_op": 21, |
| 53 | "arp_spa": 22, |
| 54 | "arp_tpa": 23, |
| 55 | "arp_sha": 24, |
| 56 | "arp_tha": 25, |
| 57 | "ipv6_src": 26, |
| 58 | "ipv6_dst": 27, |
| 59 | "ipv6_flabel": 28, |
| 60 | "icmpv6_type": 29, |
| 61 | "icmpv6_code": 30, |
| 62 | "ipv6_nd_target": 31, |
| 63 | "ipv6_nd_sll": 32, |
| 64 | "ipv6_nd_tll": 33, |
| 65 | "mpls_label": 34, |
| 66 | "mpls_tc": 35, |
| 67 | "mpls_bos": 36, |
| 68 | "pbb_isid": 37, |
| 69 | "tunnel_id": 38, |
| 70 | "ipv6_exthdr": 39, |
| 71 | "vlan_vid_masked": 200, //made up |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 72 | } |
| 73 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 74 | func (ofc *OFConnection) handleFlowAdd(ctx context.Context, flowAdd *ofp.FlowAdd) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 75 | span, ctx := log.CreateChildSpan(ctx, "openflow-flow-add") |
| 76 | defer span.Finish() |
| 77 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 78 | if logger.V(log.DebugLevel) { |
| 79 | js, _ := json.Marshal(flowAdd) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 80 | logger.Debugw(ctx, "handleFlowAdd called", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 81 | log.Fields{ |
| 82 | "device-id": ofc.DeviceID, |
| 83 | "params": js}) |
| 84 | } |
| 85 | |
David Bainbridge | f8ce7d2 | 2020-04-08 12:49:41 -0700 | [diff] [blame] | 86 | volthaClient := ofc.VolthaClient.Get() |
| 87 | if volthaClient == nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 88 | logger.Errorw(ctx, "no-voltha-connection", |
David K. Bainbridge | 9cb404e | 2020-01-28 14:32:29 -0800 | [diff] [blame] | 89 | log.Fields{"device-id": ofc.DeviceID}) |
| 90 | return |
| 91 | } |
| 92 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 93 | // Construct the match |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 94 | var oxmList []*openflow_13.OfpOxmField |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 95 | for _, oxmField := range flowAdd.Match.GetOxmList() { |
| 96 | name := oxmMap[oxmField.GetOXMName()] |
| 97 | val := oxmField.GetOXMValue() |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 98 | field := openflow_13.OfpOxmOfbField{Type: openflow_13.OxmOfbFieldTypes(name)} |
| 99 | ofpOxmField := openflow_13.OfpOxmField{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 100 | OxmClass: ofp.OFPXMCOpenflowBasic, |
| 101 | Field: &openflow_13.OfpOxmField_OfbField{OfbField: &field}, |
| 102 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 103 | switch openflow_13.OxmOfbFieldTypes(name) { |
| 104 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT: |
| 105 | field.Value = &openflow_13.OfpOxmOfbField_Port{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 106 | Port: uint32(val.(ofp.Port)), |
| 107 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 108 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT: |
| 109 | field.Value = &openflow_13.OfpOxmOfbField_PhysicalPort{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 110 | PhysicalPort: val.(uint32), |
| 111 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 112 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_METADATA: |
| 113 | field.Value = &openflow_13.OfpOxmOfbField_TableMetadata{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 114 | TableMetadata: val.(uint64), |
| 115 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 116 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE: |
| 117 | field.Value = &openflow_13.OfpOxmOfbField_EthType{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 118 | EthType: uint32(val.(ofp.EthernetType)), |
| 119 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 120 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO: |
| 121 | field.Value = &openflow_13.OfpOxmOfbField_IpProto{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 122 | IpProto: uint32(val.(ofp.IpPrototype)), |
| 123 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 124 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST: |
| 125 | field.Value = &openflow_13.OfpOxmOfbField_Ipv4Dst{ |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 126 | Ipv4Dst: binary.BigEndian.Uint32(val.(net.IP)), |
| 127 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 128 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST: |
| 129 | field.Value = &openflow_13.OfpOxmOfbField_EthDst{ |
Gamze Abaka | 3e2b2ce | 2020-05-09 10:21:40 +0000 | [diff] [blame] | 130 | EthDst: val.(net.HardwareAddr), |
| 131 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 132 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC: |
| 133 | field.Value = &openflow_13.OfpOxmOfbField_EthSrc{ |
ssiddiqui | df20bf7 | 2021-08-23 14:00:56 +0530 | [diff] [blame] | 134 | EthSrc: val.(net.HardwareAddr), |
| 135 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 136 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC: |
| 137 | field.Value = &openflow_13.OfpOxmOfbField_UdpSrc{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 138 | UdpSrc: uint32(val.(uint16)), |
| 139 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 140 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST: |
| 141 | field.Value = &openflow_13.OfpOxmOfbField_UdpDst{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 142 | UdpDst: uint32(val.(uint16)), |
| 143 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 144 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID: |
| 145 | field.Value = &openflow_13.OfpOxmOfbField_VlanVid{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 146 | VlanVid: uint32((val.(uint16) & 0xfff) | 0x1000), |
| 147 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 148 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP: |
| 149 | field.Value = &openflow_13.OfpOxmOfbField_VlanPcp{ |
Gamze Abaka | 3e2b2ce | 2020-05-09 10:21:40 +0000 | [diff] [blame] | 150 | VlanPcp: uint32(val.(uint8)), |
| 151 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 152 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL: |
| 153 | field.Value = &openflow_13.OfpOxmOfbField_MplsLabel{ |
ssiddiqui | df20bf7 | 2021-08-23 14:00:56 +0530 | [diff] [blame] | 154 | MplsLabel: val.(uint32), |
| 155 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 156 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS: |
| 157 | field.Value = &openflow_13.OfpOxmOfbField_MplsBos{ |
ssiddiqui | df20bf7 | 2021-08-23 14:00:56 +0530 | [diff] [blame] | 158 | MplsBos: uint32(val.(uint8)), |
| 159 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 160 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC: |
| 161 | field.Value = &openflow_13.OfpOxmOfbField_MplsTc{ |
ssiddiqui | df20bf7 | 2021-08-23 14:00:56 +0530 | [diff] [blame] | 162 | MplsTc: val.(uint32), |
| 163 | } |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 164 | case 200: // voltha-protos doesn't actually have a type for vlan_mask |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 165 | field = openflow_13.OfpOxmOfbField{Type: openflow_13.OxmOfbFieldTypes(oxmMap["vlan_vid"])} |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 166 | field.HasMask = true |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 167 | ofpOxmField = openflow_13.OfpOxmField{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 168 | OxmClass: ofp.OFPXMCOpenflowBasic, |
| 169 | Field: &openflow_13.OfpOxmField_OfbField{OfbField: &field}, |
| 170 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 171 | field.Value = &openflow_13.OfpOxmOfbField_VlanVid{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 172 | VlanVid: uint32(val.(uint16)), |
| 173 | } |
| 174 | vidMask := val.(uint16) |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 175 | field.Mask = &openflow_13.OfpOxmOfbField_VlanVidMask{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 176 | VlanVidMask: uint32(vidMask), |
| 177 | } |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 178 | } |
| 179 | oxmList = append(oxmList, &ofpOxmField) |
| 180 | } |
| 181 | |
| 182 | // Construct the instructions |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 183 | var instructions []*openflow_13.OfpInstruction |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 184 | for _, ofpInstruction := range flowAdd.GetInstructions() { |
| 185 | instructionType := ofpInstruction.GetType() |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 186 | instruction := openflow_13.OfpInstruction{Type: uint32(instructionType)} |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 187 | switch instructionType { |
| 188 | case ofp.OFPITGotoTable: |
| 189 | instruction.Data = &openflow_13.OfpInstruction_GotoTable{ |
| 190 | GotoTable: &openflow_13.OfpInstructionGotoTable{ |
| 191 | TableId: uint32(ofpInstruction.(ofp.IInstructionGotoTable).GetTableId()), |
| 192 | }, |
| 193 | } |
| 194 | case ofp.OFPITWriteMetadata: |
| 195 | instruction.Data = &openflow_13.OfpInstruction_WriteMetadata{ |
| 196 | WriteMetadata: &openflow_13.OfpInstructionWriteMetadata{ |
| 197 | Metadata: ofpInstruction.(ofp.IInstructionWriteMetadata).GetMetadata(), |
| 198 | MetadataMask: ofpInstruction.(ofp.IInstructionWriteMetadata).GetMetadataMask(), |
| 199 | }, |
| 200 | } |
| 201 | case ofp.OFPITWriteActions: |
| 202 | var ofpActions []*openflow_13.OfpAction |
| 203 | for _, action := range ofpInstruction.(ofp.IInstructionWriteActions).GetActions() { |
| 204 | ofpActions = append(ofpActions, extractAction(action)) |
| 205 | } |
| 206 | instruction.Data = &openflow_13.OfpInstruction_Actions{ |
| 207 | Actions: &openflow_13.OfpInstructionActions{ |
| 208 | Actions: ofpActions, |
| 209 | }, |
| 210 | } |
| 211 | case ofp.OFPITApplyActions: |
| 212 | var ofpActions []*openflow_13.OfpAction |
| 213 | for _, action := range ofpInstruction.(ofp.IInstructionApplyActions).GetActions() { |
| 214 | ofpActions = append(ofpActions, extractAction(action)) |
| 215 | } |
| 216 | instruction.Data = &openflow_13.OfpInstruction_Actions{ |
| 217 | Actions: &openflow_13.OfpInstructionActions{ |
| 218 | Actions: ofpActions, |
| 219 | }, |
| 220 | } |
| 221 | case ofp.OFPITMeter: |
| 222 | instruction.Data = &openflow_13.OfpInstruction_Meter{ |
| 223 | Meter: &openflow_13.OfpInstructionMeter{ |
| 224 | MeterId: ofpInstruction.(ofp.IInstructionMeter).GetMeterId(), |
| 225 | }, |
| 226 | } |
| 227 | } |
| 228 | instructions = append(instructions, &instruction) |
| 229 | } |
| 230 | |
| 231 | // Construct the request |
| 232 | flowUpdate := openflow_13.FlowTableUpdate{ |
| 233 | Id: ofc.DeviceID, |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 234 | FlowMod: &openflow_13.OfpFlowMod{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 235 | Cookie: flowAdd.Cookie, |
| 236 | CookieMask: flowAdd.CookieMask, |
| 237 | TableId: uint32(flowAdd.TableId), |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 238 | Command: openflow_13.OfpFlowModCommand_OFPFC_ADD, |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 239 | IdleTimeout: uint32(flowAdd.IdleTimeout), |
| 240 | HardTimeout: uint32(flowAdd.HardTimeout), |
| 241 | Priority: uint32(flowAdd.Priority), |
| 242 | BufferId: flowAdd.BufferId, |
| 243 | OutPort: uint32(flowAdd.OutPort), |
| 244 | OutGroup: uint32(flowAdd.OutGroup), |
| 245 | Flags: uint32(flowAdd.Flags), |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 246 | Match: &openflow_13.OfpMatch{ |
| 247 | Type: openflow_13.OfpMatchType(flowAdd.Match.GetType()), |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 248 | OxmFields: oxmList, |
| 249 | }, |
| 250 | |
| 251 | Instructions: instructions, |
| 252 | }, |
Maninder | e2af7e4 | 2020-12-04 11:46:26 +0530 | [diff] [blame] | 253 | Xid: flowAdd.Xid, |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 254 | } |
| 255 | if logger.V(log.DebugLevel) { |
David K. Bainbridge | e05cf0c | 2021-08-19 03:16:50 +0000 | [diff] [blame] | 256 | logger.Debugw(ctx, "FlowAdd being sent to Voltha", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 257 | log.Fields{ |
David K. Bainbridge | e05cf0c | 2021-08-19 03:16:50 +0000 | [diff] [blame] | 258 | "device-id": ofc.DeviceID, |
| 259 | "flow-mod-object": flowUpdate, |
| 260 | }) |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 261 | } |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 262 | if _, err := volthaClient.UpdateLogicalDeviceFlowTable(log.WithSpanFromContext(context.Background(), ctx), &flowUpdate); err != nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 263 | logger.Errorw(ctx, "Error calling FlowAdd ", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 264 | log.Fields{ |
| 265 | "device-id": ofc.DeviceID, |
| 266 | "error": err}) |
Andrea Campanella | 3034262 | 2020-03-05 20:48:26 +0100 | [diff] [blame] | 267 | // Report failure to controller |
| 268 | message := ofp.NewFlowModFailedErrorMsg() |
| 269 | message.SetXid(flowAdd.Xid) |
| 270 | message.SetCode(ofp.OFPFMFCBadCommand) |
| 271 | //OF 1.3 |
| 272 | message.SetVersion(4) |
| 273 | bs := make([]byte, 2) |
| 274 | //OF 1.3 |
| 275 | bs[0] = byte(4) |
| 276 | //Flow Mod |
| 277 | bs[1] = byte(14) |
| 278 | //Length of the message |
| 279 | length := make([]byte, 2) |
| 280 | binary.BigEndian.PutUint16(length, 56) |
| 281 | bs = append(bs, length...) |
| 282 | empty := []byte{0, 0, 0, 0} |
| 283 | bs = append(bs, empty...) |
| 284 | //Cookie of the Flow |
| 285 | cookie := make([]byte, 52) |
| 286 | binary.BigEndian.PutUint64(cookie, flowAdd.Cookie) |
| 287 | bs = append(bs, cookie...) |
| 288 | message.SetData(bs) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 289 | err := ofc.SendMessage(ctx, message) |
Andrea Campanella | 3034262 | 2020-03-05 20:48:26 +0100 | [diff] [blame] | 290 | if err != nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 291 | logger.Errorw(ctx, "Error reporting failure of FlowUpdate to controller", |
Andrea Campanella | 3034262 | 2020-03-05 20:48:26 +0100 | [diff] [blame] | 292 | log.Fields{ |
| 293 | "device-id": ofc.DeviceID, |
| 294 | "error": err}) |
| 295 | } |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 296 | } |
| 297 | } |
| 298 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 299 | func (ofc *OFConnection) handleFlowMod(ctx context.Context, flowMod *ofp.FlowMod) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 300 | span, ctx := log.CreateChildSpan(ctx, "openflow-flow-modification") |
| 301 | defer span.Finish() |
| 302 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 303 | if logger.V(log.DebugLevel) { |
| 304 | js, _ := json.Marshal(flowMod) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 305 | logger.Debugw(ctx, "handleFlowMod called", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 306 | log.Fields{ |
| 307 | "device-id": ofc.DeviceID, |
| 308 | "flow-mod": js}) |
| 309 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 310 | logger.Errorw(ctx, "handleFlowMod not implemented", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 311 | log.Fields{"device-id": ofc.DeviceID}) |
| 312 | } |
| 313 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 314 | func (ofc *OFConnection) handleFlowModStrict(ctx context.Context, flowModStrict *ofp.FlowModifyStrict) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 315 | span, ctx := log.CreateChildSpan(ctx, "openflow-flow-modification-strict") |
| 316 | defer span.Finish() |
| 317 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 318 | if logger.V(log.DebugLevel) { |
| 319 | js, _ := json.Marshal(flowModStrict) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 320 | logger.Debugw(ctx, "handleFlowModStrict called", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 321 | log.Fields{ |
| 322 | "device-id": ofc.DeviceID, |
| 323 | "flow-mod-strict": js}) |
| 324 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 325 | logger.Error(ctx, "handleFlowModStrict not implemented", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 326 | log.Fields{"device-id": ofc.DeviceID}) |
| 327 | } |
| 328 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 329 | func (ofc *OFConnection) handleFlowDelete(ctx context.Context, flowDelete *ofp.FlowDelete) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 330 | span, ctx := log.CreateChildSpan(ctx, "openflow-flow-delete") |
| 331 | defer span.Finish() |
| 332 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 333 | if logger.V(log.DebugLevel) { |
| 334 | js, _ := json.Marshal(flowDelete) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 335 | logger.Debugw(ctx, "handleFlowDelete called", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 336 | log.Fields{ |
| 337 | "device-id": ofc.DeviceID, |
| 338 | "flow-delete": js}) |
| 339 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 340 | logger.Error(ctx, "handleFlowDelete not implemented", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 341 | log.Fields{"device-id": ofc.DeviceID}) |
| 342 | |
| 343 | } |
| 344 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 345 | func (ofc *OFConnection) handleFlowDeleteStrict(ctx context.Context, flowDeleteStrict *ofp.FlowDeleteStrict) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 346 | span, ctx := log.CreateChildSpan(ctx, "openflow-flow-delete-strict") |
| 347 | defer span.Finish() |
| 348 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 349 | if logger.V(log.DebugLevel) { |
| 350 | js, _ := json.Marshal(flowDeleteStrict) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 351 | logger.Debugw(ctx, "handleFlowDeleteStrict called", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 352 | log.Fields{ |
| 353 | "device-id": ofc.DeviceID, |
| 354 | "flow-delete-strict": js}) |
| 355 | } |
| 356 | |
David Bainbridge | f8ce7d2 | 2020-04-08 12:49:41 -0700 | [diff] [blame] | 357 | volthaClient := ofc.VolthaClient.Get() |
| 358 | if volthaClient == nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 359 | logger.Errorw(ctx, "no-voltha-connection", |
David K. Bainbridge | 9cb404e | 2020-01-28 14:32:29 -0800 | [diff] [blame] | 360 | log.Fields{"device-id": ofc.DeviceID}) |
| 361 | return |
| 362 | } |
| 363 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 364 | // Construct match |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 365 | var oxmList []*openflow_13.OfpOxmField |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 366 | for _, oxmField := range flowDeleteStrict.Match.GetOxmList() { |
| 367 | name := oxmMap[oxmField.GetOXMName()] |
| 368 | val := oxmField.GetOXMValue() |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 369 | var ofpOxmField openflow_13.OfpOxmField |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 370 | ofpOxmField.OxmClass = ofp.OFPXMCOpenflowBasic |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 371 | var field openflow_13.OfpOxmOfbField |
| 372 | field.Type = openflow_13.OxmOfbFieldTypes(name) |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 373 | |
| 374 | var x openflow_13.OfpOxmField_OfbField |
| 375 | x.OfbField = &field |
| 376 | ofpOxmField.Field = &x |
| 377 | |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 378 | switch openflow_13.OxmOfbFieldTypes(name) { |
| 379 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT: |
| 380 | field.Value = &openflow_13.OfpOxmOfbField_Port{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 381 | Port: uint32(val.(ofp.Port)), |
| 382 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 383 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT: |
| 384 | field.Value = &openflow_13.OfpOxmOfbField_PhysicalPort{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 385 | PhysicalPort: val.(uint32), |
| 386 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 387 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_METADATA: |
| 388 | field.Value = &openflow_13.OfpOxmOfbField_TableMetadata{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 389 | TableMetadata: val.(uint64), |
| 390 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 391 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE: |
| 392 | field.Value = &openflow_13.OfpOxmOfbField_EthType{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 393 | EthType: uint32(val.(ofp.EthernetType)), |
| 394 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 395 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO: |
| 396 | field.Value = &openflow_13.OfpOxmOfbField_IpProto{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 397 | IpProto: uint32(val.(ofp.IpPrototype)), |
| 398 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 399 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST: |
| 400 | field.Value = &openflow_13.OfpOxmOfbField_Ipv4Dst{ |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 401 | Ipv4Dst: binary.BigEndian.Uint32(val.(net.IP)), |
| 402 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 403 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST: |
| 404 | field.Value = &openflow_13.OfpOxmOfbField_EthDst{ |
Esin Karaman | 082a701 | 2020-06-23 15:47:02 +0000 | [diff] [blame] | 405 | EthDst: val.(net.HardwareAddr), |
| 406 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 407 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC: |
| 408 | field.Value = &openflow_13.OfpOxmOfbField_UdpSrc{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 409 | UdpSrc: uint32(val.(uint16)), |
| 410 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 411 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST: |
| 412 | field.Value = &openflow_13.OfpOxmOfbField_UdpDst{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 413 | UdpDst: uint32(val.(uint16)), |
| 414 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 415 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID: |
| 416 | field.Value = &openflow_13.OfpOxmOfbField_VlanVid{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 417 | VlanVid: uint32(val.(uint16)), |
| 418 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 419 | case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP: |
| 420 | field.Value = &openflow_13.OfpOxmOfbField_VlanPcp{ |
Esin Karaman | 082a701 | 2020-06-23 15:47:02 +0000 | [diff] [blame] | 421 | VlanPcp: uint32(val.(uint8)), |
| 422 | } |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 423 | case 200: // voltha-protos doesn't actually have a type for vlan_mask |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 424 | field = openflow_13.OfpOxmOfbField{Type: openflow_13.OxmOfbFieldTypes(oxmMap["vlan_vid"])} |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 425 | field.HasMask = true |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 426 | ofpOxmField = openflow_13.OfpOxmField{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 427 | OxmClass: ofp.OFPXMCOpenflowBasic, |
| 428 | Field: &openflow_13.OfpOxmField_OfbField{OfbField: &field}, |
| 429 | } |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 430 | field.Value = &openflow_13.OfpOxmOfbField_VlanVid{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 431 | VlanVid: uint32(val.(uint16)), |
| 432 | } |
| 433 | vidMask := val.(uint16) |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 434 | field.Mask = &openflow_13.OfpOxmOfbField_VlanVidMask{ |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 435 | VlanVidMask: uint32(vidMask), |
| 436 | } |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 437 | } |
Don Newton | 7fe70f7 | 2020-02-21 13:54:11 -0500 | [diff] [blame] | 438 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 439 | oxmList = append(oxmList, &ofpOxmField) |
| 440 | } |
| 441 | |
Matteo Scandolo | 322c308 | 2020-06-17 14:21:26 -0700 | [diff] [blame] | 442 | responseRequired := false |
| 443 | |
| 444 | if flowDeleteStrict.GetFlags() == ofp.OFPFFSendFlowRem { |
| 445 | responseRequired = true |
| 446 | } |
| 447 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 448 | // Construct request |
| 449 | flowUpdate := openflow_13.FlowTableUpdate{ |
| 450 | Id: ofc.DeviceID, |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 451 | FlowMod: &openflow_13.OfpFlowMod{ |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 452 | Cookie: flowDeleteStrict.Cookie, |
| 453 | CookieMask: flowDeleteStrict.CookieMask, |
| 454 | TableId: uint32(flowDeleteStrict.TableId), |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 455 | Command: openflow_13.OfpFlowModCommand_OFPFC_DELETE_STRICT, |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 456 | IdleTimeout: uint32(flowDeleteStrict.IdleTimeout), |
| 457 | HardTimeout: uint32(flowDeleteStrict.HardTimeout), |
| 458 | Priority: uint32(flowDeleteStrict.Priority), |
| 459 | BufferId: flowDeleteStrict.BufferId, |
| 460 | OutPort: uint32(flowDeleteStrict.OutPort), |
| 461 | OutGroup: uint32(flowDeleteStrict.OutGroup), |
| 462 | Flags: uint32(flowDeleteStrict.Flags), |
khenaidoo | fcf0b8d | 2021-10-19 17:57:30 -0400 | [diff] [blame^] | 463 | Match: &openflow_13.OfpMatch{ |
| 464 | Type: openflow_13.OfpMatchType(flowDeleteStrict.Match.GetType()), |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 465 | OxmFields: oxmList, |
| 466 | }, |
| 467 | }, |
Maninder | e2af7e4 | 2020-12-04 11:46:26 +0530 | [diff] [blame] | 468 | Xid: flowDeleteStrict.Xid, |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 469 | } |
| 470 | |
| 471 | if logger.V(log.DebugLevel) { |
| 472 | flowUpdateJs, _ := json.Marshal(flowUpdate) |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 473 | logger.Debugf(ctx, "FlowDeleteStrict being sent to Voltha", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 474 | log.Fields{ |
| 475 | "device-id": ofc.DeviceID, |
| 476 | "flow-update": flowUpdateJs}) |
| 477 | } |
Matteo Scandolo | 936e2df | 2020-10-27 14:31:36 -0700 | [diff] [blame] | 478 | |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 479 | if _, err := volthaClient.UpdateLogicalDeviceFlowTable(log.WithSpanFromContext(context.Background(), ctx), &flowUpdate); err != nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 480 | logger.Errorw(ctx, "Error calling FlowDelete ", |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 481 | log.Fields{ |
| 482 | "device-id": ofc.DeviceID, |
| 483 | "error": err}) |
Matteo Scandolo | 322c308 | 2020-06-17 14:21:26 -0700 | [diff] [blame] | 484 | return |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 485 | } |
Matteo Scandolo | 322c308 | 2020-06-17 14:21:26 -0700 | [diff] [blame] | 486 | |
| 487 | if responseRequired { |
| 488 | response := ofp.NewFlowRemoved() |
| 489 | |
| 490 | response.Cookie = flowDeleteStrict.Cookie |
| 491 | response.Priority = flowDeleteStrict.Priority |
| 492 | response.Reason = ofp.OFPRRDelete |
| 493 | response.Match = flowDeleteStrict.Match |
| 494 | response.IdleTimeout = flowDeleteStrict.IdleTimeout |
| 495 | response.HardTimeout = flowDeleteStrict.HardTimeout |
| 496 | response.Xid = flowDeleteStrict.Xid |
| 497 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 498 | err := ofc.SendMessage(ctx, response) |
Matteo Scandolo | 322c308 | 2020-06-17 14:21:26 -0700 | [diff] [blame] | 499 | if err != nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 500 | logger.Errorw(ctx, "Error sending FlowRemoved to ONOS", |
Matteo Scandolo | 322c308 | 2020-06-17 14:21:26 -0700 | [diff] [blame] | 501 | log.Fields{ |
| 502 | "device-id": ofc.DeviceID, |
| 503 | "error": err}) |
| 504 | } |
| 505 | } |
| 506 | |
David K. Bainbridge | 157bdab | 2020-01-16 14:38:05 -0800 | [diff] [blame] | 507 | } |