WIP - Suggesting changes (take2)
This is not yet completed, still working on things. Eventually the plan
is to provide the following changes
- restructure repo to be more aligned with https://github.com/golang-standards/project-layout
- add k8s probes
- modifications (golang range loops, etc) to follow some golang
practices
Change-Id: I6922cbc00b5ef17ceab183aba00a7fc59ab46480
diff --git a/.gitignore b/.gitignore
index 0186f5b..f761ff5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
ofagent-go
output
+*.swp
diff --git a/cmd/ofagent/config.go b/cmd/ofagent/config.go
new file mode 100644
index 0000000..1ced4e8
--- /dev/null
+++ b/cmd/ofagent/config.go
@@ -0,0 +1,114 @@
+/*
+ Copyright 2019 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 main
+
+import (
+ "flag"
+ "time"
+)
+
+type Config struct {
+ OFControllerEndPoint string
+ VolthaApiEndPoint string
+ LogLevel string
+ Banner bool
+ Version bool
+ ProbeEndPoint string
+ CpuProfile string
+ MemProfile string
+ DeviceListRefreshInterval time.Duration
+ ConnectionRetryDelay time.Duration
+ ConnectionMaxRetries int
+}
+
+func parseCommandLineArguments() (*Config, error) {
+ config := Config{}
+
+ flag.BoolVar(&(config.Banner),
+ "banner",
+ true,
+ "display application banner on startup")
+ flag.BoolVar(&(config.Version),
+ "version",
+ false,
+ "display application version and exit")
+ flag.StringVar(&(config.OFControllerEndPoint),
+ "controller",
+ "onos-openflow:6653",
+ "connection to the OF controller specified as host:port")
+ flag.StringVar(&(config.OFControllerEndPoint),
+ "O",
+ "onos-openflow:6653",
+ "(short) connection to the OF controller specified as host:port")
+ flag.StringVar(&(config.VolthaApiEndPoint),
+ "voltha",
+ "voltha-api-server:50060",
+ "connection to the VOLTHA API server specified as host:port")
+ flag.StringVar(&(config.VolthaApiEndPoint),
+ "A",
+ "voltha-api-server:50060",
+ "(short) connection to the VOLTHA API server specified as host:port")
+ flag.StringVar(&(config.ProbeEndPoint),
+ "probe",
+ ":8080",
+ "address and port on which to listen for k8s live and ready probe requests")
+ flag.StringVar(&(config.ProbeEndPoint),
+ "P",
+ ":8080",
+ "(short) address and port on which to listen for k8s live and ready probe requests")
+ flag.StringVar(&(config.LogLevel),
+ "loglevel",
+ "WARN",
+ "initial log level setting, overriden by any value set in configuration store")
+ flag.StringVar(&(config.LogLevel),
+ "L",
+ "WARN",
+ "(short) initial log level setting, overriden by any value set in configuration store")
+ flag.StringVar(&(config.CpuProfile),
+ "cpuprofile",
+ "",
+ "write cpu profile to 'file' if specified")
+ flag.StringVar(&(config.MemProfile),
+ "memprofile",
+ "",
+ "write memory profile to 'file' if specified")
+ flag.DurationVar(&(config.ConnectionRetryDelay),
+ "cd",
+ 3*time.Second,
+ "(short) delay to wait before connection establishment retries")
+ flag.DurationVar(&(config.ConnectionRetryDelay),
+ "connnection-delay",
+ 3*time.Second,
+ "delay to wait before connection establishment retries")
+ flag.IntVar(&(config.ConnectionMaxRetries),
+ "mr",
+ 0,
+ "(short) number of retries when attempting to estblish a connection, 0 is unlimted")
+ flag.IntVar(&(config.ConnectionMaxRetries),
+ "connnection-retries",
+ 0,
+ "number of retries when attempting to estblish a connection, 0 is unlimted")
+ flag.DurationVar(&(config.DeviceListRefreshInterval),
+ "dri",
+ 1*time.Minute,
+ "(short) interval between attempts to synchronize devices from voltha to ofagent")
+ flag.DurationVar(&(config.DeviceListRefreshInterval),
+ "device-refresh-interval",
+ 1*time.Minute,
+ "interval between attempts to synchronize devices from voltha to ofagent")
+
+ return &config, nil
+}
diff --git a/cmd/ofagent/main.go b/cmd/ofagent/main.go
new file mode 100644
index 0000000..cd03674
--- /dev/null
+++ b/cmd/ofagent/main.go
@@ -0,0 +1,130 @@
+/*
+ Copyright 2019 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 main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "github.com/opencord/ofagent-go/internal/pkg/ofagent"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/probe"
+ "github.com/opencord/voltha-lib-go/v2/pkg/version"
+ "os"
+ "strings"
+)
+
+func printBanner() {
+ fmt.Println(` ___ _____ _ _ `)
+ fmt.Println(` / _ \| ___/ \ __ _ ___ _ __ | |_ `)
+ fmt.Println(` | | | | |_ / _ \ / _' |/ _ \ '_ \| __|`)
+ fmt.Println(` | |_| | _/ ___ \ (_| | __/ | | | |_ `)
+ fmt.Println(` \___/|_|/_/ \_\__, |\___|_| |_|\__|`)
+ fmt.Println(` |___/ `)
+}
+
+func printVersion() {
+ fmt.Println("OFAgent")
+ fmt.Println(version.VersionInfo.String(" "))
+}
+
+func main() {
+
+ config, _ := parseCommandLineArguments()
+ flag.Parse()
+
+ if config.Version {
+ printVersion()
+ os.Exit(0)
+ }
+
+ if config.Banner {
+ printBanner()
+ }
+
+ log.SetLogLevel(log.DebugLevel)
+ log.SetDefaultLogger(log.JSON, log.DebugLevel,
+ log.Fields{
+ "component": "ofagent",
+ })
+
+ logLevel := log.WarnLevel
+ switch strings.ToLower(config.LogLevel) {
+ case "fatal":
+ logLevel = log.FatalLevel
+ case "error":
+ logLevel = log.ErrorLevel
+ case "warn":
+ logLevel = log.WarnLevel
+ case "info":
+ logLevel = log.InfoLevel
+ case "debug":
+ logLevel = log.DebugLevel
+ default:
+ log.Warn("unrecognized-log-level",
+ log.Fields{
+ "msg": "Unrecognized log level setting defaulting to 'WARN'",
+ "component": "ofagent",
+ "value": config.LogLevel,
+ })
+ config.LogLevel = "WARN"
+ logLevel = log.FatalLevel
+ }
+ log.SetDefaultLogger(log.JSON, logLevel,
+ log.Fields{
+ "component": "ofagent",
+ })
+ log.SetAllLogLevel(logLevel)
+
+ log.Infow("ofagent-startup-configuration",
+ log.Fields{
+ "configuration": fmt.Sprintf("%+v", *config),
+ })
+
+ _, err := log.AddPackage(log.JSON, logLevel, nil)
+ if err != nil {
+ log.Errorw("unable-to-register-package-to-the-log-map", log.Fields{"error": err})
+ }
+
+ /*
+ * Create and start the liveness and readiness container management probes. This
+ * is done in the main function so just in case the main starts multiple other
+ * objects there can be a single probe end point for the process.
+ */
+ p := &probe.Probe{}
+ go p.ListenAndServe(config.ProbeEndPoint)
+
+ /*
+ * Create a context which to start the services used by the applicaiton
+ * and attach the probe to that context
+ */
+ ctx := context.WithValue(context.Background(), probe.ProbeContextKey, p)
+
+ ofa, err := ofagent.NewOFAgent(&ofagent.OFAgent{
+ OFControllerEndPoint: config.OFControllerEndPoint,
+ VolthaApiEndPoint: config.VolthaApiEndPoint,
+ DeviceListRefreshInterval: config.DeviceListRefreshInterval,
+ ConnectionMaxRetries: config.ConnectionMaxRetries,
+ ConnectionRetryDelay: config.ConnectionRetryDelay,
+ })
+ if err != nil {
+ log.Fatalw("failed-to-create-ofagent",
+ log.Fields{
+ "error": err})
+ }
+ ofa.Run(ctx)
+}
diff --git a/go.sum b/go.sum
index 321d0e0..6a88e01 100644
--- a/go.sum
+++ b/go.sum
@@ -32,8 +32,6 @@
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/donNewtonAlpha/goloxi v0.0.0-20191114190442-56ef1a8d7bcc h1:o0ijbscb9OjCFSg13kkfGtdWkU6ep66eiKbX3h94BEk=
-github.com/donNewtonAlpha/goloxi v0.0.0-20191114190442-56ef1a8d7bcc/go.mod h1:mf2669Q9OEthwDwxdgO6fmRVZhM/3F+hhlvkFD7V/JI=
github.com/donNewtonAlpha/goloxi v1.0.0 h1:aMRErR0P1PXN0JqfWwhjn33gD/NS5YB7bHi/ydsC36I=
github.com/donNewtonAlpha/goloxi v1.0.0/go.mod h1:mf2669Q9OEthwDwxdgO6fmRVZhM/3F+hhlvkFD7V/JI=
github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
diff --git a/grpc/changeEvent.go b/grpc/changeEvent.go
deleted file mode 100644
index 68f87cd..0000000
--- a/grpc/changeEvent.go
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- 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 grpc
-
-import (
- "context"
- "encoding/json"
-
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/golang/protobuf/ptypes/empty"
- "github.com/opencord/ofagent-go/openflow"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
- "google.golang.org/grpc"
-
- "net"
- "time"
-)
-
-func receiveChangeEvent(client pb.VolthaServiceClient) {
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugln("GrpcClient receiveChangeEvent called")
- }
- opt := grpc.EmptyCallOption{}
- stream, err := client.ReceiveChangeEvents(context.Background(), &empty.Empty{}, opt)
- if err != nil {
- logger.Fatalln("Unable to establish Receive Change Event Stream")
- }
- for {
- changeEvent, err := stream.Recv()
- if err != nil {
- logger.Errorw("Error receiving change event", l.Fields{"Error": err})
- }
- deviceID := changeEvent.GetId()
- portStatus := changeEvent.GetPortStatus()
- if settings.GetDebug(grpcDeviceID) {
- //js, _ := json.Marshal(changeEvent)
-
- logger.Debugw("Received Change Event", l.Fields{"DeviceID": deviceID, "PortStatus": portStatus})
- }
-
- if portStatus == nil {
- js, _ := json.Marshal(changeEvent.GetEvent())
- logger.Warnw("Received change event that was not port status", l.Fields{"ChangeEvent": js})
- break
- }
- ofPortStatus := ofp.NewPortStatus()
- ofPortStatus.SetXid(openflow.GetXid())
- ofPortStatus.SetVersion(4)
-
- ofReason := ofp.PortReason(portStatus.GetReason())
- ofPortStatus.SetReason(ofReason)
- ofDesc := ofp.NewPortDesc()
-
- desc := portStatus.GetDesc()
- ofDesc.SetAdvertised(ofp.PortFeatures(desc.GetAdvertised()))
- ofDesc.SetConfig(ofp.PortConfig(0))
- ofDesc.SetCurr(ofp.PortFeatures(desc.GetAdvertised()))
- ofDesc.SetCurrSpeed(desc.GetCurrSpeed())
- intArray := desc.GetHwAddr()
- var octets []byte
- for i := 0; i < len(intArray); i++ {
- octets = append(octets, byte(intArray[i]))
- }
- addr := net.HardwareAddr(octets)
- ofDesc.SetHwAddr(addr)
- ofDesc.SetMaxSpeed(desc.GetMaxSpeed())
- ofDesc.SetName(openflow.PadString(desc.GetName(), 16))
- ofDesc.SetPeer(ofp.PortFeatures(desc.GetPeer()))
- ofDesc.SetPortNo(ofp.Port(desc.GetPortNo()))
- ofDesc.SetState(ofp.PortState(desc.GetState()))
- ofDesc.SetSupported(ofp.PortFeatures(desc.GetSupported()))
- ofPortStatus.SetDesc(*ofDesc)
- var client = clientMap[deviceID]
- if client == nil {
- client = addClient(deviceID)
- time.Sleep(2 * time.Second)
- }
- client.SendMessage(ofPortStatus)
- }
-}
diff --git a/grpc/client.go b/grpc/client.go
deleted file mode 100644
index 40c805b..0000000
--- a/grpc/client.go
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- 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 grpc
-
-import (
- "context"
- "sync"
- "time"
-
- "github.com/golang/protobuf/ptypes/empty"
-
- "github.com/opencord/ofagent-go/openflow"
-
- "fmt"
-
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
-
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
- "google.golang.org/grpc"
-)
-
-var grpcDeviceID = "GRPC_CLIENT"
-var client pb.VolthaServiceClient
-var clientMap map[string]*openflow.Client
-var ofAddress string
-var ofPort uint16
-var mapLock sync.Mutex
-var logger, _ = l.AddPackage(l.JSON, l.DebugLevel, nil)
-
-//StartClient - make the inital connection to voltha and kicks off io streams
-func StartClient(endpointAddress string, endpointPort uint16, openFlowAddress string, openFlowPort uint16) {
-
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugw("Starting GRPC - VOLTHA client", l.Fields{"EndPointAddr": endpointAddress,
- "EndPointPort": endpointPort, "OpenFlowAddress": openFlowAddress, "OpenFlowPort": openFlowPort})
- }
- ofAddress = openFlowAddress
- ofPort = openFlowPort
- clientMap = make(map[string]*openflow.Client)
- var opts []grpc.DialOption
- opts = append(opts, grpc.WithInsecure())
- endpoint := fmt.Sprintf("%s:%d", endpointAddress, endpointPort)
- conn, err := grpc.Dial(endpoint, opts...)
- defer conn.Close()
- if err != nil {
- l.Fatalw("StartClient failed opening GRPC connecton", l.Fields{"EndPoint": endpoint, "Error": err})
- }
- client = pb.NewVolthaServiceClient(conn)
-
- go receivePacketIn(client)
- go receiveChangeEvent(client)
- go streamPacketOut(client)
-
- openflow.SetGrpcClient(&client)
- for {
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugln("GrpcClient entering device refresh pull")
- }
- deviceList, err := client.ListLogicalDevices(context.Background(), &empty.Empty{})
- if err != nil {
- logger.Errorw("GrpcClient getDeviceList failed", l.Fields{"Error": err})
- }
- devices := deviceList.GetItems()
- refreshDeviceList(devices)
- time.Sleep(time.Minute)
- }
-}
-func refreshDeviceList(devices []*pb.LogicalDevice) {
- //first find the new ones
-
- var toAdd []string
- var toDel []string
- var deviceIDMap = make(map[string]string)
- for i := 0; i < len(devices); i++ {
- deviceID := devices[i].GetId()
- deviceIDMap[deviceID] = deviceID
- if clientMap[deviceID] == nil {
- toAdd = append(toAdd, deviceID)
- }
- }
- for key := range clientMap {
- if deviceIDMap[key] == "" {
- toDel = append(toDel, key)
- }
- }
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugw("GrpcClient refreshDeviceList", l.Fields{"ToAdd": toAdd, "ToDel": toDel})
- }
- for i := 0; i < len(toAdd); i++ {
- var client = addClient(toAdd[i])
- go client.Start()
- }
- for i := 0; i < len(toDel); i++ {
- clientMap[toDel[i]].End()
- mapLock.Lock()
- delete(clientMap, toDel[i])
- mapLock.Unlock()
- }
-}
-func addClient(deviceID string) *openflow.Client {
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugw("GrpcClient addClient called ", l.Fields{"DeviceID": deviceID})
- }
- mapLock.Lock()
- var client *openflow.Client
- client = clientMap[deviceID]
- if client == nil {
- client = openflow.NewClient(ofAddress, ofPort, deviceID, true)
- go client.Start()
- clientMap[deviceID] = client
- }
- mapLock.Unlock()
- logger.Debugw("Finished with addClient", l.Fields{"deviceID": deviceID})
- return client
-}
-
-//GetClient Returns a pointer to the OpenFlow client
-func GetClient(deviceID string) *openflow.Client {
- client := clientMap[deviceID]
- if client == nil {
- client = addClient(deviceID)
- }
- return client
-}
diff --git a/grpc/packetIn.go b/grpc/packetIn.go
deleted file mode 100644
index bc8d3a8..0000000
--- a/grpc/packetIn.go
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- 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 grpc
-
-import (
- "context"
- "encoding/json"
-
- "github.com/donNewtonAlpha/goloxi"
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/golang/protobuf/ptypes/empty"
- "github.com/opencord/ofagent-go/openflow"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- "github.com/opencord/voltha-protos/v2/go/openflow_13"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
- "google.golang.org/grpc"
-)
-
-func receivePacketIn(client pb.VolthaServiceClient) {
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugln("Starting ReceivePacketIn Stream")
- }
- opt := grpc.EmptyCallOption{}
- stream, err := client.ReceivePacketsIn(context.Background(), &empty.Empty{}, opt)
- if err != nil {
- logger.Fatalw("Unable to establish PacketIn stream", l.Fields{"Error": err})
- }
- for {
- packet, err := stream.Recv()
- packetIn := packet.GetPacketIn()
-
- if err != nil {
- logger.Fatalw("ReceivePacketIn unable to receive packet", l.Fields{"Error": err})
- }
- if settings.GetDebug(grpcDeviceID) {
- js, _ := json.Marshal(packetIn)
- logger.Debugw("ReceivePacketIn Recieved", l.Fields{"PacketIn": js})
- }
- deviceID := packet.GetId()
- ofPacketIn := ofp.NewPacketIn()
- ofPacketIn.SetVersion(uint8(4))
- ofPacketIn.SetXid(openflow.GetXid())
- ofPacketIn.SetBufferId(packetIn.GetBufferId())
- ofPacketIn.SetCookie(packetIn.GetCookie())
- ofPacketIn.SetData(packetIn.GetData())
- match := ofp.NewMatchV3()
- inMatch := packetIn.GetMatch()
- match.SetType(uint16(inMatch.GetType()))
- oxFields := inMatch.GetOxmFields()
- var fields []goloxi.IOxm
- var size uint16
- size = 4
- for i := 0; i < len(oxFields); i++ {
- oxmField := oxFields[i]
- field := oxmField.GetField()
- ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
- size += 4 //header for oxm
- 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)
- size += 4
- fields = append(fields, ofpInPort)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
- ofpEthType := ofp.NewOxmEthType()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_EthType)
- ofpEthType.Value = ofp.EthernetType(val.EthType)
- size += 2
- fields = append(fields, ofpEthType)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
- ofpInPhyPort := ofp.NewOxmInPhyPort()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
- ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
- size += 4
- 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)
- size += 1
- 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)
- size += 2
- fields = append(fields, ofpUdpSrc)
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
- ofpUdpDst := ofp.NewOxmUdpDst()
- val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
- ofpUdpDst.Value = uint16(val.UdpDst)
- size += 2
- fields = append(fields, ofpUdpDst)
- 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
- size += 2
- } else {
- ofpVlanVid.Value = uint16(0)
- }
-
- fields = append(fields, ofpVlanVid)
- default:
- logger.Warnw("receivePacketIn Unhandled OxmField ", l.Fields{"Field": ofbField.Type})
- }
- }
- match.SetLength(size)
-
- match.SetOxmList(fields)
-
- ofPacketIn.SetMatch(*match)
- ofPacketIn.SetReason(uint8(packetIn.GetReason()))
- ofPacketIn.SetTableId(uint8(packetIn.GetTableId()))
- ofPacketIn.SetTotalLen(uint16(len(ofPacketIn.GetData())))
- openFlowClient := GetClient(deviceID)
- openFlowClient.SendMessage(ofPacketIn)
-
- }
-
-}
diff --git a/grpc/packetOut.go b/grpc/packetOut.go
deleted file mode 100644
index c2c92d1..0000000
--- a/grpc/packetOut.go
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- 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 grpc
-
-import (
- "context"
- "encoding/json"
-
- "github.com/opencord/ofagent-go/openflow"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
- "google.golang.org/grpc"
-)
-
-func streamPacketOut(client pb.VolthaServiceClient) {
- if settings.GetDebug(grpcDeviceID) {
- logger.Debugln("GrpcClient streamPacketOut called")
- }
- opt := grpc.EmptyCallOption{}
- outClient, err := client.StreamPacketsOut(context.Background(), opt)
- if err != nil {
- logger.Fatalw("streamPacketOut Error creating packetout stream ", l.Fields{"Error": err})
- }
- packetOutChannel := make(chan pb.PacketOut)
- openflow.SetPacketOutChannel(packetOutChannel)
- for {
- ofPacketOut := <-packetOutChannel
- if settings.GetDebug(grpcDeviceID) {
- js, _ := json.Marshal(ofPacketOut)
- logger.Debugw("streamPacketOut Receive PacketOut from Channel", l.Fields{"PacketOut": js})
- }
- outClient.Send(&ofPacketOut)
- }
-
-}
diff --git a/internal/pkg/ofagent/changeEvent.go b/internal/pkg/ofagent/changeEvent.go
new file mode 100644
index 0000000..90b0fd6
--- /dev/null
+++ b/internal/pkg/ofagent/changeEvent.go
@@ -0,0 +1,110 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/opencord/ofagent-go/internal/pkg/openflow"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "google.golang.org/grpc"
+ "net"
+)
+
+func (ofa *OFAgent) receiveChangeEvents(ctx context.Context) {
+ logger.Debug("receive-change-events-started")
+ opt := grpc.EmptyCallOption{}
+ streamCtx, streamDone := context.WithCancel(context.Background())
+ stream, err := ofa.volthaClient.ReceiveChangeEvents(streamCtx, &empty.Empty{}, opt)
+ if err != nil {
+ logger.Errorw("Unable to establish Receive Change Event Stream",
+ log.Fields{"error": err})
+ ofa.events <- ofaEventVolthaDisconnected
+ }
+ defer streamDone()
+
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ default:
+ if ce, err := stream.Recv(); err != nil {
+ logger.Errorw("error receiving change event",
+ log.Fields{"error": err})
+ ofa.events <- ofaEventVolthaDisconnected
+ } else {
+ ofa.changeEventChannel <- ce
+ }
+ }
+ }
+}
+
+func (ofa *OFAgent) handleChangeEvents(ctx context.Context) {
+ logger.Debugln("handle-change-event-started")
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case changeEvent := <-ofa.changeEventChannel:
+ deviceID := changeEvent.GetId()
+ portStatus := changeEvent.GetPortStatus()
+ logger.Debugw("received-change-event",
+ log.Fields{
+ "device-id": deviceID,
+ "port-status": portStatus})
+
+ if portStatus == nil {
+ if logger.V(log.WarnLevel) {
+ js, _ := json.Marshal(changeEvent.GetEvent())
+ logger.Warnw("Received change event that was not port status",
+ log.Fields{"ChangeEvent": js})
+ }
+ break
+ }
+ ofPortStatus := ofp.NewPortStatus()
+ ofPortStatus.SetXid(openflow.GetXid())
+ ofPortStatus.SetVersion(4)
+
+ ofReason := ofp.PortReason(portStatus.GetReason())
+ ofPortStatus.SetReason(ofReason)
+ ofDesc := ofp.NewPortDesc()
+
+ desc := portStatus.GetDesc()
+ ofDesc.SetAdvertised(ofp.PortFeatures(desc.GetAdvertised()))
+ ofDesc.SetConfig(ofp.PortConfig(0))
+ ofDesc.SetCurr(ofp.PortFeatures(desc.GetAdvertised()))
+ ofDesc.SetCurrSpeed(desc.GetCurrSpeed())
+ intArray := desc.GetHwAddr()
+ var octets []byte
+ for _, val := range intArray {
+ octets = append(octets, byte(val))
+ }
+ addr := net.HardwareAddr(octets)
+ ofDesc.SetHwAddr(addr)
+ ofDesc.SetMaxSpeed(desc.GetMaxSpeed())
+ ofDesc.SetName(openflow.PadString(desc.GetName(), 16))
+ ofDesc.SetPeer(ofp.PortFeatures(desc.GetPeer()))
+ ofDesc.SetPortNo(ofp.Port(desc.GetPortNo()))
+ ofDesc.SetState(ofp.PortState(desc.GetState()))
+ ofDesc.SetSupported(ofp.PortFeatures(desc.GetSupported()))
+ ofPortStatus.SetDesc(*ofDesc)
+ ofa.getOFClient(deviceID).SendMessage(ofPortStatus)
+ }
+ }
+}
diff --git a/internal/pkg/ofagent/connection.go b/internal/pkg/ofagent/connection.go
new file mode 100644
index 0000000..5fd8a3f
--- /dev/null
+++ b/internal/pkg/ofagent/connection.go
@@ -0,0 +1,77 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "errors"
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/probe"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+ "google.golang.org/grpc"
+ "time"
+)
+
+func (ofa *OFAgent) establishConnectionToVoltha(p *probe.Probe) error {
+ if p != nil {
+ p.UpdateStatus("voltha", probe.ServiceStatusPreparing)
+ }
+
+ if ofa.volthaConnection != nil {
+ ofa.volthaConnection.Close()
+ }
+
+ ofa.volthaConnection = nil
+ ofa.volthaClient = nil
+ try := 1
+ for ofa.ConnectionMaxRetries == 0 || try < ofa.ConnectionMaxRetries {
+ conn, err := grpc.Dial(ofa.VolthaApiEndPoint, grpc.WithInsecure())
+ if err == nil {
+ svc := voltha.NewVolthaServiceClient(conn)
+ if svc != nil {
+ if _, err = svc.GetVoltha(context.Background(), &empty.Empty{}); err == nil {
+ logger.Debugw("Established connection to Voltha",
+ log.Fields{
+ "VolthaApiEndPoint": ofa.VolthaApiEndPoint,
+ })
+ ofa.volthaConnection = conn
+ ofa.volthaClient = svc
+ if p != nil {
+ p.UpdateStatus("voltha", probe.ServiceStatusRunning)
+ }
+ ofa.events <- ofaEventVolthaConnected
+ return nil
+ }
+ }
+ }
+ logger.Warnw("Failed to connect to voltha",
+ log.Fields{
+ "VolthaApiEndPoint": ofa.VolthaApiEndPoint,
+ "error": err.Error(),
+ })
+ if ofa.ConnectionMaxRetries == 0 || try < ofa.ConnectionMaxRetries {
+ if ofa.ConnectionMaxRetries != 0 {
+ try += 1
+ }
+ time.Sleep(ofa.ConnectionRetryDelay)
+ }
+ }
+ if p != nil {
+ p.UpdateStatus("voltha", probe.ServiceStatusFailed)
+ }
+ return errors.New("failed-to-connect-to-voltha")
+}
diff --git a/internal/pkg/ofagent/ofagent.go b/internal/pkg/ofagent/ofagent.go
new file mode 100644
index 0000000..0ad4cd1
--- /dev/null
+++ b/internal/pkg/ofagent/ofagent.go
@@ -0,0 +1,181 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "github.com/opencord/ofagent-go/internal/pkg/openflow"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/probe"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+ "google.golang.org/grpc"
+ "sync"
+ "time"
+)
+
+var logger, _ = log.AddPackage(log.JSON, log.DebugLevel, nil)
+
+type ofaEvent byte
+type ofaState byte
+
+const (
+ ofaEventStart = ofaEvent(iota)
+ ofaEventVolthaConnected
+ ofaEventVolthaDisconnected
+ ofaEventError
+
+ ofaStateConnected = ofaState(iota)
+ ofaStateDisconnected
+)
+
+type OFAgent struct {
+ VolthaApiEndPoint string
+ OFControllerEndPoint string
+ DeviceListRefreshInterval time.Duration
+ ConnectionMaxRetries int
+ ConnectionRetryDelay time.Duration
+
+ volthaConnection *grpc.ClientConn
+ volthaClient voltha.VolthaServiceClient
+ mapLock sync.Mutex
+ clientMap map[string]*openflow.OFClient
+ events chan ofaEvent
+
+ packetInChannel chan *voltha.PacketIn
+ packetOutChannel chan *voltha.PacketOut
+ changeEventChannel chan *voltha.ChangeEvent
+}
+
+func NewOFAgent(config *OFAgent) (*OFAgent, error) {
+ ofa := OFAgent{
+ VolthaApiEndPoint: config.VolthaApiEndPoint,
+ OFControllerEndPoint: config.OFControllerEndPoint,
+ DeviceListRefreshInterval: config.DeviceListRefreshInterval,
+ ConnectionMaxRetries: config.ConnectionMaxRetries,
+ ConnectionRetryDelay: config.ConnectionRetryDelay,
+ packetInChannel: make(chan *voltha.PacketIn),
+ packetOutChannel: make(chan *voltha.PacketOut),
+ changeEventChannel: make(chan *voltha.ChangeEvent),
+ clientMap: make(map[string]*openflow.OFClient),
+ events: make(chan ofaEvent, 100),
+ }
+
+ if ofa.DeviceListRefreshInterval <= 0 {
+ logger.Warnw("device list refresh internal not valid, setting to default",
+ log.Fields{
+ "value": ofa.DeviceListRefreshInterval.String(),
+ "default": (1 * time.Minute).String()})
+ ofa.DeviceListRefreshInterval = 1 * time.Minute
+ }
+
+ if ofa.ConnectionRetryDelay <= 0 {
+ logger.Warnw("connection retry delay not value, setting to default",
+ log.Fields{
+ "value": ofa.ConnectionRetryDelay.String(),
+ "default": (3 * time.Second).String()})
+ ofa.ConnectionRetryDelay = 3 * time.Second
+ }
+
+ return &ofa, nil
+}
+
+// Run - make the inital connection to voltha and kicks off io streams
+func (ofa *OFAgent) Run(ctx context.Context) {
+
+ logger.Debugw("Starting GRPC - VOLTHA client",
+ log.Fields{
+ "voltha-endpoint": ofa.VolthaApiEndPoint,
+ "controller-endpoint": ofa.OFControllerEndPoint})
+
+ // If the context contains a k8s probe then register services
+ p := probe.GetProbeFromContext(ctx)
+ if p != nil {
+ p.RegisterService("voltha")
+ }
+ ofa.events <- ofaEventStart
+
+ /*
+ * Two sub-contexts are created here for different purposes so we can
+ * control the lifecyle of processing loops differently.
+ *
+ * volthaCtx - controls those processes that rely on the GRPC
+ * GRPCconnection to voltha and will be restarted when the
+ * GRPC connection is interrupted.
+ * hdlCtx - controls those processes that listen to channels and
+ * process each message. these will likely never be
+ * stopped until the ofagent is stopped.
+ */
+ var volthaCtx, hdlCtx context.Context
+ var volthaDone, hdlDone func()
+ state := ofaStateDisconnected
+
+ for {
+ select {
+ case <-ctx.Done():
+ if volthaDone != nil {
+ volthaDone()
+ volthaDone = nil
+ }
+ if hdlDone != nil {
+ hdlDone()
+ hdlDone = nil
+ }
+ return
+ case event := <-ofa.events:
+ switch event {
+ case ofaEventStart:
+ logger.Debug("ofagent-voltha-start-event")
+
+ // Start the loops that process messages
+ hdlCtx, hdlDone = context.WithCancel(context.Background())
+ go ofa.handlePacketsIn(hdlCtx)
+ go ofa.handleChangeEvents(hdlCtx)
+
+ // Kick off process to attempt to establish
+ // connection to voltha
+ go ofa.establishConnectionToVoltha(p)
+
+ case ofaEventVolthaConnected:
+ logger.Debug("ofagent-voltha-connect-event")
+
+ // Start the loops that poll from voltha
+ if state != ofaStateConnected {
+ state = ofaStateConnected
+ volthaCtx, volthaDone = context.WithCancel(context.Background())
+ go ofa.receiveChangeEvents(volthaCtx)
+ go ofa.receivePacketsIn(volthaCtx)
+ go ofa.streamPacketOut(volthaCtx)
+ go ofa.synchronizeDeviceList(volthaCtx)
+ }
+
+ case ofaEventVolthaDisconnected:
+ logger.Debug("ofagent-voltha-disconnect-event")
+ if state == ofaStateConnected {
+ state = ofaStateDisconnected
+ volthaDone()
+ volthaDone = nil
+ volthaCtx = nil
+ }
+ case ofaEventError:
+ logger.Debug("ofagent-error-event")
+ default:
+ logger.Fatalw("ofagent-unknown-event",
+ log.Fields{"event": event})
+ }
+ }
+ }
+}
diff --git a/internal/pkg/ofagent/packetIn.go b/internal/pkg/ofagent/packetIn.go
new file mode 100644
index 0000000..721d1d7
--- /dev/null
+++ b/internal/pkg/ofagent/packetIn.go
@@ -0,0 +1,160 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "encoding/json"
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/opencord/ofagent-go/internal/pkg/openflow"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/openflow_13"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+ "google.golang.org/grpc"
+)
+
+func (ofa *OFAgent) receivePacketsIn(ctx context.Context) {
+ logger.Debug("receive-packets-in-started")
+ opt := grpc.EmptyCallOption{}
+ streamCtx, streamDone := context.WithCancel(context.Background())
+ stream, err := ofa.volthaClient.ReceivePacketsIn(streamCtx, &empty.Empty{}, opt)
+ if err != nil {
+ logger.Errorw("Unable to establish Receive PacketIn Stream",
+ log.Fields{"error": err})
+ }
+ defer streamDone()
+
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ default:
+ if pkt, err := stream.Recv(); err != nil {
+ logger.Errorw("error receiving packet",
+ log.Fields{"error": err})
+ ofa.events <- ofaEventVolthaDisconnected
+ } else {
+ ofa.packetInChannel <- pkt
+ }
+ }
+ }
+}
+
+func (ofa *OFAgent) handlePacketsIn(ctx context.Context) {
+ logger.Debug("handle-packets-in-started")
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case packet := <-ofa.packetInChannel:
+ packetIn := packet.GetPacketIn()
+
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(packetIn)
+ logger.Debugw("packet-in recieved", log.Fields{"packet-in": js})
+ }
+ deviceID := packet.GetId()
+ ofPacketIn := ofp.NewPacketIn()
+ ofPacketIn.SetVersion(uint8(4))
+ ofPacketIn.SetXid(openflow.GetXid())
+ ofPacketIn.SetBufferId(packetIn.GetBufferId())
+ ofPacketIn.SetCookie(packetIn.GetCookie())
+ ofPacketIn.SetData(packetIn.GetData())
+ match := ofp.NewMatchV3()
+ inMatch := packetIn.GetMatch()
+ match.SetType(uint16(inMatch.GetType()))
+ //oxFields := inMatch.GetOxmFields()
+ var fields []goloxi.IOxm
+ size := uint16(4)
+ for _, oxmField := range inMatch.GetOxmFields() {
+ /*
+ for i := 0; i < len(oxFields); i++ {
+ oxmField := oxFields[i]
+ */
+ field := oxmField.GetField()
+ ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
+ size += 4 //header for oxm
+ switch ofbField.Type {
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+ ofpInPort := ofp.NewOxmInPort()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_Port)
+ ofpInPort.Value = ofp.Port(val.Port)
+ size += 4
+ fields = append(fields, ofpInPort)
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+ ofpEthType := ofp.NewOxmEthType()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_EthType)
+ ofpEthType.Value = ofp.EthernetType(val.EthType)
+ size += 2
+ fields = append(fields, ofpEthType)
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
+ ofpInPhyPort := ofp.NewOxmInPhyPort()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_PhysicalPort)
+ ofpInPhyPort.Value = ofp.Port(val.PhysicalPort)
+ size += 4
+ fields = append(fields, ofpInPhyPort)
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+ ofpIpProto := ofp.NewOxmIpProto()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_IpProto)
+ ofpIpProto.Value = ofp.IpPrototype(val.IpProto)
+ size += 1
+ fields = append(fields, ofpIpProto)
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+ ofpUdpSrc := ofp.NewOxmUdpSrc()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpSrc)
+ ofpUdpSrc.Value = uint16(val.UdpSrc)
+ size += 2
+ fields = append(fields, ofpUdpSrc)
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+ ofpUdpDst := ofp.NewOxmUdpDst()
+ val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_UdpDst)
+ ofpUdpDst.Value = uint16(val.UdpDst)
+ size += 2
+ fields = append(fields, ofpUdpDst)
+ case voltha.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
+ size += 2
+ } else {
+ ofpVlanVid.Value = uint16(0)
+ }
+
+ fields = append(fields, ofpVlanVid)
+ default:
+ logger.Warnw("receive-packet-in:unhandled-oxm-field",
+ log.Fields{"field": ofbField.Type})
+ }
+ }
+ match.SetLength(size)
+
+ match.SetOxmList(fields)
+
+ ofPacketIn.SetMatch(*match)
+ ofPacketIn.SetReason(uint8(packetIn.GetReason()))
+ ofPacketIn.SetTableId(uint8(packetIn.GetTableId()))
+ ofPacketIn.SetTotalLen(uint16(len(ofPacketIn.GetData())))
+ ofc := ofa.getOFClient(deviceID)
+ ofc.SendMessage(ofPacketIn)
+
+ }
+ }
+}
diff --git a/internal/pkg/ofagent/packetOut.go b/internal/pkg/ofagent/packetOut.go
new file mode 100644
index 0000000..3a43335
--- /dev/null
+++ b/internal/pkg/ofagent/packetOut.go
@@ -0,0 +1,50 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "encoding/json"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "google.golang.org/grpc"
+)
+
+func (ofa *OFAgent) streamPacketOut(ctx context.Context) {
+ if logger.V(log.DebugLevel) {
+ logger.Debug("GrpcClient streamPacketOut called")
+ }
+ opt := grpc.EmptyCallOption{}
+ streamCtx, streamDone := context.WithCancel(context.Background())
+ outClient, err := ofa.volthaClient.StreamPacketsOut(streamCtx, opt)
+ defer streamDone()
+ if err != nil {
+ logger.Errorw("streamPacketOut Error creating packetout stream ", log.Fields{"error": err})
+ ofa.events <- ofaEventVolthaDisconnected
+ }
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case ofPacketOut := <-ofa.packetOutChannel:
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(ofPacketOut)
+ logger.Debugw("streamPacketOut Receive PacketOut from Channel", log.Fields{"PacketOut": js})
+ }
+ outClient.Send(ofPacketOut)
+ }
+ }
+}
diff --git a/internal/pkg/ofagent/refresh.go b/internal/pkg/ofagent/refresh.go
new file mode 100644
index 0000000..8f68ef0
--- /dev/null
+++ b/internal/pkg/ofagent/refresh.go
@@ -0,0 +1,109 @@
+/*
+ Copyright 2020 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 ofagent
+
+import (
+ "context"
+ "github.com/golang/protobuf/ptypes/empty"
+ "github.com/opencord/ofagent-go/internal/pkg/openflow"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "time"
+)
+
+func (ofa *OFAgent) synchronizeDeviceList(ctx context.Context) {
+ // Refresh once to get everything started
+ ofa.refreshDeviceList()
+
+ tick := time.NewTicker(ofa.DeviceListRefreshInterval)
+loop:
+ for {
+ select {
+ case <-ctx.Done():
+ break loop
+ case <-tick.C:
+ ofa.refreshDeviceList()
+ }
+ }
+ tick.Stop()
+}
+
+func (ofa *OFAgent) refreshDeviceList() {
+ deviceList, err := ofa.volthaClient.ListLogicalDevices(context.Background(), &empty.Empty{})
+ if err != nil {
+ logger.Errorw("ofagent failed to query device list from voltha",
+ log.Fields{"error": err})
+ return
+ }
+ devices := deviceList.GetItems()
+
+ var toAdd []string
+ var toDel []string
+ var deviceIDMap = make(map[string]string)
+ for i := 0; i < len(devices); i++ {
+ deviceID := devices[i].GetId()
+ deviceIDMap[deviceID] = deviceID
+ if ofa.clientMap[deviceID] == nil {
+ toAdd = append(toAdd, deviceID)
+ }
+ }
+ for key := range ofa.clientMap {
+ if deviceIDMap[key] == "" {
+ toDel = append(toDel, key)
+ }
+ }
+ logger.Debugw("GrpcClient refreshDeviceList", log.Fields{"ToAdd": toAdd, "ToDel": toDel})
+ for i := 0; i < len(toAdd); i++ {
+ var client = ofa.addOFClient(toAdd[i])
+ go client.Run(context.Background())
+ }
+ for i := 0; i < len(toDel); i++ {
+ ofa.clientMap[toDel[i]].Stop()
+ ofa.mapLock.Lock()
+ delete(ofa.clientMap, toDel[i])
+ ofa.mapLock.Unlock()
+ }
+}
+
+func (ofa *OFAgent) addOFClient(deviceID string) *openflow.OFClient {
+ logger.Debugw("GrpcClient addClient called ", log.Fields{"device-id": deviceID})
+ ofa.mapLock.Lock()
+ ofc := ofa.clientMap[deviceID]
+ if ofc == nil {
+ ofc = openflow.NewOFClient(&openflow.OFClient{
+ DeviceID: deviceID,
+ OFControllerEndPoint: ofa.OFControllerEndPoint,
+ VolthaClient: ofa.volthaClient,
+ PacketOutChannel: ofa.packetOutChannel,
+ ConnectionMaxRetries: ofa.ConnectionMaxRetries,
+ ConnectionRetryDelay: ofa.ConnectionRetryDelay,
+ KeepRunning: true,
+ })
+ go ofc.Run(context.Background())
+ ofa.clientMap[deviceID] = ofc
+ }
+ ofa.mapLock.Unlock()
+ logger.Debugw("Finished with addClient", log.Fields{"deviceID": deviceID})
+ return ofc
+}
+
+func (ofa *OFAgent) getOFClient(deviceID string) *openflow.OFClient {
+ ofc := ofa.clientMap[deviceID]
+ if ofc == nil {
+ ofc = ofa.addOFClient(deviceID)
+ }
+ return ofc
+}
diff --git a/openflow/barrier.go b/internal/pkg/openflow/barrier.go
similarity index 66%
rename from openflow/barrier.go
rename to internal/pkg/openflow/barrier.go
index cb999d6..d6af20a 100644
--- a/openflow/barrier.go
+++ b/internal/pkg/openflow/barrier.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,21 +18,21 @@
import (
"encoding/json"
-
- "github.com/opencord/ofagent-go/settings"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleBarrierRequest(request *ofp.BarrierRequest, DeviceID string, client *Client) {
+func (ofc *OFClient) handleBarrierRequest(request *ofp.BarrierRequest) {
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleBarrierRequest called with %s", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleBarrierRequest called with %s",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
reply := ofp.NewBarrierReply()
reply.SetVersion(4)
reply.SetXid(request.GetXid())
- client.SendMessage(reply)
+ ofc.SendMessage(reply)
}
diff --git a/internal/pkg/openflow/client.go b/internal/pkg/openflow/client.go
new file mode 100644
index 0000000..33d531d
--- /dev/null
+++ b/internal/pkg/openflow/client.go
@@ -0,0 +1,538 @@
+/*
+ Copyright 2020 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 (
+ "context"
+ "encoding/binary"
+ "encoding/json"
+ "errors"
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+ "io"
+ "net"
+ "time"
+)
+
+var logger, _ = log.AddPackage(log.JSON, log.DebugLevel, nil)
+
+type ofcEvent byte
+type ofcState byte
+
+const (
+ ofcEventStart = ofcEvent(iota)
+ ofcEventConnected
+ ofcEventDisconnected
+
+ ofcStateConnected = ofcState(iota)
+ ofcStateDisconnected
+)
+
+//Client structure to hold fields of Openflow Client
+type OFClient struct {
+ OFControllerEndPoint string
+ Port uint16
+ DeviceID string
+ KeepRunning bool
+ VolthaClient voltha.VolthaServiceClient
+ PacketOutChannel chan *voltha.PacketOut
+ ConnectionMaxRetries int
+ ConnectionRetryDelay time.Duration
+ conn net.Conn
+
+ // expirimental
+ events chan ofcEvent
+ sendChannel chan Message
+ lastUnsentMessage Message
+}
+
+//NewClient contstructs a new Openflow Client and then starts up
+func NewOFClient(config *OFClient) *OFClient {
+
+ ofc := OFClient{
+ DeviceID: config.DeviceID,
+ OFControllerEndPoint: config.OFControllerEndPoint,
+ VolthaClient: config.VolthaClient,
+ PacketOutChannel: config.PacketOutChannel,
+ KeepRunning: config.KeepRunning,
+ ConnectionMaxRetries: config.ConnectionMaxRetries,
+ ConnectionRetryDelay: config.ConnectionRetryDelay,
+ events: make(chan ofcEvent, 10),
+ sendChannel: make(chan Message, 100),
+ }
+
+ if ofc.ConnectionRetryDelay <= 0 {
+ logger.Warnw("connection retry delay not valid, setting to default",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "value": ofc.ConnectionRetryDelay.String(),
+ "default": (3 * time.Second).String()})
+ ofc.ConnectionRetryDelay = 3 * time.Second
+ }
+ return &ofc
+}
+
+//End - set keepRunning to false so start loop exits
+func (ofc *OFClient) Stop() {
+ ofc.KeepRunning = false
+}
+
+func (ofc *OFClient) peekAtOFHeader(buf []byte) (ofp.IHeader, error) {
+ header := ofp.Header{}
+ header.Version = uint8(buf[0])
+ header.Type = uint8(buf[1])
+ header.Length = binary.BigEndian.Uint16(buf[2:4])
+ header.Xid = binary.BigEndian.Uint32(buf[4:8])
+
+ // TODO: add minimal validation of version and type
+
+ return &header, nil
+}
+
+func (ofc *OFClient) establishConnectionToController() error {
+ if ofc.conn != nil {
+ ofc.conn.Close()
+ ofc.conn = nil
+ }
+ try := 1
+ for ofc.ConnectionMaxRetries == 0 || try < ofc.ConnectionMaxRetries {
+ if raddr, err := net.ResolveTCPAddr("tcp", ofc.OFControllerEndPoint); err != nil {
+ logger.Debugw("openflow-client unable to resolve endpoint",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "endpoint": ofc.OFControllerEndPoint})
+ } else {
+ if connection, err := net.DialTCP("tcp", nil, raddr); err == nil {
+ ofc.conn = connection
+ ofc.sayHello()
+ ofc.events <- ofcEventConnected
+ return nil
+ } else {
+ logger.Warnw("openflow-client-connect-error",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "endpoint": ofc.OFControllerEndPoint})
+ }
+ }
+ if ofc.ConnectionMaxRetries == 0 || try < ofc.ConnectionMaxRetries {
+ if ofc.ConnectionMaxRetries != 0 {
+ try += 1
+ }
+ time.Sleep(ofc.ConnectionRetryDelay)
+ }
+ }
+ return errors.New("failed-to-connect-to-of-controller")
+}
+
+func (ofc *OFClient) Run(ctx context.Context) {
+
+ var ofCtx context.Context
+ var ofDone func()
+ ofc.events <- ofcEventStart
+ state := ofcStateDisconnected
+top:
+ for {
+ select {
+ case <-ctx.Done():
+ break top
+ case event := <-ofc.events:
+ switch event {
+ case ofcEventStart:
+ logger.Debugw("ofc-event-star",
+ log.Fields{"device-id": ofc.DeviceID})
+ go ofc.establishConnectionToController()
+ case ofcEventConnected:
+ if state == ofcStateDisconnected {
+ state = ofcStateConnected
+ logger.Debugw("ofc-event-connected",
+ log.Fields{"device-id": ofc.DeviceID})
+ ofCtx, ofDone = context.WithCancel(context.Background())
+ go ofc.messageSender(ofCtx)
+ go ofc.processOFStream(ofCtx)
+ }
+ case ofcEventDisconnected:
+ if state == ofcStateConnected {
+ state = ofcStateDisconnected
+ logger.Debugw("ofc-event-disconnected",
+ log.Fields{"device-id": ofc.DeviceID})
+ if ofDone != nil {
+ ofDone()
+ ofDone = nil
+ }
+ go ofc.establishConnectionToController()
+ }
+ }
+ }
+ }
+
+ if ofDone != nil {
+ ofDone()
+ ofDone = nil
+ }
+
+}
+
+// Run run loop for the openflow client
+func (ofc *OFClient) processOFStream(ctx context.Context) {
+ buf := make([]byte, 1500)
+ var need, have int
+ /*
+ * EXPLANATION
+ *
+ * The below loops reuses a byte array to read messages from the TCP
+ * connection to the OF controller. It reads messages into a large
+ * buffer in an attempt to optimize the read performance from the
+ * TCP connection. This means that on any given read there may be more
+ * than a single message in the byte array read.
+ *
+ * As the minimal size for an OF message is 8 bytes (because that is
+ * the size of the basic header) we know that if we have not read
+ * 8 bytes we need to read more before we can process a message.
+ *
+ * Once the mninium header is read, the complete length of the
+ * message is retrieved from the header and bytes are repeatedly read
+ * until we know the byte array contains at least one message.
+ *
+ * Once it is known that the buffer has at least a single message
+ * a slice (msg) is moved through the read bytes looking to process
+ * each message util the length of read data is < the length required
+ * i.e., the minimum size or the size of the next message.
+ *
+ * When no more message can be proessed from the byte array any unused
+ * bytes are moved to the front of the source array and more data is
+ * read from the TCP connection.
+ */
+
+ /*
+ * First thing we are looking for is an openflow header, so we need at
+ * least 8 bytes
+ */
+ need = 8
+
+top:
+ // Continue until we are told to stop
+ for ofc.KeepRunning {
+ logger.Debugw("before-read-from-controller",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need,
+ "buf-length": len(buf[have:])})
+ read, err := ofc.conn.Read(buf[have:])
+ have += read
+ logger.Debugw("read-from-controller",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "byte-count": read,
+ "error": err})
+
+ /*
+ * If we have less than we need and there is no
+ * error, then continue to attempt to read more data
+ */
+ if have < need && err == nil {
+ // No bytes available, just continue
+ logger.Debugw("continue-to-read",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need,
+ "error": err})
+ continue
+ }
+
+ /*
+ * Single out EOF here, because if we have bytes
+ * but have an EOF we still want to process the
+ * the last meesage. A read of 0 bytes and EOF is
+ * a terminated connection.
+ */
+ if err != nil && (err != io.EOF || read == 0) {
+ logger.Errorw("voltha-connection-dead",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
+ break
+ }
+
+ /*
+ * We should have at least 1 message at this point so
+ * create a slice (msg) that points to the start of the
+ * buffer
+ */
+ msg := buf[0:]
+ for need <= have {
+ logger.Debugw("process-of-message-stream",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need})
+ /*
+ * If we get here, we have at least the 8 bytes of the
+ * header, if not enough for the complete message. So
+ * take a peek at the OF header to do simple validation
+ * and be able to get the full expected length of the
+ * packet
+ */
+ peek, err := ofc.peekAtOFHeader(msg)
+ if err != nil {
+ /*
+ * Header is bad, assume stream is corrupted
+ * and needs to be restarted
+ */
+ logger.Errorw("bad-of-packet",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
+ break top
+ }
+
+ /*
+ * If we don't have the full packet, then back around
+ * the outer loop to get more bytes
+ */
+ need = int(peek.GetLength())
+
+ logger.Debugw("processed-header-need-message",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need})
+
+ if have < need {
+ logger.Debugw("end-processing:continue-to-read",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need})
+ break
+ }
+
+ // Decode and process the packet
+ decoder := goloxi.NewDecoder(msg)
+ header, err := ofp.DecodeHeader(decoder)
+ if err != nil {
+ js, _ := json.Marshal(decoder)
+ logger.Errorw("failed-to-decode",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "decoder": js,
+ "error": err})
+ break top
+ }
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(header)
+ logger.Debugw("packet-header",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "header": js})
+ }
+ ofc.parseHeader(header)
+
+ /*
+ * Move the msg slice to the start of the next
+ * message, which is the current message plus the
+ * used bytes (need)
+ */
+ msg = msg[need:]
+ have -= need
+
+ // Finished process method, need header again
+ need = 8
+
+ logger.Debugw("message-process-complete",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "have": have,
+ "need": need,
+ "read-length": len(buf[have:])})
+ }
+ /*
+ * If we have any left over bytes move them to the front
+ * of the byte array to be appended to bny the next read
+ */
+ if have > 0 {
+ copy(buf, msg)
+ }
+ }
+ ofc.events <- ofcEventDisconnected
+}
+
+func (ofc *OFClient) sayHello() {
+ hello := ofp.NewHello()
+ hello.Xid = uint32(GetXid())
+ elem := ofp.NewHelloElemVersionbitmap()
+ elem.SetType(ofp.OFPHETVersionbitmap)
+ elem.SetLength(8)
+ elem.SetBitmaps([]*ofp.Uint32{&ofp.Uint32{Value: 16}})
+ hello.SetElements([]ofp.IHelloElem{elem})
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(hello)
+ logger.Debugw("sayHello Called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "hello-message": js})
+ }
+ if err := ofc.SendMessage(hello); err != nil {
+ logger.Fatalw("Failed saying hello to Openflow Server, unable to proceed",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
+ }
+}
+
+func (ofc *OFClient) parseHeader(header ofp.IHeader) {
+ switch header.GetType() {
+ case ofp.OFPTHello:
+ //x := header.(*ofp.Hello)
+ case ofp.OFPTError:
+ go ofc.handleErrMsg(header.(*ofp.ErrorMsg))
+ case ofp.OFPTEchoRequest:
+ go ofc.handleEchoRequest(header.(*ofp.EchoRequest))
+ case ofp.OFPTEchoReply:
+ case ofp.OFPTExperimenter:
+ case ofp.OFPTFeaturesRequest:
+ go ofc.handleFeatureRequest(header.(*ofp.FeaturesRequest))
+ case ofp.OFPTFeaturesReply:
+ case ofp.OFPTGetConfigRequest:
+ go ofc.handleGetConfigRequest(header.(*ofp.GetConfigRequest))
+ case ofp.OFPTGetConfigReply:
+ case ofp.OFPTSetConfig:
+ go ofc.handleSetConfig(header.(*ofp.SetConfig))
+ case ofp.OFPTPacketIn:
+ case ofp.OFPTFlowRemoved:
+ case ofp.OFPTPortStatus:
+ case ofp.OFPTPacketOut:
+ go ofc.handlePacketOut(header.(*ofp.PacketOut))
+ case ofp.OFPTFlowMod:
+ /*
+ * Not using go routine to handle flow* messages or barrier requests
+ * onos typically issues barrier requests just before a flow* message.
+ * by handling in this thread I ensure all flow* are handled when barrier
+ * request is issued.
+ */
+ switch header.(ofp.IFlowMod).GetCommand() {
+ case ofp.OFPFCAdd:
+ ofc.handleFlowAdd(header.(*ofp.FlowAdd))
+ case ofp.OFPFCModify:
+ ofc.handleFlowMod(header.(*ofp.FlowMod))
+ case ofp.OFPFCModifyStrict:
+ ofc.handleFlowModStrict(header.(*ofp.FlowModifyStrict))
+ case ofp.OFPFCDelete:
+ ofc.handleFlowDelete(header.(*ofp.FlowDelete))
+ case ofp.OFPFCDeleteStrict:
+ ofc.handleFlowDeleteStrict(header.(*ofp.FlowDeleteStrict))
+ }
+ case ofp.OFPTStatsRequest:
+ go ofc.handleStatsRequest(header, header.(ofp.IStatsRequest).GetStatsType())
+ case ofp.OFPTBarrierRequest:
+ /* See note above at case ofp.OFPTFlowMod:*/
+ ofc.handleBarrierRequest(header.(*ofp.BarrierRequest))
+ case ofp.OFPTRoleRequest:
+ go ofc.handleRoleRequest(header.(*ofp.RoleRequest))
+ case ofp.OFPTMeterMod:
+ go ofc.handleMeterModRequest(header.(*ofp.MeterMod))
+ }
+}
+
+//Message created to allow for a single SendMessage
+type Message interface {
+ Serialize(encoder *goloxi.Encoder) error
+}
+
+func (ofc *OFClient) doSend(msg Message) error {
+ if ofc.conn == nil {
+ return errors.New("no-connection")
+ }
+ enc := goloxi.NewEncoder()
+ msg.Serialize(enc)
+ bytes := enc.Bytes()
+ if _, err := ofc.conn.Write(bytes); err != nil {
+ logger.Warnw("unable-to-send-message-to-controller",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "message": msg,
+ "error": err})
+ return err
+ }
+ return nil
+}
+
+func (ofc *OFClient) messageSender(ctx context.Context) {
+
+ // first process last fail if it exists
+ if ofc.lastUnsentMessage != nil {
+ if err := ofc.doSend(ofc.lastUnsentMessage); err != nil {
+ ofc.events <- ofcEventDisconnected
+ return
+ }
+ ofc.lastUnsentMessage = nil
+ }
+top:
+ for {
+ select {
+ case <-ctx.Done():
+ break top
+ case msg := <-ofc.sendChannel:
+ if ofc.doSend(msg) != nil {
+ ofc.lastUnsentMessage = msg
+ ofc.events <- ofcEventDisconnected
+ return
+ }
+ ofc.lastUnsentMessage = nil
+ }
+ }
+}
+
+func (ofc *OFClient) SendMessage(message Message) error {
+ ofc.sendChannel <- message
+ return nil
+}
+
+//SendMessage sends message to openflow server
+func (ofc *OFClient) SendMessageOrig(message Message) error {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(message)
+ logger.Debugw("SendMessage called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "message": js})
+ }
+ enc := goloxi.NewEncoder()
+ message.Serialize(enc)
+ for {
+ if ofc.conn == nil {
+ logger.Warnln("SendMessage Connection is Nil sleeping for 10 milliseconds")
+ time.Sleep(10 * time.Millisecond)
+ } else {
+ break
+ }
+ }
+ bytes := enc.Bytes()
+ if _, err := ofc.conn.Write(bytes); err != nil {
+ jMessage, _ := json.Marshal(message)
+ logger.Errorw("SendMessage failed sending message",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err,
+ "message": jMessage})
+ return err
+ }
+ return nil
+}
diff --git a/openflow/echo.go b/internal/pkg/openflow/echo.go
similarity index 67%
rename from openflow/echo.go
rename to internal/pkg/openflow/echo.go
index 528f845..d773c70 100644
--- a/openflow/echo.go
+++ b/internal/pkg/openflow/echo.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,20 +18,20 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleEchoRequest(request *ofp.EchoRequest, DeviceID string, client *Client) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleEchoRequest(request *ofp.EchoRequest) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleEchoRequest called", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleEchoRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
reply := ofp.NewEchoReply()
reply.SetXid(request.GetXid())
reply.SetVersion(request.GetVersion())
- client.SendMessage(reply)
-
+ ofc.SendMessage(reply)
}
diff --git a/openflow/ofError.go b/internal/pkg/openflow/error.go
similarity index 69%
rename from openflow/ofError.go
rename to internal/pkg/openflow/error.go
index 1f90c34..c1679b6 100644
--- a/openflow/ofError.go
+++ b/internal/pkg/openflow/error.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,16 +18,17 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleErrMsg(message *ofp.ErrorMsg, DeviceID string) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleErrMsg(message ofp.IErrorMsg) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(message)
- logger.Debugw("handleErrMsg called", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleErrMsg called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
//Not sure yet what if anything to do here
}
diff --git a/internal/pkg/openflow/feature.go b/internal/pkg/openflow/feature.go
new file mode 100644
index 0000000..706a84c
--- /dev/null
+++ b/internal/pkg/openflow/feature.go
@@ -0,0 +1,57 @@
+/*
+ Copyright 2020 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 (
+ "context"
+ "encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/common"
+)
+
+func (ofc *OFClient) handleFeatureRequest(request *ofp.FeaturesRequest) error {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(request)
+ logger.Debugw("handleFeatureRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
+ }
+ var id = common.ID{Id: ofc.DeviceID}
+ logicalDevice, err := ofc.VolthaClient.GetLogicalDevice(context.Background(), &id)
+ reply := ofp.NewFeaturesReply()
+ reply.SetVersion(4)
+ reply.SetXid(request.GetXid())
+ features := logicalDevice.GetSwitchFeatures()
+ reply.SetDatapathId(logicalDevice.GetDatapathId())
+ reply.SetNBuffers(features.GetNBuffers())
+ reply.SetNTables(uint8(features.GetNTables()))
+ reply.SetAuxiliaryId(uint8(features.GetAuxiliaryId()))
+ capabilities := features.GetCapabilities()
+ reply.SetCapabilities(ofp.Capabilities(capabilities))
+
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(reply)
+ logger.Debugw("handleFeatureRequestReturn",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "reply": js})
+ }
+ err = ofc.SendMessage(reply)
+ return err
+}
diff --git a/internal/pkg/openflow/flowMod.go b/internal/pkg/openflow/flowMod.go
new file mode 100644
index 0000000..42f37f2
--- /dev/null
+++ b/internal/pkg/openflow/flowMod.go
@@ -0,0 +1,346 @@
+/*
+ Copyright 2020 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 (
+ "context"
+ "encoding/json"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/openflow_13"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+)
+
+var oxmMap = map[string]int32{
+ "in_port": 0,
+ "in_phy_port": 1,
+ "metadata": 2,
+ "eth_dst": 3,
+ "eth_src": 4,
+ "eth_type": 5,
+ "vlan_vid": 6,
+ "vlan_pcp": 7,
+ "ip_dscp": 8,
+ "ip_ecn": 9,
+ "ip_proto": 10,
+ "ipv4_src": 11,
+ "ipv4_dst": 12,
+ "tcp_src": 13,
+ "tcp_dst": 14,
+ "udp_src": 15,
+ "udp_dst": 16,
+ "sctp_src": 17,
+ "sctp_dst": 18,
+ "icmpv4_type": 19,
+ "icmpv4_code": 20,
+ "arp_op": 21,
+ "arp_spa": 22,
+ "arp_tpa": 23,
+ "arp_sha": 24,
+ "arp_tha": 25,
+ "ipv6_src": 26,
+ "ipv6_dst": 27,
+ "ipv6_flabel": 28,
+ "icmpv6_type": 29,
+ "icmpv6_code": 30,
+ "ipv6_nd_target": 31,
+ "ipv6_nd_sll": 32,
+ "ipv6_nd_tll": 33,
+ "mpls_label": 34,
+ "mpls_tc": 35,
+ "mpls_bos": 36,
+ "pbb_isid": 37,
+ "tunnel_id": 38,
+ "ipv6_exthdr": 39,
+}
+
+func (ofc *OFClient) handleFlowAdd(flowAdd *ofp.FlowAdd) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(flowAdd)
+ logger.Debugw("handleFlowAdd called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "params": js})
+ }
+
+ // Construct the match
+ var oxmList []*voltha.OfpOxmField
+ for _, oxmField := range flowAdd.Match.GetOxmList() {
+ name := oxmMap[oxmField.GetOXMName()]
+ val := oxmField.GetOXMValue()
+ field := voltha.OfpOxmOfbField{Type: voltha.OxmOfbFieldTypes(name)}
+ ofpOxmField := voltha.OfpOxmField{
+ OxmClass: ofp.OFPXMCOpenflowBasic,
+ Field: &openflow_13.OfpOxmField_OfbField{OfbField: &field},
+ }
+ switch voltha.OxmOfbFieldTypes(name) {
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+ field.Value = &voltha.OfpOxmOfbField_Port{
+ Port: uint32(val.(ofp.Port)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
+ field.Value = &voltha.OfpOxmOfbField_PhysicalPort{
+ PhysicalPort: val.(uint32),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+ field.Value = &voltha.OfpOxmOfbField_TableMetadata{
+ TableMetadata: val.(uint64),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+ field.Value = &voltha.OfpOxmOfbField_EthType{
+ EthType: uint32(val.(ofp.EthernetType)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+ field.Value = &voltha.OfpOxmOfbField_IpProto{
+ IpProto: uint32(val.(ofp.IpPrototype)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+ field.Value = &voltha.OfpOxmOfbField_UdpSrc{
+ UdpSrc: uint32(val.(uint16)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+ field.Value = &voltha.OfpOxmOfbField_UdpDst{
+ UdpDst: uint32(val.(uint16)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+ field.Value = &voltha.OfpOxmOfbField_VlanVid{
+ VlanVid: uint32((val.(uint16) & 0xfff) | 0x1000),
+ }
+ }
+ oxmList = append(oxmList, &ofpOxmField)
+ }
+
+ // Construct the instructions
+ var instructions []*voltha.OfpInstruction
+ for _, ofpInstruction := range flowAdd.GetInstructions() {
+ instructionType := ofpInstruction.GetType()
+ instruction := voltha.OfpInstruction{Type: uint32(instructionType)}
+ switch instructionType {
+ case ofp.OFPITGotoTable:
+ instruction.Data = &openflow_13.OfpInstruction_GotoTable{
+ GotoTable: &openflow_13.OfpInstructionGotoTable{
+ TableId: uint32(ofpInstruction.(ofp.IInstructionGotoTable).GetTableId()),
+ },
+ }
+ case ofp.OFPITWriteMetadata:
+ instruction.Data = &openflow_13.OfpInstruction_WriteMetadata{
+ WriteMetadata: &openflow_13.OfpInstructionWriteMetadata{
+ Metadata: ofpInstruction.(ofp.IInstructionWriteMetadata).GetMetadata(),
+ MetadataMask: ofpInstruction.(ofp.IInstructionWriteMetadata).GetMetadataMask(),
+ },
+ }
+ case ofp.OFPITWriteActions:
+ var ofpActions []*openflow_13.OfpAction
+ for _, action := range ofpInstruction.(ofp.IInstructionWriteActions).GetActions() {
+ ofpActions = append(ofpActions, extractAction(action))
+ }
+ instruction.Data = &openflow_13.OfpInstruction_Actions{
+ Actions: &openflow_13.OfpInstructionActions{
+ Actions: ofpActions,
+ },
+ }
+ case ofp.OFPITApplyActions:
+ var ofpActions []*openflow_13.OfpAction
+ for _, action := range ofpInstruction.(ofp.IInstructionApplyActions).GetActions() {
+ ofpActions = append(ofpActions, extractAction(action))
+ }
+ instruction.Data = &openflow_13.OfpInstruction_Actions{
+ Actions: &openflow_13.OfpInstructionActions{
+ Actions: ofpActions,
+ },
+ }
+ case ofp.OFPITMeter:
+ instruction.Data = &openflow_13.OfpInstruction_Meter{
+ Meter: &openflow_13.OfpInstructionMeter{
+ MeterId: ofpInstruction.(ofp.IInstructionMeter).GetMeterId(),
+ },
+ }
+ }
+ instructions = append(instructions, &instruction)
+ }
+
+ // Construct the request
+ flowUpdate := openflow_13.FlowTableUpdate{
+ Id: ofc.DeviceID,
+ FlowMod: &voltha.OfpFlowMod{
+ Cookie: flowAdd.Cookie,
+ CookieMask: flowAdd.CookieMask,
+ TableId: uint32(flowAdd.TableId),
+ Command: voltha.OfpFlowModCommand_OFPFC_ADD,
+ IdleTimeout: uint32(flowAdd.IdleTimeout),
+ HardTimeout: uint32(flowAdd.HardTimeout),
+ Priority: uint32(flowAdd.Priority),
+ BufferId: flowAdd.BufferId,
+ OutPort: uint32(flowAdd.OutPort),
+ OutGroup: uint32(flowAdd.OutGroup),
+ Flags: uint32(flowAdd.Flags),
+ Match: &voltha.OfpMatch{
+ Type: voltha.OfpMatchType(flowAdd.Match.GetType()),
+ OxmFields: oxmList,
+ },
+
+ Instructions: instructions,
+ },
+ }
+ if logger.V(log.DebugLevel) {
+ flowUpdateJs, _ := json.Marshal(flowUpdate)
+ logger.Debugf("FlowUpdate being sent to Voltha",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-mod-request": flowUpdateJs})
+ }
+ if _, err := ofc.VolthaClient.UpdateLogicalDeviceFlowTable(context.Background(), &flowUpdate); err != nil {
+ logger.Errorw("Error calling FlowUpdate ",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
+ }
+}
+
+func (ofc *OFClient) handleFlowMod(flowMod *ofp.FlowMod) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(flowMod)
+ logger.Debugw("handleMod called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-mod": js})
+ }
+ logger.Errorw("handleFlowMod not implemented",
+ log.Fields{"device-id": ofc.DeviceID})
+}
+
+func (ofc *OFClient) handleFlowModStrict(flowModStrict *ofp.FlowModifyStrict) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(flowModStrict)
+ logger.Debugw("handleFlowModStrict called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-mod-strict": js})
+ }
+ logger.Error("handleFlowModStrict not implemented",
+ log.Fields{"device-id": ofc.DeviceID})
+}
+
+func (ofc *OFClient) handleFlowDelete(flowDelete *ofp.FlowDelete) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(flowDelete)
+ logger.Debugw("handleFlowDelete called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-delete": js})
+ }
+ logger.Error("handleFlowDelete not implemented",
+ log.Fields{"device-id": ofc.DeviceID})
+
+}
+
+func (ofc *OFClient) handleFlowDeleteStrict(flowDeleteStrict *ofp.FlowDeleteStrict) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(flowDeleteStrict)
+ logger.Debugw("handleFlowAdd called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-delete-strict": js})
+ }
+
+ // Construct match
+ var oxmList []*voltha.OfpOxmField
+ for _, oxmField := range flowDeleteStrict.Match.GetOxmList() {
+ name := oxmMap[oxmField.GetOXMName()]
+ val := oxmField.GetOXMValue()
+ var ofpOxmField voltha.OfpOxmField
+ ofpOxmField.OxmClass = ofp.OFPXMCOpenflowBasic
+ var field voltha.OfpOxmOfbField
+ field.Type = voltha.OxmOfbFieldTypes(name)
+
+ var x openflow_13.OfpOxmField_OfbField
+ x.OfbField = &field
+ ofpOxmField.Field = &x
+
+ switch voltha.OxmOfbFieldTypes(name) {
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+ field.Value = &voltha.OfpOxmOfbField_Port{
+ Port: uint32(val.(ofp.Port)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
+ field.Value = &voltha.OfpOxmOfbField_PhysicalPort{
+ PhysicalPort: val.(uint32),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+ field.Value = &voltha.OfpOxmOfbField_TableMetadata{
+ TableMetadata: val.(uint64),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+ field.Value = &voltha.OfpOxmOfbField_EthType{
+ EthType: uint32(val.(ofp.EthernetType)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+ field.Value = &voltha.OfpOxmOfbField_IpProto{
+ IpProto: uint32(val.(ofp.IpPrototype)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+ field.Value = &voltha.OfpOxmOfbField_UdpSrc{
+ UdpSrc: uint32(val.(uint16)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+ field.Value = &voltha.OfpOxmOfbField_UdpDst{
+ UdpDst: uint32(val.(uint16)),
+ }
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+ field.Value = &voltha.OfpOxmOfbField_VlanVid{
+ VlanVid: uint32(val.(uint16)),
+ }
+ }
+ oxmList = append(oxmList, &ofpOxmField)
+ }
+
+ // Construct request
+ flowUpdate := openflow_13.FlowTableUpdate{
+ Id: ofc.DeviceID,
+ FlowMod: &voltha.OfpFlowMod{
+ Cookie: flowDeleteStrict.Cookie,
+ CookieMask: flowDeleteStrict.CookieMask,
+ TableId: uint32(flowDeleteStrict.TableId),
+ Command: voltha.OfpFlowModCommand_OFPFC_DELETE_STRICT,
+ IdleTimeout: uint32(flowDeleteStrict.IdleTimeout),
+ HardTimeout: uint32(flowDeleteStrict.HardTimeout),
+ Priority: uint32(flowDeleteStrict.Priority),
+ BufferId: flowDeleteStrict.BufferId,
+ OutPort: uint32(flowDeleteStrict.OutPort),
+ OutGroup: uint32(flowDeleteStrict.OutGroup),
+ Flags: uint32(flowDeleteStrict.Flags),
+ Match: &voltha.OfpMatch{
+ Type: voltha.OfpMatchType(flowDeleteStrict.Match.GetType()),
+ OxmFields: oxmList,
+ },
+ },
+ }
+
+ if logger.V(log.DebugLevel) {
+ flowUpdateJs, _ := json.Marshal(flowUpdate)
+ logger.Debugf("FlowUpdate being sent to Voltha",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "flow-update": flowUpdateJs})
+ }
+ if _, err := ofc.VolthaClient.UpdateLogicalDeviceFlowTable(context.Background(), &flowUpdate); err != nil {
+ logger.Errorw("Error calling FlowUpdate ",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
+ }
+}
diff --git a/openflow/getConfig.go b/internal/pkg/openflow/getConfig.go
similarity index 62%
rename from openflow/getConfig.go
rename to internal/pkg/openflow/getConfig.go
index 3cce700..6d373e9 100644
--- a/openflow/getConfig.go
+++ b/internal/pkg/openflow/getConfig.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,24 +18,28 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleGetConfigRequest(request *ofp.GetConfigRequest, DeviceID string, client *Client) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleGetConfigRequest(request *ofp.GetConfigRequest) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleGetConfigRequest called", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleGetConfigRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
reply := ofp.NewGetConfigReply()
reply.SetVersion(4)
reply.SetXid(request.GetXid())
reply.SetMissSendLen(ofp.OFPCMLNoBuffer)
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(reply)
- logger.Debugw("handleGetConfigRequest reply", l.Fields{"DeviceID": DeviceID, "reply": js})
+ logger.Debugw("handleGetConfigRequest reply",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "reply": js})
}
- client.SendMessage(reply)
+ ofc.SendMessage(reply)
}
diff --git a/openflow/meter.go b/internal/pkg/openflow/meter.go
similarity index 67%
rename from openflow/meter.go
rename to internal/pkg/openflow/meter.go
index ea1f552..d4843fa 100644
--- a/openflow/meter.go
+++ b/internal/pkg/openflow/meter.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+Copyright 2020 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.
@@ -17,34 +17,31 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
"github.com/opencord/voltha-protos/v2/go/openflow_13"
"golang.org/x/net/context"
)
-func handleMeterModRequest(request *ofp.MeterMod, DeviceID string, client *Client) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleMeterModRequest(request *ofp.MeterMod) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleMeterModRequest called", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleMeterModRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
- var meterModUpdate openflow_13.MeterModUpdate
- meterModUpdate.Id = DeviceID
- var meterMod openflow_13.OfpMeterMod
- meterMod.MeterId = request.MeterId
- meterMod.Flags = uint32(request.Flags)
- command := openflow_13.OfpMeterModCommand(request.Command)
- meterMod.Command = command
+ meterModUpdate := openflow_13.MeterModUpdate{Id: ofc.DeviceID}
+ meterMod := openflow_13.OfpMeterMod{
+ MeterId: request.MeterId,
+ Flags: uint32(request.Flags),
+ Command: openflow_13.OfpMeterModCommand(request.Command),
+ }
var bands []*openflow_13.OfpMeterBandHeader
- ofpBands := request.GetMeters()
- for i := 0; i < len(ofpBands); i++ {
- ofpBand := ofpBands[i]
- bandType := ofpBand.GetType()
+ for _, ofpBand := range request.GetMeters() {
var band openflow_13.OfpMeterBandHeader
- switch bandType {
+ switch ofpBand.GetType() {
case ofp.OFPMBTDrop:
ofpDrop := ofpBand.(ofp.IMeterBandDrop)
band.Type = openflow_13.OfpMeterBandType_OFPMBT_DROP
@@ -81,14 +78,17 @@
}
meterMod.Bands = bands
meterModUpdate.MeterMod = &meterMod
- grpcClient := *getGrpcClient()
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
meterModJS, _ := json.Marshal(meterModUpdate)
logger.Debugw("handleMeterModUpdate sending request",
- l.Fields{"DeviceID": DeviceID, "MeterModRequest": meterModJS})
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "meter-mod-request": meterModJS})
}
- _, err := grpcClient.UpdateLogicalDeviceMeterTable(context.Background(), &meterModUpdate)
- if err != nil {
- logger.Errorw("Error calling UpdateLogicalDeviceMeterTable", l.Fields{"DeviceID": DeviceID, "error": err})
+ if _, err := ofc.VolthaClient.UpdateLogicalDeviceMeterTable(context.Background(), &meterModUpdate); err != nil {
+ logger.Errorw("Error calling UpdateLogicalDeviceMeterTable",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "error": err})
}
}
diff --git a/internal/pkg/openflow/packet.go b/internal/pkg/openflow/packet.go
new file mode 100644
index 0000000..dc26594
--- /dev/null
+++ b/internal/pkg/openflow/packet.go
@@ -0,0 +1,62 @@
+/*
+ Copyright 2020 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-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
+)
+
+func (ofc *OFClient) handlePacketOut(packetOut *ofp.PacketOut) {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(packetOut)
+ logger.Debugw("handlePacketOut called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "packet-out": js})
+ }
+
+ // Collection actions
+ var actions []*voltha.OfpAction
+ for _, action := range packetOut.GetActions() {
+ actions = append(actions, extractAction(action))
+ }
+
+ // Build packet out
+ pbPacketOut := voltha.PacketOut{
+ Id: ofc.DeviceID,
+ PacketOut: &voltha.OfpPacketOut{
+ BufferId: packetOut.GetBufferId(),
+ InPort: uint32(packetOut.GetInPort()),
+ Actions: actions,
+ Data: packetOut.GetData(),
+ },
+ }
+
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(pbPacketOut)
+ logger.Debugw("handlePacketOut sending",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "packet-out": js})
+ }
+
+ // Queue it
+ ofc.PacketOutChannel <- &pbPacketOut
+}
diff --git a/openflow/parseGrpcReturn.go b/internal/pkg/openflow/parseGrpcReturn.go
similarity index 76%
rename from openflow/parseGrpcReturn.go
rename to internal/pkg/openflow/parseGrpcReturn.go
index 30ec672..f4177d1 100644
--- a/openflow/parseGrpcReturn.go
+++ b/internal/pkg/openflow/parseGrpcReturn.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -17,53 +17,54 @@
import (
"encoding/json"
-
"github.com/donNewtonAlpha/goloxi"
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
"github.com/opencord/voltha-protos/v2/go/openflow_13"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
+ "github.com/opencord/voltha-protos/v2/go/voltha"
)
func parseOxm(ofbField *openflow_13.OfpOxmOfbField, DeviceID string) (goloxi.IOxm, uint16) {
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(ofbField)
- logger.Debugw("parseOxm called", l.Fields{"DeviceID": DeviceID, "ofbField": js})
+ logger.Debugw("parseOxm called",
+ log.Fields{
+ "device-id": DeviceID,
+ "ofbField": js})
}
switch ofbField.Type {
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+ case voltha.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:
+ case voltha.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:
+ case voltha.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:
+ case voltha.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:
+ case voltha.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:
+ case voltha.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:
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
ofpVlanVid := ofp.NewOxmVlanVid()
val := ofbField.GetValue()
if val != nil {
@@ -73,21 +74,30 @@
ofpVlanVid.Value = uint16(0)
}
return ofpVlanVid, 2
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+ case voltha.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
ofpMetadata := ofp.NewOxmMetadata()
val := ofbField.GetValue().(*openflow_13.OfpOxmOfbField_TableMetadata)
ofpMetadata.Value = val.TableMetadata
return ofpMetadata, 8
default:
- js, _ := json.Marshal(ofbField)
- logger.Warnw("ParseOXM Unhandled OxmField", l.Fields{"DeviceID": DeviceID, "OfbField": js})
+ if logger.V(log.WarnLevel) {
+ js, _ := json.Marshal(ofbField)
+ logger.Warnw("ParseOXM Unhandled OxmField",
+ log.Fields{
+ "device-id": DeviceID,
+ "OfbField": js})
+ }
}
return nil, 0
}
+
func parseInstructions(ofpInstruction *openflow_13.OfpInstruction, DeviceID string) (ofp.IInstruction, uint16) {
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(ofpInstruction)
- logger.Debugw("parseInstructions called", l.Fields{"DeviceID": DeviceID, "Instruction": js})
+ logger.Debugw("parseInstructions called",
+ log.Fields{
+ "device-id": DeviceID,
+ "Instruction": js})
}
instType := ofpInstruction.Type
data := ofpInstruction.GetData()
@@ -114,10 +124,9 @@
instruction := ofp.NewInstructionApplyActions()
var instructionSize uint16
instructionSize = 8
- ofpActions := ofpInstruction.GetActions().Actions
+ //ofpActions := ofpInstruction.GetActions().Actions
var actions []goloxi.IAction
- for i := 0; i < len(ofpActions); i++ {
- ofpAction := ofpActions[i]
+ for _, ofpAction := range ofpInstruction.GetActions().Actions {
action, actionSize := parseAction(ofpAction, DeviceID)
actions = append(actions, action)
instructionSize += actionSize
@@ -125,20 +134,27 @@
}
instruction.Actions = actions
instruction.SetLen(instructionSize)
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(instruction)
- l.Debugw("parseInstructions returning", l.Fields{"DeviceID": DeviceID,
- "Size": instructionSize, "ParsedInstruction": js})
+ logger.Debugw("parseInstructions returning",
+ log.Fields{
+ "device-id": DeviceID,
+ "size": instructionSize,
+ "parsed-instruction": js})
}
return instruction, instructionSize
}
//shouldn't have reached here :<
return nil, 0
}
+
func parseAction(ofpAction *openflow_13.OfpAction, DeviceID string) (goloxi.IAction, uint16) {
- if settings.GetDebug(DeviceID) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(ofpAction)
- logger.Debugw("parseAction called", l.Fields{"DeviceID": DeviceID, "Action": js})
+ logger.Debugw("parseAction called",
+ log.Fields{
+ "device-id": DeviceID,
+ "action": js})
}
switch ofpAction.Type {
case openflow_13.OfpActionType_OFPAT_OUTPUT:
@@ -166,12 +182,18 @@
setFieldAction.Len = 16
return setFieldAction, 16
default:
- js, _ := json.Marshal(ofpAction)
- logger.Warnw("parseAction unknow action", l.Fields{"DeviceID": DeviceID, "Action": js})
+ if logger.V(log.WarnLevel) {
+ js, _ := json.Marshal(ofpAction)
+ logger.Warnw("parseAction unknow action",
+ log.Fields{
+ "device-id": DeviceID,
+ "action": js})
+ }
}
return nil, 0
}
-func parsePortStats(port *pb.LogicalPort) ofp.PortStatsEntry {
+
+func parsePortStats(port *voltha.LogicalPort) *ofp.PortStatsEntry {
stats := port.OfpPortStats
port.OfpPort.GetPortNo()
var entry ofp.PortStatsEntry
@@ -190,5 +212,5 @@
entry.SetCollisions(stats.GetCollisions())
entry.SetDurationSec(stats.GetDurationSec())
entry.SetDurationNsec(stats.GetDurationNsec())
- return entry
+ return &entry
}
diff --git a/openflow/role.go b/internal/pkg/openflow/role.go
similarity index 69%
rename from openflow/role.go
rename to internal/pkg/openflow/role.go
index 3ca3e93..3b7bf2f 100644
--- a/openflow/role.go
+++ b/internal/pkg/openflow/role.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,21 +18,22 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleRoleRequest(request *ofp.RoleRequest, DeviceID string, client *Client) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleRoleRequest(request *ofp.RoleRequest) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleRoleRequest called", l.Fields{"DeviceID": client.DeviceID, "request": js})
+ logger.Debugw("handleRoleRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
reply := ofp.NewRoleReply()
reply.SetXid(request.GetXid())
reply.SetVersion(request.GetVersion())
reply.SetRole(request.GetRole())
reply.SetGenerationId(request.GetGenerationId())
- client.SendMessage(reply)
+ ofc.SendMessage(reply)
}
diff --git a/openflow/setConfig.go b/internal/pkg/openflow/setConfig.go
similarity index 67%
rename from openflow/setConfig.go
rename to internal/pkg/openflow/setConfig.go
index 3c789fd..d1c52ac 100644
--- a/openflow/setConfig.go
+++ b/internal/pkg/openflow/setConfig.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,16 +18,17 @@
import (
"encoding/json"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
)
-func handleSetConfig(request *ofp.SetConfig, DeviceID string) {
- if settings.GetDebug(DeviceID) {
+func (ofc *OFClient) handleSetConfig(request *ofp.SetConfig) {
+ if logger.V(log.DebugLevel) {
js, _ := json.Marshal(request)
- logger.Debugw("handleSetConfig called", l.Fields{"DeviceID": DeviceID, "request": js})
+ logger.Debugw("handleSetConfig called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": js})
}
}
diff --git a/internal/pkg/openflow/stats.go b/internal/pkg/openflow/stats.go
new file mode 100644
index 0000000..68d2625
--- /dev/null
+++ b/internal/pkg/openflow/stats.go
@@ -0,0 +1,619 @@
+/*
+ Copyright 2020 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 (
+ "context"
+ "encoding/json"
+ "github.com/donNewtonAlpha/goloxi"
+ ofp "github.com/donNewtonAlpha/goloxi/of13"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "github.com/opencord/voltha-protos/v2/go/common"
+ "github.com/opencord/voltha-protos/v2/go/openflow_13"
+ "net"
+ "unsafe"
+)
+
+func (ofc *OFClient) handleStatsRequest(request ofp.IHeader, statType uint16) error {
+ if logger.V(log.DebugLevel) {
+ js, _ := json.Marshal(request)
+ logger.Debugw("handleStatsRequest called",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "stat-type": statType,
+ "request": js})
+ }
+
+ switch statType {
+ case ofp.OFPSTDesc:
+ statsReq := request.(*ofp.DescStatsRequest)
+ response, err := ofc.handleDescStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTFlow:
+ statsReq := request.(*ofp.FlowStatsRequest)
+ response, err := ofc.handleFlowStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ response.Length = uint16(unsafe.Sizeof(*response))
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+
+ case ofp.OFPSTAggregate:
+ statsReq := request.(*ofp.AggregateStatsRequest)
+ response, err := ofc.handleAggregateStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTTable:
+ statsReq := request.(*ofp.TableStatsRequest)
+ response, e := ofc.handleTableStatsRequest(statsReq)
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ if e != nil {
+ return e
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTPort:
+ statsReq := request.(*ofp.PortStatsRequest)
+ response, err := ofc.handlePortStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTQueue:
+ statsReq := request.(*ofp.QueueStatsRequest)
+ response, err := ofc.handleQueueStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTGroup:
+ statsReq := request.(*ofp.GroupStatsRequest)
+ response, err := ofc.handleGroupStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ ofc.SendMessage(response)
+ case ofp.OFPSTGroupDesc:
+ statsReq := request.(*ofp.GroupDescStatsRequest)
+ response, err := ofc.handleGroupStatsDescRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+
+ case ofp.OFPSTGroupFeatures:
+ statsReq := request.(*ofp.GroupFeaturesStatsRequest)
+ response, err := ofc.handleGroupFeatureStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTMeter:
+ statsReq := request.(*ofp.MeterStatsRequest)
+ response, err := ofc.handleMeterStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTMeterConfig:
+ statsReq := request.(*ofp.MeterConfigStatsRequest)
+ response, err := ofc.handleMeterConfigStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTMeterFeatures:
+ statsReq := request.(*ofp.MeterFeaturesStatsRequest)
+ response, err := ofc.handleMeterFeatureStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTTableFeatures:
+ statsReq := request.(*ofp.TableFeaturesStatsRequest)
+ response, err := ofc.handleTableFeaturesStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ case ofp.OFPSTPortDesc:
+ statsReq := request.(*ofp.PortDescStatsRequest)
+ response, err := ofc.handlePortDescStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+
+ case ofp.OFPSTExperimenter:
+ statsReq := request.(*ofp.ExperimenterStatsRequest)
+ response, err := ofc.handleExperimenterStatsRequest(statsReq)
+ if err != nil {
+ return err
+ }
+ if logger.V(log.DebugLevel) {
+ reqJs, _ := json.Marshal(statsReq)
+ resJs, _ := json.Marshal(response)
+ logger.Debugw("handle-stats-request",
+ log.Fields{
+ "device-id": ofc.DeviceID,
+ "request": reqJs,
+ "response": resJs})
+ }
+ return ofc.SendMessage(response)
+ }
+ return nil
+}
+
+func (ofc *OFClient) handleDescStatsRequest(request *ofp.DescStatsRequest) (*ofp.DescStatsReply, error) {
+ response := ofp.NewDescStatsReply()
+ response.SetXid(request.GetXid())
+ response.SetVersion(request.GetVersion())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+
+ resp, err := ofc.VolthaClient.GetLogicalDevice(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ desc := resp.GetDesc()
+
+ response.SetMfrDesc(PadString(desc.GetMfrDesc(), 256))
+ response.SetHwDesc(PadString(desc.GetHwDesc(), 256))
+ response.SetSwDesc(PadString(desc.GetSwDesc(), 256))
+ response.SetSerialNum(PadString(desc.GetSerialNum(), 32))
+ response.SetDpDesc(PadString(desc.GetDpDesc(), 256))
+ return response, nil
+}
+
+func (ofc *OFClient) handleFlowStatsRequest(request *ofp.FlowStatsRequest) (*ofp.FlowStatsReply, error) {
+ response := ofp.NewFlowStatsReply()
+ response.SetXid(request.GetXid())
+ response.SetVersion(4)
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ resp, err := ofc.VolthaClient.ListLogicalDeviceFlows(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ var flow []*ofp.FlowStatsEntry
+ for _, item := range resp.GetItems() {
+ entry := ofp.NewFlowStatsEntry()
+ entry.SetTableId(uint8(item.GetTableId()))
+ entry.SetDurationSec(item.GetDurationSec())
+ entry.SetDurationNsec(item.GetDurationNsec())
+ entry.SetPriority(uint16(item.GetPriority()))
+ entry.SetIdleTimeout(uint16(item.GetIdleTimeout()))
+ entry.SetHardTimeout(uint16(item.GetHardTimeout()))
+ entry.SetFlags(ofp.FlowModFlags(item.GetFlags()))
+ entry.SetCookie(item.GetCookie())
+ entry.SetPacketCount(item.GetPacketCount())
+ entry.SetByteCount(item.GetByteCount())
+ entrySize := uint16(48)
+ match := ofp.NewMatchV3()
+ pbMatch := item.GetMatch()
+ match.SetType(uint16(pbMatch.GetType()))
+ size := uint16(4)
+ var fields []goloxi.IOxm
+ for _, oxmField := range pbMatch.GetOxmFields() {
+ field := oxmField.GetField()
+ ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
+ iOxm, oxmSize := parseOxm(ofbField, ofc.DeviceID)
+ fields = append(fields, iOxm)
+ if oxmSize > 0 {
+ size += 4 //header for oxm
+ }
+ size += oxmSize
+ }
+
+ match.OxmList = fields
+ match.Length = uint16(size)
+ //account for 8 byte alignment
+ if size%8 != 0 {
+ size = ((size / 8) + 1) * 8
+ }
+ entrySize += size
+ entry.SetMatch(*match)
+ var instructions []ofp.IInstruction
+ for _, ofpInstruction := range item.Instructions {
+ instruction, size := parseInstructions(ofpInstruction, ofc.DeviceID)
+ instructions = append(instructions, instruction)
+ entrySize += size
+ }
+ entry.Instructions = instructions
+ entry.Length = entrySize
+ entrySize = 0
+ flow = append(flow, entry)
+ }
+ response.SetEntries(flow)
+ return response, nil
+}
+
+func (ofc *OFClient) handleAggregateStatsRequest(request *ofp.AggregateStatsRequest) (*ofp.AggregateStatsReply, error) {
+ 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
+}
+
+func (ofc *OFClient) handleGroupStatsRequest(request *ofp.GroupStatsRequest) (*ofp.GroupStatsReply, error) {
+ response := ofp.NewGroupStatsReply()
+ response.SetVersion(request.GetVersion())
+ response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ reply, err := ofc.VolthaClient.ListLogicalDeviceFlowGroups(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+
+ var groupStatsEntries []*ofp.GroupStatsEntry
+ for _, item := range reply.GetItems() {
+ stats := item.GetStats()
+ var entry ofp.GroupStatsEntry
+ entry.SetByteCount(stats.GetByteCount())
+ entry.SetPacketCount(stats.GetPacketCount())
+ entry.SetDurationNsec(stats.GetDurationNsec())
+ entry.SetDurationSec(stats.GetDurationSec())
+ entry.SetRefCount(stats.GetRefCount())
+ entry.SetGroupId(stats.GetGroupId())
+ var bucketStatsList []*ofp.BucketCounter
+ for _, bucketStat := range stats.GetBucketStats() {
+ bucketCounter := ofp.BucketCounter{}
+ bucketCounter.SetPacketCount(bucketStat.GetPacketCount())
+ bucketCounter.SetByteCount(bucketStat.GetByteCount())
+ bucketStatsList = append(bucketStatsList, &bucketCounter)
+ }
+ entry.SetBucketStats(bucketStatsList)
+ groupStatsEntries = append(groupStatsEntries, &entry)
+ }
+ response.SetEntries(groupStatsEntries)
+ return response, nil
+}
+
+func (ofc *OFClient) handleGroupStatsDescRequest(request *ofp.GroupDescStatsRequest) (*ofp.GroupDescStatsReply, error) {
+ response := ofp.NewGroupDescStatsReply()
+ response.SetVersion(request.GetVersion())
+ response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ reply, err := ofc.VolthaClient.ListLogicalDeviceFlowGroups(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ var groupDescStatsEntries []*ofp.GroupDescStatsEntry
+ for _, item := range reply.GetItems() {
+ stats := item.GetStats()
+ var groupDesc ofp.GroupDescStatsEntry
+ groupDesc.SetGroupId(stats.GetGroupId())
+ /*
+ buckets := item.g
+ var bucketList []*ofp.Bucket
+ for j:=0;j<len(buckets);j++{
+
+ }
+
+ groupDesc.SetBuckets(bucketList)
+ */
+ groupDescStatsEntries = append(groupDescStatsEntries, &groupDesc)
+ }
+ response.SetEntries(groupDescStatsEntries)
+ return response, nil
+}
+
+func (ofc *OFClient) handleGroupFeatureStatsRequest(request *ofp.GroupFeaturesStatsRequest) (*ofp.GroupFeaturesStatsReply, error) {
+ 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
+}
+
+func (ofc *OFClient) handleMeterStatsRequest(request *ofp.MeterStatsRequest) (*ofp.MeterStatsReply, error) {
+ response := ofp.NewMeterStatsReply()
+ response.SetVersion(request.GetVersion())
+ response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ resp, err := ofc.VolthaClient.ListLogicalDeviceMeters(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ size := uint16(40)
+ var meterStats []*ofp.MeterStats
+ for _, item := range resp.Items {
+ meterStat := ofp.NewMeterStats()
+ 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
+ for _, bStat := range stats.BandStats {
+ 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
+}
+
+func (ofc *OFClient) handleMeterConfigStatsRequest(request *ofp.MeterConfigStatsRequest) (*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
+}
+
+func (ofc *OFClient) handleTableFeaturesStatsRequest(request *ofp.TableFeaturesStatsRequest) (*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 (ofc *OFClient) handleTableStatsRequest(request *ofp.TableStatsRequest) (*ofp.TableStatsReply, error) {
+ 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 (ofc *OFClient) handleQueueStatsRequest(request *ofp.QueueStatsRequest) (*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
+}
+
+func (ofc *OFClient) handlePortStatsRequest(request *ofp.PortStatsRequest) (*ofp.PortStatsReply, error) {
+ response := ofp.NewPortStatsReply()
+ response.SetXid(request.GetXid())
+ response.SetVersion(request.GetVersion())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ reply, err := ofc.VolthaClient.ListLogicalDevicePorts(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ var entries []*ofp.PortStatsEntry
+ if request.GetPortNo() == 0xffffffff { //all ports
+ for _, port := range reply.GetItems() {
+ entries = append(entries, parsePortStats(port))
+ }
+ } else { //find right port that is requested
+ for _, port := range reply.GetItems() {
+ if port.GetOfpPortStats().GetPortNo() == uint32(request.GetPortNo()) {
+ entries = append(entries, parsePortStats(port))
+ }
+ }
+ }
+ response.SetEntries(entries)
+ return response, nil
+}
+
+func (ofc *OFClient) handlePortDescStatsRequest(request *ofp.PortDescStatsRequest) (*ofp.PortDescStatsReply, error) {
+ response := ofp.NewPortDescStatsReply()
+ response.SetVersion(request.GetVersion())
+ response.SetXid(request.GetXid())
+ response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
+ logicalDevice, err := ofc.VolthaClient.GetLogicalDevice(context.Background(),
+ &common.ID{Id: ofc.DeviceID})
+ if err != nil {
+ return nil, err
+ }
+ var entries []*ofp.PortDesc
+ for _, port := range logicalDevice.GetPorts() {
+ ofpPort := port.GetOfpPort()
+ var entry ofp.PortDesc
+ entry.SetPortNo(ofp.Port(ofpPort.GetPortNo()))
+
+ var octets []byte
+ for _, val := range ofpPort.GetHwAddr() {
+ octets = append(octets, byte(val))
+ }
+ hwAddr := net.HardwareAddr(octets)
+ entry.SetHwAddr(hwAddr)
+ entry.SetName(PadString(ofpPort.GetName(), 16))
+ entry.SetConfig(ofp.PortConfig(ofpPort.GetConfig()))
+ entry.SetState(ofp.PortState(ofpPort.GetState()))
+ entry.SetCurr(ofp.PortFeatures(ofpPort.GetCurr()))
+ entry.SetAdvertised(ofp.PortFeatures(ofpPort.GetAdvertised()))
+ entry.SetSupported(ofp.PortFeatures(ofpPort.GetSupported()))
+ entry.SetPeer(ofp.PortFeatures(ofpPort.GetPeer()))
+ entry.SetCurrSpeed(ofpPort.GetCurrSpeed())
+ entry.SetMaxSpeed(ofpPort.GetMaxSpeed())
+
+ entries = append(entries, &entry)
+ }
+
+ response.SetEntries(entries)
+ //TODO call voltha and get port descriptions etc
+ return response, nil
+
+}
+
+func (ofc *OFClient) handleMeterFeatureStatsRequest(request *ofp.MeterFeaturesStatsRequest) (*ofp.MeterFeaturesStatsReply, error) {
+ 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 (ofc *OFClient) handleExperimenterStatsRequest(request *ofp.ExperimenterStatsRequest) (*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/internal/pkg/openflow/utils.go
similarity index 98%
rename from openflow/utils.go
rename to internal/pkg/openflow/utils.go
index d87c338..f2d72e0 100644
--- a/openflow/utils.go
+++ b/internal/pkg/openflow/utils.go
@@ -1,5 +1,5 @@
/*
- Copyright 2017 the original author or authors.
+ Copyright 2020 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.
@@ -18,11 +18,10 @@
import (
"fmt"
- "strings"
- "sync"
-
ofp "github.com/donNewtonAlpha/goloxi/of13"
"github.com/opencord/voltha-protos/v2/go/openflow_13"
+ "strings"
+ "sync"
)
var mu sync.Mutex
diff --git a/main.go b/main.go
deleted file mode 100644
index 1be60a4..0000000
--- a/main.go
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- Copyright 2019 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 main
-
-import (
- "flag"
-
- "github.com/opencord/ofagent-go/settings"
-
- "github.com/opencord/ofagent-go/grpc"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
-)
-
-func main() {
- debug := flag.Bool("debug", false, "Set Debug Level Logging")
- var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to `file`")
- var memprofile = flag.String("memprofile", "", "write memory profile to `file`")
-
- openflowAddress := flag.String("ofaddress", "localhost", "address of the openflow server")
- openflowPort := flag.Uint("openflowPort", 6653, "port the openflow server is listening on")
- volthaAddress := flag.String("volthaAddress", "localhost", "address for voltha core / afrouter")
- volthaPort := flag.Uint("volthaPort", 50057, "port that voltha core / afrouter listens on ")
- flag.Parse()
-
- logLevel := l.InfoLevel
- if *debug {
- logLevel = l.DebugLevel
- settings.SetDebug(true)
- } else {
- settings.SetDebug(false)
- }
- _, err := l.AddPackage(l.JSON, logLevel, nil)
- if err != nil {
- l.Errorw("unable-to-register-package-to-the-log-map", l.Fields{"error": err})
- }
- l.Infow("ofagent-startup params", l.Fields{"OpenFlowAddress": *openflowAddress,
- "OpenFlowPort": *openflowPort,
- "VolthaAddress": *volthaAddress,
- "VolthaPort": *volthaPort,
- "LogLevel": logLevel,
- "CpuProfile": *cpuprofile,
- "MemProfile": *memprofile})
-
- grpc.StartClient(*volthaAddress, uint16(*volthaPort), *openflowAddress, uint16(*openflowPort))
-}
diff --git a/openflow/feature.go b/openflow/feature.go
deleted file mode 100644
index ebfca92..0000000
--- a/openflow/feature.go
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- 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 (
- "context"
- "encoding/json"
-
- "github.com/opencord/ofagent-go/settings"
-
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- "github.com/opencord/voltha-protos/v2/go/common"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
-)
-
-func handleFeatureRequest(request *ofp.FeaturesRequest, DeviceID string, client *Client) error {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(request)
- logger.Debugw("handleFeatureRequest called", l.Fields{"DeviceID": DeviceID, "request": js})
- }
- var grpcClient = *getGrpcClient()
- var id = common.ID{Id: DeviceID}
- logicalDevice, err := grpcClient.GetLogicalDevice(context.Background(), &id)
- reply := createFeaturesRequestReply(request.GetXid(), logicalDevice)
-
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(reply)
- logger.Debugw("handleFeatureRequestReturn", l.Fields{"DeviceID": DeviceID, "reply": js})
- }
- err = client.SendMessage(reply)
- return err
-}
-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())
- featureReply.SetNBuffers(features.GetNBuffers())
- featureReply.SetNTables(uint8(features.GetNTables()))
- featureReply.SetAuxiliaryId(uint8(features.GetAuxiliaryId()))
- capabilities := features.GetCapabilities()
- featureReply.SetCapabilities(ofp.Capabilities(capabilities))
- return featureReply
-}
diff --git a/openflow/flowMod.go b/openflow/flowMod.go
deleted file mode 100644
index eb6ba02..0000000
--- a/openflow/flowMod.go
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- 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 (
- "context"
- "encoding/json"
-
- "github.com/opencord/ofagent-go/settings"
-
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- "github.com/opencord/voltha-protos/v2/go/openflow_13"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
-)
-
-var oxmMap = map[string]int32{
- "in_port": 0,
- "in_phy_port": 1,
- "metadata": 2,
- "eth_dst": 3,
- "eth_src": 4,
- "eth_type": 5,
- "vlan_vid": 6,
- "vlan_pcp": 7,
- "ip_dscp": 8,
- "ip_ecn": 9,
- "ip_proto": 10,
- "ipv4_src": 11,
- "ipv4_dst": 12,
- "tcp_src": 13,
- "tcp_dst": 14,
- "udp_src": 15,
- "udp_dst": 16,
- "sctp_src": 17,
- "sctp_dst": 18,
- "icmpv4_type": 19,
- "icmpv4_code": 20,
- "arp_op": 21,
- "arp_spa": 22,
- "arp_tpa": 23,
- "arp_sha": 24,
- "arp_tha": 25,
- "ipv6_src": 26,
- "ipv6_dst": 27,
- "ipv6_flabel": 28,
- "icmpv6_type": 29,
- "icmpv6_code": 30,
- "ipv6_nd_target": 31,
- "ipv6_nd_sll": 32,
- "ipv6_nd_tll": 33,
- "mpls_label": 34,
- "mpls_tc": 35,
- "mpls_bos": 36,
- "pbb_isid": 37,
- "tunnel_id": 38,
- "ipv6_exthdr": 39,
-}
-
-func handleFlowAdd(flowAdd *ofp.FlowAdd, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(flowAdd)
- logger.Debugw("handleFlowAdd called", l.Fields{"DeviceID": DeviceID, "params": js})
- }
-
- var flowUpdate openflow_13.FlowTableUpdate
- flowUpdate.Id = DeviceID
- var flowMod pb.OfpFlowMod
- flowMod.Cookie = flowAdd.Cookie
- flowMod.CookieMask = flowAdd.CookieMask
- flowMod.TableId = uint32(flowAdd.TableId)
- flowMod.Command = pb.OfpFlowModCommand_OFPFC_ADD
- flowMod.IdleTimeout = uint32(flowAdd.IdleTimeout)
- flowMod.HardTimeout = uint32(flowAdd.HardTimeout)
- flowMod.Priority = uint32(flowAdd.Priority)
- flowMod.BufferId = flowAdd.BufferId
- flowMod.OutPort = uint32(flowAdd.OutPort)
- flowMod.OutGroup = uint32(flowAdd.OutGroup)
- flowMod.Flags = uint32(flowAdd.Flags)
- inMatch := flowAdd.Match
- var flowMatch pb.OfpMatch
- flowMatch.Type = pb.OfpMatchType(inMatch.GetType())
- var oxmList []*pb.OfpOxmField
- inOxmList := inMatch.GetOxmList()
- for i := 0; i < len(inOxmList); i++ {
- oxmField := inOxmList[i]
- name := oxmMap[oxmField.GetOXMName()]
- val := oxmField.GetOXMValue()
- var ofpOxmField pb.OfpOxmField
- ofpOxmField.OxmClass = ofp.OFPXMCOpenflowBasic
- var field pb.OfpOxmOfbField
- field.Type = pb.OxmOfbFieldTypes(name)
- var x openflow_13.OfpOxmField_OfbField
- x.OfbField = &field
- ofpOxmField.Field = &x
- switch pb.OxmOfbFieldTypes(name) {
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
- port := val.(ofp.Port)
- var value pb.OfpOxmOfbField_Port
- value.Port = uint32(port)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
- phyPort := val.(uint32)
- var value pb.OfpOxmOfbField_PhysicalPort
- value.PhysicalPort = phyPort
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
- metadata := val.(uint64)
- var value pb.OfpOxmOfbField_TableMetadata
- value.TableMetadata = metadata
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
- ethType := val.(ofp.EthernetType)
- var value pb.OfpOxmOfbField_EthType
- value.EthType = uint32(ethType)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
- proto := val.(ofp.IpPrototype)
- var value pb.OfpOxmOfbField_IpProto
- value.IpProto = uint32(proto)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
- udpSrc := val.(uint16)
- var value pb.OfpOxmOfbField_UdpSrc
- value.UdpSrc = uint32(udpSrc)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
- udpDst := val.(uint16)
- var value pb.OfpOxmOfbField_UdpDst
- value.UdpDst = uint32(udpDst)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
- vid := (val.(uint16) & 0xfff) | 0x1000
- var value pb.OfpOxmOfbField_VlanVid
- value.VlanVid = uint32(vid)
- field.Value = &value
- }
- oxmList = append(oxmList, &ofpOxmField)
- }
- flowMatch.OxmFields = oxmList
- flowMod.Match = &flowMatch
- var instructions []*pb.OfpInstruction
- ofpInstructions := flowAdd.GetInstructions()
- for i := 0; i < len(ofpInstructions); i++ {
- var instruction pb.OfpInstruction
- ofpInstruction := ofpInstructions[i]
- instructionType := ofpInstruction.GetType()
- instruction.Type = uint32(instructionType)
- switch instructionType {
- 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 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 ofp.OFPITWriteActions:
- writeAction := ofpInstruction.(ofp.IInstructionWriteActions)
- var ofpInstructionActions openflow_13.OfpInstruction_Actions
- var ofpActions []*openflow_13.OfpAction
- actions := writeAction.GetActions()
- for i := 0; i < len(actions); i++ {
- action := actions[i]
- ofpAction := extractAction(action)
- ofpActions = append(ofpActions, ofpAction)
- }
- instruction.Data = &ofpInstructionActions
- case ofp.OFPITApplyActions:
- applyAction := ofpInstruction.(ofp.IInstructionApplyActions)
- var ofpInstructionActions openflow_13.OfpInstruction_Actions
- var ofpActions []*openflow_13.OfpAction
- actions := applyAction.GetActions()
- for i := 0; i < len(actions); i++ {
- action := actions[i]
- ofpAction := extractAction(action)
- ofpActions = append(ofpActions, ofpAction)
- }
- var actionsHolder openflow_13.OfpInstructionActions
- 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)
- }
-
- flowMod.Instructions = instructions
- flowUpdate.FlowMod = &flowMod
- grpcClient := *getGrpcClient()
- if settings.GetDebug(DeviceID) {
- flowUpdateJs, _ := json.Marshal(flowUpdate)
- logger.Debugf("FlowUpdate being sent to Voltha", l.Fields{"DeviceID": DeviceID, "FlowModRequest": flowUpdateJs})
- }
- _, err := grpcClient.UpdateLogicalDeviceFlowTable(context.Background(), &flowUpdate)
- if err != nil {
- logger.Errorw("Error calling FlowUpdate ", l.Fields{"DeviceID": DeviceID, "error": err})
- }
-}
-
-func handleFlowMod(flowMod *ofp.FlowMod, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(flowMod)
- logger.Debugw("handleMod called", l.Fields{"DeviceID": DeviceID, "params": js})
- }
- logger.Error("handleFlowMod not implemented")
-}
-
-func handleFlowModStrict(flowModStrict *ofp.FlowModifyStrict, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(flowModStrict)
- logger.Debugw("handleFlowModStrict called", l.Fields{"DeviceID": DeviceID, "params": js})
- }
- logger.Error("handleFlowModStrict not implemented")
-}
-func handleFlowDelete(flowDelete *ofp.FlowDelete, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(flowDelete)
- logger.Debugw("handleFlowDelete called", l.Fields{"DeviceID": DeviceID, "params": js})
- }
- logger.Error("handleFlowDelete not implemented")
-
-}
-func handleFlowDeleteStrict(flowDeleteStrict *ofp.FlowDeleteStrict, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(flowDeleteStrict)
- logger.Debugw("handleFlowAdd called", l.Fields{"DeviceID": DeviceID, "params": js})
- }
-
- var flowUpdate openflow_13.FlowTableUpdate
- flowUpdate.Id = DeviceID
- var flowMod pb.OfpFlowMod
- flowMod.Cookie = flowDeleteStrict.Cookie
- flowMod.CookieMask = flowDeleteStrict.CookieMask
- flowMod.TableId = uint32(flowDeleteStrict.TableId)
- flowMod.Command = pb.OfpFlowModCommand_OFPFC_DELETE_STRICT
- flowMod.IdleTimeout = uint32(flowDeleteStrict.IdleTimeout)
- flowMod.HardTimeout = uint32(flowDeleteStrict.HardTimeout)
- flowMod.Priority = uint32(flowDeleteStrict.Priority)
- flowMod.BufferId = flowDeleteStrict.BufferId
- flowMod.OutPort = uint32(flowDeleteStrict.OutPort)
- flowMod.OutGroup = uint32(flowDeleteStrict.OutGroup)
- flowMod.Flags = uint32(flowDeleteStrict.Flags)
- inMatch := flowDeleteStrict.Match
- var flowMatch pb.OfpMatch
- flowMatch.Type = pb.OfpMatchType(inMatch.GetType())
- var oxmList []*pb.OfpOxmField
- inOxmList := inMatch.GetOxmList()
- for i := 0; i < len(inOxmList); i++ {
- oxmField := inOxmList[i]
- name := oxmMap[oxmField.GetOXMName()]
- val := oxmField.GetOXMValue()
- var ofpOxmField pb.OfpOxmField
- ofpOxmField.OxmClass = ofp.OFPXMCOpenflowBasic
- var field pb.OfpOxmOfbField
- field.Type = pb.OxmOfbFieldTypes(name)
-
- var x openflow_13.OfpOxmField_OfbField
- x.OfbField = &field
- ofpOxmField.Field = &x
-
- switch pb.OxmOfbFieldTypes(name) {
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
- port := val.(ofp.Port)
- var value pb.OfpOxmOfbField_Port
- value.Port = uint32(port)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT:
- phyPort := val.(uint32)
- var value pb.OfpOxmOfbField_PhysicalPort
- value.PhysicalPort = phyPort
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
- metadata := val.(uint64)
- var value pb.OfpOxmOfbField_TableMetadata
- value.TableMetadata = metadata
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
- ethType := val.(ofp.EthernetType)
- var value pb.OfpOxmOfbField_EthType
- value.EthType = uint32(ethType)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
- proto := val.(ofp.IpPrototype)
- var value pb.OfpOxmOfbField_IpProto
- value.IpProto = uint32(proto)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
- udpSrc := val.(uint16)
- var value pb.OfpOxmOfbField_UdpSrc
- value.UdpSrc = uint32(udpSrc)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
- udpDst := val.(uint16)
- var value pb.OfpOxmOfbField_UdpDst
- value.UdpDst = uint32(udpDst)
- field.Value = &value
- case pb.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
- //vid := (val.(uint16) & 0xfff)|0x1000
- vid := val.(uint16)
- //vid := val.(uint16) & 0xfff
- var value pb.OfpOxmOfbField_VlanVid
- value.VlanVid = uint32(vid)
- field.Value = &value
- }
- oxmList = append(oxmList, &ofpOxmField)
- }
- flowMatch.OxmFields = oxmList
- flowMod.Match = &flowMatch
- flowUpdate.FlowMod = &flowMod
- grpcClient := *getGrpcClient()
- if settings.GetDebug(DeviceID) {
- flowUpdateJs, _ := json.Marshal(flowUpdate)
- logger.Debugf("FlowUpdate being sent to Voltha", l.Fields{"DeviceID": DeviceID, "FlowModRequest": flowUpdateJs})
- }
- _, err := grpcClient.UpdateLogicalDeviceFlowTable(context.Background(), &flowUpdate)
- if err != nil {
- logger.Errorw("Error calling FlowUpdate ", l.Fields{"DeviceID": DeviceID, "error": err})
- }
-}
diff --git a/openflow/openflowClient.go b/openflow/openflowClient.go
deleted file mode 100644
index 8922f0b..0000000
--- a/openflow/openflowClient.go
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- 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"
- "fmt"
- "time"
-
- "github.com/donNewtonAlpha/goloxi"
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
-
- "net"
-)
-
-var volthaClient *pb.VolthaServiceClient
-var packetOutChannel chan pb.PacketOut
-var logger, _ = l.AddPackage(l.JSON, l.DebugLevel, nil)
-
-//Client structure to hold fields of Openflow Client
-type Client struct {
- OfServerAddress string
- Port uint16
- DeviceID string
- KeepRunning bool
- conn net.Conn
-}
-
-//NewClient contstructs a new Openflow Client and then starts up
-func NewClient(ofServerAddress string, port uint16, deviceID string, keepRunning bool) *Client {
-
- client := Client{OfServerAddress: ofServerAddress, Port: port, DeviceID: deviceID, KeepRunning: keepRunning}
- addressLine := fmt.Sprintf("%s:%d", client.OfServerAddress, client.Port)
- raddr, e := net.ResolveTCPAddr("tcp", addressLine)
- if e != nil {
- logger.Fatalw("openflowClient Start unable to resolve address", l.Fields{"Address": addressLine})
- }
- connection, e := net.DialTCP("tcp", nil, raddr)
- client.conn = connection
- if e != nil {
- logger.Fatalf("openflowClient Unable to connect to voltha @ %v exiting", raddr)
- }
- client.sayHello()
- return &client
-}
-
-//End - set keepRunning to false so start loop exits
-func (client *Client) End() {
- client.KeepRunning = false
-}
-
-//Start run loop for the openflow client
-func (client *Client) Start() {
-
- for {
- if client.KeepRunning {
- defer client.conn.Close()
- for {
- defer func() {
-
- if r := recover(); r != nil {
- err := r.(error)
- fmt.Printf("Caught error in client.Start() %v \n ", err)
- }
- }()
-
- if !client.KeepRunning {
- return
- }
- buf := make([]byte, 1500)
- read, e := client.conn.Read(buf)
- if settings.GetDebug(client.DeviceID) {
- fmt.Printf("conn.Read read %d bytes\n", read)
- }
- if read < 8 {
- continue
- }
-
- if e != nil {
- logger.Errorw("Voltha connection has died", l.Fields{"DeviceID": client.DeviceID, "Error": e})
- break
- }
- decoder := goloxi.NewDecoder(buf)
- header, e := ofp.DecodeHeader(decoder)
-
- if e != nil {
- js, _ := json.Marshal(decoder)
- logger.Errorw("DecodeHeader threw error", l.Fields{"DeviceID": client.DeviceID, "Decoder": js, "Error": e})
- }
- if settings.GetDebug(client.DeviceID) {
- js, _ := json.Marshal(header)
- logger.Debugw("Header Decode", l.Fields{"DeviceID": client.DeviceID, "Header": js})
- }
- client.parseHeader(header, buf) //first one is ready
- len := header.GetLength()
- if len < uint16(read) {
- for {
- read = read - int(len)
- newBuf := buf[len:]
- decoder = goloxi.NewDecoder(newBuf)
- newHeader, e := ofp.DecodeHeader(decoder)
- if e != nil {
- js, _ := json.Marshal(decoder)
- logger.Errorw("DecodeHeader threw error", l.Fields{"DeviceID": client.DeviceID, "Decoder": js, "Error": e})
- }
- if e != nil {
- js, _ := json.Marshal(decoder)
- logger.Errorw("DecodeHeader threw error", l.Fields{"DeviceID": client.DeviceID, "Decoder": js, "Error": e})
- }
- if settings.GetDebug(client.DeviceID) {
- js, _ := json.Marshal(header)
- logger.Debugw("Header Decode", l.Fields{"DeviceID": client.DeviceID, "Header": js})
- }
- len = newHeader.GetLength()
- client.parseHeader(newHeader, newBuf)
- if read == int(len) {
- break
- }
- buf = newBuf
- }
- }
- }
- }
- break
- }
-}
-func (client *Client) sayHello() {
- hello := ofp.NewHello()
- hello.Xid = uint32(GetXid())
- var elements []ofp.IHelloElem
- elem := ofp.NewHelloElemVersionbitmap()
- elem.SetType(ofp.OFPHETVersionbitmap)
- elem.SetLength(8)
- var bitmap = ofp.Uint32{Value: 16}
- bitmaps := []*ofp.Uint32{&bitmap}
- elem.SetBitmaps(bitmaps)
- elements = append(elements, elem)
- hello.SetElements(elements)
- if settings.GetDebug(client.DeviceID) {
- js, _ := json.Marshal(hello)
- logger.Debugw("sayHello Called", l.Fields{"DeviceID": client.DeviceID, "HelloMessage": js})
- }
- e := client.SendMessage(hello)
- if e != nil {
- logger.Fatalw("Failed saying hello to Openflow Server, unable to proceed",
- l.Fields{"DeviceID": client.DeviceID, "Error": e})
- }
-}
-func (client *Client) parseHeader(header ofp.IHeader, buf []byte) {
- switch header.GetType() {
- case ofp.OFPTHello:
- //x := header.(*ofp.Hello)
- case ofp.OFPTError:
- errMsg := header.(*ofp.ErrorMsg)
- go handleErrMsg(errMsg, client.DeviceID)
- case ofp.OFPTEchoRequest:
- echoReq := header.(*ofp.EchoRequest)
- go handleEchoRequest(echoReq, client.DeviceID, client)
- case ofp.OFPTEchoReply:
- case ofp.OFPTExperimenter:
- case ofp.OFPTFeaturesRequest:
- featReq := header.(*ofp.FeaturesRequest)
- go handleFeatureRequest(featReq, client.DeviceID, client)
- case ofp.OFPTFeaturesReply:
- case ofp.OFPTGetConfigRequest:
- configReq := header.(*ofp.GetConfigRequest)
- go handleGetConfigRequest(configReq, client.DeviceID, client)
- case ofp.OFPTGetConfigReply:
- case ofp.OFPTSetConfig:
- setConf := header.(*ofp.SetConfig)
- go handleSetConfig(setConf, client.DeviceID)
- case ofp.OFPTPacketIn:
- case ofp.OFPTFlowRemoved:
- case ofp.OFPTPortStatus:
- case ofp.OFPTPacketOut:
- packetOut := header.(*ofp.PacketOut)
- go handlePacketOut(packetOut, client.DeviceID)
- case ofp.OFPTFlowMod:
- /* Not using go routine to handle flow* messages or barrier requests
- onos typically issues barrier requests just before a flow* message.
- by handling in this thread I ensure all flow* are handled when barrier
- request is issued.
- */
- flowModType := uint8(buf[25])
- switch flowModType {
- case ofp.OFPFCAdd:
- flowAdd := header.(*ofp.FlowAdd)
- handleFlowAdd(flowAdd, client.DeviceID)
- case ofp.OFPFCModify:
- flowMod := header.(*ofp.FlowMod)
- handleFlowMod(flowMod, client.DeviceID)
- case ofp.OFPFCModifyStrict:
- flowModStrict := header.(*ofp.FlowModifyStrict)
- handleFlowModStrict(flowModStrict, client.DeviceID)
- case ofp.OFPFCDelete:
- flowDelete := header.(*ofp.FlowDelete)
- handleFlowDelete(flowDelete, client.DeviceID)
- case ofp.OFPFCDeleteStrict:
- flowDeleteStrict := header.(*ofp.FlowDeleteStrict)
- handleFlowDeleteStrict(flowDeleteStrict, client.DeviceID)
- }
- case ofp.OFPTStatsRequest:
- var statType = uint16(buf[8])<<8 + uint16(buf[9])
- go handleStatsRequest(header, statType, client.DeviceID, client)
- case ofp.OFPTBarrierRequest:
- /* See note above at case ofp.OFPTFlowMod:*/
- barRequest := header.(*ofp.BarrierRequest)
- handleBarrierRequest(barRequest, client.DeviceID, client)
- case ofp.OFPTRoleRequest:
- roleReq := header.(*ofp.RoleRequest)
- go handleRoleRequest(roleReq, client.DeviceID, client)
- case ofp.OFPTMeterMod:
- meterMod := header.(*ofp.MeterMod)
- go handleMeterModRequest(meterMod, client.DeviceID, client)
-
- }
-}
-
-//Message created to allow for a single SendMessage
-type Message interface {
- Serialize(encoder *goloxi.Encoder) error
-}
-
-//SendMessage sends message to openflow server
-func (client *Client) SendMessage(message Message) error {
- if settings.GetDebug(client.DeviceID) {
- js, _ := json.Marshal(message)
- logger.Debugw("SendMessage called", l.Fields{"DeviceID": client.DeviceID, "Message": js})
- }
- enc := goloxi.NewEncoder()
- message.Serialize(enc)
- for {
- if client.conn == nil {
- logger.Warnln("SendMessage Connection is Nil sleeping for 10 milliseconds")
- time.Sleep(10 * time.Millisecond)
- } else {
- break
- }
- }
- bytes := enc.Bytes()
- _, err := client.conn.Write(bytes)
- if err != nil {
- jMessage, _ := json.Marshal(message)
- logger.Errorw("SendMessage failed sending message", l.Fields{"DeviceID": client.DeviceID, "Error": err, "Message": jMessage})
- return err
- }
- return nil
-}
-
-//SetGrpcClient store a reference to the grpc client connection
-func SetGrpcClient(client *pb.VolthaServiceClient) {
- volthaClient = client
-}
-func getGrpcClient() *pb.VolthaServiceClient {
- return volthaClient
-}
-
-//SetPacketOutChannel - store the channel to send packet outs to grpc connection
-func SetPacketOutChannel(pktOutChan chan pb.PacketOut) {
- packetOutChannel = pktOutChan
-}
diff --git a/openflow/packet.go b/openflow/packet.go
deleted file mode 100644
index 046d8a3..0000000
--- a/openflow/packet.go
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- 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/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- pb "github.com/opencord/voltha-protos/v2/go/voltha"
-)
-
-func handlePacketOut(packetOut *ofp.PacketOut, DeviceID string) {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(packetOut)
- logger.Debugw("handlePacketOut called", l.Fields{"DeviceID": DeviceID, "packetOut": js})
- }
- pktOut := pb.OfpPacketOut{}
- pktOut.BufferId = packetOut.GetBufferId()
- pktOut.InPort = uint32(packetOut.GetInPort())
- var actions []*pb.OfpAction
- inActions := packetOut.GetActions()
- for i := 0; i < len(inActions); i++ {
- action := inActions[i]
- newAction := extractAction(action)
- actions = append(actions, newAction)
- }
- pktOut.Actions = actions
- pktOut.Data = packetOut.GetData()
- pbPacketOut := pb.PacketOut{}
- pbPacketOut.PacketOut = &pktOut
- pbPacketOut.Id = DeviceID
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(pbPacketOut)
- logger.Debugw("handlePacketOut sending", l.Fields{"DeviceID": DeviceID, "packetOut": js})
- }
- packetOutChannel <- pbPacketOut
-}
diff --git a/openflow/stats.go b/openflow/stats.go
deleted file mode 100644
index 8b12294..0000000
--- a/openflow/stats.go
+++ /dev/null
@@ -1,571 +0,0 @@
-/*
- 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 (
- "context"
- "encoding/json"
-
- "net"
-
- "unsafe"
-
- "github.com/opencord/ofagent-go/settings"
- l "github.com/opencord/voltha-lib-go/v2/pkg/log"
- "github.com/opencord/voltha-protos/v2/go/openflow_13"
-
- "github.com/donNewtonAlpha/goloxi"
- ofp "github.com/donNewtonAlpha/goloxi/of13"
- "github.com/opencord/voltha-protos/v2/go/common"
-)
-
-func handleStatsRequest(request ofp.IHeader, statType uint16, DeviceID string, client *Client) error {
- if settings.GetDebug(DeviceID) {
- js, _ := json.Marshal(request)
- logger.Debugw("handleStatsRequest called", l.Fields{"DeviceID": DeviceID, "StatType": statType, "rquest": js})
- }
- var id = common.ID{Id: DeviceID}
- switch statType {
- case ofp.OFPSTDesc:
- statsReq := request.(*ofp.DescStatsRequest)
- response, err := handleDescStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTFlow:
- statsReq := request.(*ofp.FlowStatsRequest)
- response, err := handleFlowStatsRequest(statsReq, id, DeviceID)
- if err != nil {
- return err
- }
- response.Length = uint16(unsafe.Sizeof(*response))
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
-
- case ofp.OFPSTAggregate:
- statsReq := request.(*ofp.AggregateStatsRequest)
- response, err := handleAggregateStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTTable:
- statsReq := request.(*ofp.TableStatsRequest)
- response, e := handleTableStatsRequest(statsReq, id)
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- if e != nil {
- return e
- }
- return client.SendMessage(response)
- case ofp.OFPSTPort:
- statsReq := request.(*ofp.PortStatsRequest)
- response, err := handlePortStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
-
- case ofp.OFPSTQueue:
- statsReq := request.(*ofp.QueueStatsRequest)
- response, err := handleQueueStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTGroup:
- statsReq := request.(*ofp.GroupStatsRequest)
- response, err := handleGroupStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- client.SendMessage(response)
- case ofp.OFPSTGroupDesc:
- statsReq := request.(*ofp.GroupDescStatsRequest)
- response, err := handleGroupStatsDescRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
-
- case ofp.OFPSTGroupFeatures:
- statsReq := request.(*ofp.GroupFeaturesStatsRequest)
- response, err := handleGroupFeatureStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTMeter:
- statsReq := request.(*ofp.MeterStatsRequest)
- response, err := handleMeterStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTMeterConfig:
- statsReq := request.(*ofp.MeterConfigStatsRequest)
- response, err := handleMeterConfigStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTMeterFeatures:
- statsReq := request.(*ofp.MeterFeaturesStatsRequest)
- response, err := handleMeterFeatureStatsRequest(statsReq)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTTableFeatures:
- statsReq := request.(*ofp.TableFeaturesStatsRequest)
- response, err := handleTableFeaturesStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- case ofp.OFPSTPortDesc:
- statsReq := request.(*ofp.PortDescStatsRequest)
- response, err := handlePortDescStatsRequest(statsReq, DeviceID)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
-
- case ofp.OFPSTExperimenter:
- statsReq := request.(*ofp.ExperimenterStatsRequest)
- response, err := handleExperimenterStatsRequest(statsReq, id)
- if err != nil {
- return err
- }
- if settings.GetDebug(DeviceID) {
- reqJs, _ := json.Marshal(statsReq)
- resJs, _ := json.Marshal(response)
- logger.Debugw("HandleStatsRequest GRPC", l.Fields{"DeviceID": DeviceID, "Req": reqJs, "Res": resJs})
- }
- return client.SendMessage(response)
- }
- return nil
-}
-
-func handleDescStatsRequest(request *ofp.DescStatsRequest, id common.ID) (*ofp.DescStatsReply, error) {
- 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 {
- return nil, err
- }
- desc := resp.GetDesc()
-
- response.SetMfrDesc(PadString(desc.GetMfrDesc(), 256))
- response.SetHwDesc(PadString(desc.GetHwDesc(), 256))
- response.SetSwDesc(PadString(desc.GetSwDesc(), 256))
- response.SetSerialNum(PadString(desc.GetSerialNum(), 32))
- response.SetDpDesc(PadString(desc.GetDpDesc(), 256))
- return response, nil
-}
-func handleFlowStatsRequest(request *ofp.FlowStatsRequest, id common.ID, DeviceID string) (*ofp.FlowStatsReply, error) {
- response := ofp.NewFlowStatsReply()
- response.SetXid(request.GetXid())
- response.SetVersion(4)
- response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
- client := *getGrpcClient()
- resp, err := client.ListLogicalDeviceFlows(context.Background(), &id)
- if err != nil {
- return nil, err
- }
- var flow []*ofp.FlowStatsEntry
- items := resp.GetItems()
- for i := 0; i < len(items); i++ {
- item := items[i]
- entry := ofp.NewFlowStatsEntry()
- entry.SetTableId(uint8(item.GetTableId()))
- entry.SetDurationSec(item.GetDurationSec())
- entry.SetDurationNsec(item.GetDurationNsec())
- entry.SetPriority(uint16(item.GetPriority()))
- entry.SetIdleTimeout(uint16(item.GetIdleTimeout()))
- entry.SetHardTimeout(uint16(item.GetHardTimeout()))
- entry.SetFlags(ofp.FlowModFlags(item.GetFlags()))
- entry.SetCookie(item.GetCookie())
- entry.SetPacketCount(item.GetPacketCount())
- entry.SetByteCount(item.GetByteCount())
- 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++ {
- oxmField := oxFields[i]
- field := oxmField.GetField()
- ofbField := field.(*openflow_13.OfpOxmField_OfbField).OfbField
- iOxm, oxmSize := parseOxm(ofbField, DeviceID)
- fields = append(fields, iOxm)
- if oxmSize > 0 {
- size += 4 //header for oxm
- }
- size += oxmSize
- }
-
- match.OxmList = fields
- match.Length = uint16(size)
- //account for 8 byte alignment
- if size%8 != 0 {
- size = ((size / 8) + 1) * 8
- }
- entrySize += size
- entry.SetMatch(*match)
- var instructions []ofp.IInstruction
- ofpInstructions := item.Instructions
- for i := 0; i < len(ofpInstructions); i++ {
- instruction, size := parseInstructions(ofpInstructions[i], DeviceID)
- instructions = append(instructions, instruction)
- entrySize += size
- }
- entry.Instructions = instructions
- entry.Length = entrySize
- entrySize = 0
- flow = append(flow, entry)
- }
- response.SetEntries(flow)
- return response, nil
-}
-func handleAggregateStatsRequest(request *ofp.AggregateStatsRequest, id common.ID) (*ofp.AggregateStatsReply, error) {
- 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
-}
-func handleGroupStatsRequest(request *ofp.GroupStatsRequest, id common.ID) (*ofp.GroupStatsReply, error) {
- 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 {
- return nil, err
- }
-
- var groupStatsEntries []*ofp.GroupStatsEntry
- items := reply.GetItems()
- for i := 0; i < len(items); i++ {
- item := items[i].GetStats()
- var entry ofp.GroupStatsEntry
- entry.SetByteCount(item.GetByteCount())
- entry.SetPacketCount(item.GetPacketCount())
- entry.SetDurationNsec(item.GetDurationNsec())
- entry.SetDurationSec(item.GetDurationSec())
- entry.SetRefCount(item.GetRefCount())
- entry.SetGroupId(item.GetGroupId())
- bucketStats := item.GetBucketStats()
- var bucketStatsList []*ofp.BucketCounter
- for j := 0; j < len(bucketStats); j++ {
- bucketStat := bucketStats[i]
- var bucketCounter ofp.BucketCounter
- bucketCounter.SetPacketCount(bucketStat.GetPacketCount())
- bucketCounter.SetByteCount(bucketStat.GetByteCount())
- bucketStatsList = append(bucketStatsList, &bucketCounter)
- }
- entry.SetBucketStats(bucketStatsList)
- groupStatsEntries = append(groupStatsEntries, &entry)
- }
- response.SetEntries(groupStatsEntries)
- return response, nil
-}
-func handleGroupStatsDescRequest(request *ofp.GroupDescStatsRequest, id common.ID) (*ofp.GroupDescStatsReply, error) {
- 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 {
- return nil, err
- }
- entries := reply.GetItems()
- var groupDescStatsEntries []*ofp.GroupDescStatsEntry
- for i := 0; i < len(entries); i++ {
- item := entries[i].GetStats()
- var groupDesc ofp.GroupDescStatsEntry
- groupDesc.SetGroupId(item.GetGroupId())
- /*
- buckets := item.g
- var bucketList []*ofp.Bucket
- for j:=0;j<len(buckets);j++{
-
- }
-
- groupDesc.SetBuckets(bucketList)
- */
- groupDescStatsEntries = append(groupDescStatsEntries, &groupDesc)
- }
- response.SetEntries(groupDescStatsEntries)
- return response, nil
-}
-func handleGroupFeatureStatsRequest(request *ofp.GroupFeaturesStatsRequest, id common.ID) (*ofp.GroupFeaturesStatsReply, error) {
- 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
-}
-func handleMeterStatsRequest(request *ofp.MeterStatsRequest, id common.ID) (*ofp.MeterStatsReply, error) {
- response := ofp.NewMeterStatsReply()
- response.SetVersion(request.GetVersion())
- response.SetXid(request.GetXid())
- 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
-}
-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
-}
-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 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
-}
-func handlePortStatsRequest(request *ofp.PortStatsRequest, id common.ID) (*ofp.PortStatsReply, error) {
- response := ofp.NewPortStatsReply()
- response.SetXid(request.GetXid())
- response.SetVersion(request.GetVersion())
- response.SetFlags(ofp.StatsReplyFlags(request.GetFlags()))
- client := *getGrpcClient()
- reply, err := client.ListLogicalDevicePorts(context.Background(), &id)
- //reply,err := client.GetLogicalDevicePort(context.Background(),&id)
- if err != nil {
- return nil, err
- }
- ports := reply.GetItems()
- var entries []*ofp.PortStatsEntry
- if request.GetPortNo() == 0xffffffff { //all ports
- for i := 0; i < len(ports); i++ {
- port := ports[i]
- entry := parsePortStats(port)
- entries = append(entries, &entry)
- }
- } else { //find right port that is requested
- for i := 0; i < len(ports); i++ {
- if ports[i].GetOfpPortStats().GetPortNo() == uint32(request.GetPortNo()) {
- entry := parsePortStats(ports[i])
- entries = append(entries, &entry)
- }
- }
- }
- response.SetEntries(entries)
- return response, nil
-}
-
-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)
- if err != nil {
- return nil, err
- }
- ports := logicalDevice.GetPorts()
- var entries []*ofp.PortDesc
- for i := 0; i < len(ports); i++ {
- var entry ofp.PortDesc
- port := ports[i].GetOfpPort()
- entry.SetPortNo(ofp.Port(port.GetPortNo()))
-
- intArray := port.GetHwAddr()
- var octets []byte
- for i := 0; i < len(intArray); i++ {
- octets = append(octets, byte(intArray[i]))
- }
- hwAddr := net.HardwareAddr(octets)
- entry.SetHwAddr(hwAddr)
- entry.SetName(PadString(port.GetName(), 16))
- entry.SetConfig(ofp.PortConfig(port.GetConfig()))
- entry.SetState(ofp.PortState(port.GetState()))
- entry.SetCurr(ofp.PortFeatures(port.GetCurr()))
- entry.SetAdvertised(ofp.PortFeatures(port.GetAdvertised()))
- entry.SetSupported(ofp.PortFeatures(port.GetSupported()))
- entry.SetPeer(ofp.PortFeatures(port.GetPeer()))
- entry.SetCurrSpeed(port.GetCurrSpeed())
- entry.SetMaxSpeed(port.GetMaxSpeed())
-
- entries = append(entries, &entry)
- }
-
- response.SetEntries(entries)
- //TODO call voltha and get port descriptions etc
- return response, nil
-
-}
-func handleMeterFeatureStatsRequest(request *ofp.MeterFeaturesStatsRequest) (*ofp.MeterFeaturesStatsReply, error) {
- 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/settings/settings.go b/settings/settings.go
deleted file mode 100644
index f112767..0000000
--- a/settings/settings.go
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- 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 settings
-
-var debug bool
-var debugMap = make(map[string]bool)
-
-func SetDebug(on bool) {
- debug = on
-}
-
-func SetDeviceDebug(deviceId string, on bool) {
- debugMap[deviceId] = on
-}
-func GetDebug(deviceId string) bool {
- /*
- if debug {
- return true
- }
- return getDeviceDebug(deviceId)
- */
- return debug
-}
-func getDeviceDebug(deviceId string) bool {
- //will return false if nothing has been added for that device
- return debugMap[deviceId]
-}
diff --git a/vendor/github.com/opencord/voltha-lib-go/v2/pkg/probe/probe.go b/vendor/github.com/opencord/voltha-lib-go/v2/pkg/probe/probe.go
new file mode 100644
index 0000000..7e6dbf9
--- /dev/null
+++ b/vendor/github.com/opencord/voltha-lib-go/v2/pkg/probe/probe.go
@@ -0,0 +1,293 @@
+/*
+ * Copyright 2019-present Open Networking Foundation
+ *
+ * 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 probe
+
+import (
+ "context"
+ "fmt"
+ "github.com/opencord/voltha-lib-go/v2/pkg/log"
+ "net/http"
+ "sync"
+)
+
+// ProbeContextKey used to fetch the Probe instance from a context
+type ProbeContextKeyType string
+
+// ServiceStatus typed values for service status
+type ServiceStatus int
+
+const (
+ // ServiceStatusUnknown initial state of services
+ ServiceStatusUnknown ServiceStatus = iota
+
+ // ServiceStatusPreparing to optionally be used for prep, such as connecting
+ ServiceStatusPreparing
+
+ // ServiceStatusPrepared to optionally be used when prep is complete, but before run
+ ServiceStatusPrepared
+
+ // ServiceStatusRunning service is functional
+ ServiceStatusRunning
+
+ // ServiceStatusStopped service has stopped, but not because of error
+ ServiceStatusStopped
+
+ // ServiceStatusFailed service has stopped because of an error
+ ServiceStatusFailed
+
+ // ServiceStatusNotReady service has started but is unable to accept requests
+ ServiceStatusNotReady
+)
+
+const (
+ // ProbeContextKey value of context key to fetch probe
+ ProbeContextKey = ProbeContextKeyType("status-update-probe")
+)
+
+// String convert ServiceStatus values to strings
+func (s ServiceStatus) String() string {
+ switch s {
+ default:
+ fallthrough
+ case ServiceStatusUnknown:
+ return "Unknown"
+ case ServiceStatusPreparing:
+ return "Preparing"
+ case ServiceStatusPrepared:
+ return "Prepared"
+ case ServiceStatusRunning:
+ return "Running"
+ case ServiceStatusStopped:
+ return "Stopped"
+ case ServiceStatusFailed:
+ return "Failed"
+ case ServiceStatusNotReady:
+ return "NotReady"
+ }
+}
+
+// ServiceStatusUpdate status update event
+type ServiceStatusUpdate struct {
+ Name string
+ Status ServiceStatus
+}
+
+// Probe reciever on which to implement probe capabilities
+type Probe struct {
+ readyFunc func(map[string]ServiceStatus) bool
+ healthFunc func(map[string]ServiceStatus) bool
+
+ mutex sync.RWMutex
+ status map[string]ServiceStatus
+ isReady bool
+ isHealthy bool
+}
+
+// WithReadyFunc override the default ready calculation function
+func (p *Probe) WithReadyFunc(readyFunc func(map[string]ServiceStatus) bool) *Probe {
+ p.readyFunc = readyFunc
+ return p
+}
+
+// WithHealthFunc override the default health calculation function
+func (p *Probe) WithHealthFunc(healthFunc func(map[string]ServiceStatus) bool) *Probe {
+ p.healthFunc = healthFunc
+ return p
+}
+
+// RegisterService register one or more service names with the probe, status will be track against service name
+func (p *Probe) RegisterService(names ...string) {
+ p.mutex.Lock()
+ defer p.mutex.Unlock()
+ if p.status == nil {
+ p.status = make(map[string]ServiceStatus)
+ }
+ for _, name := range names {
+ if _, ok := p.status[name]; !ok {
+ p.status[name] = ServiceStatusUnknown
+ log.Debugw("probe-service-registered", log.Fields{"service-name": name})
+ }
+ }
+
+ if p.readyFunc != nil {
+ p.isReady = p.readyFunc(p.status)
+ } else {
+ p.isReady = defaultReadyFunc(p.status)
+ }
+
+ if p.healthFunc != nil {
+ p.isHealthy = p.healthFunc(p.status)
+ } else {
+ p.isHealthy = defaultHealthFunc(p.status)
+ }
+}
+
+// UpdateStatus utility function to send a service update to the probe
+func (p *Probe) UpdateStatus(name string, status ServiceStatus) {
+ p.mutex.Lock()
+ defer p.mutex.Unlock()
+ if p.status == nil {
+ p.status = make(map[string]ServiceStatus)
+ }
+
+ // if status hasn't changed, avoid doing useless work
+ existingStatus, ok := p.status[name]
+ if ok && (existingStatus == status) {
+ return
+ }
+
+ p.status[name] = status
+ if p.readyFunc != nil {
+ p.isReady = p.readyFunc(p.status)
+ } else {
+ p.isReady = defaultReadyFunc(p.status)
+ }
+
+ if p.healthFunc != nil {
+ p.isHealthy = p.healthFunc(p.status)
+ } else {
+ p.isHealthy = defaultHealthFunc(p.status)
+ }
+ log.Debugw("probe-service-status-updated",
+ log.Fields{
+ "service-name": name,
+ "status": status.String(),
+ "ready": p.isReady,
+ "health": p.isHealthy,
+ })
+}
+
+func (p *Probe) GetStatus(name string) ServiceStatus {
+ p.mutex.Lock()
+ defer p.mutex.Unlock()
+
+ if p.status == nil {
+ p.status = make(map[string]ServiceStatus)
+ }
+
+ currentStatus, ok := p.status[name]
+ if ok {
+ return currentStatus
+ }
+
+ return ServiceStatusUnknown
+}
+
+func GetProbeFromContext(ctx context.Context) *Probe {
+ if ctx != nil {
+ if value := ctx.Value(ProbeContextKey); value != nil {
+ if p, ok := value.(*Probe); ok {
+ return p
+ }
+ }
+ }
+ return nil
+}
+
+// UpdateStatusFromContext a convenience function to pull the Probe reference from the
+// Context, if it exists, and then calling UpdateStatus on that Probe reference. If Context
+// is nil or if a Probe reference is not associated with the ProbeContextKey then nothing
+// happens
+func UpdateStatusFromContext(ctx context.Context, name string, status ServiceStatus) {
+ p := GetProbeFromContext(ctx)
+ if p != nil {
+ p.UpdateStatus(name, status)
+ }
+}
+
+// pulled out to a function to help better enable unit testing
+func (p *Probe) readzFunc(w http.ResponseWriter, req *http.Request) {
+ p.mutex.RLock()
+ defer p.mutex.RUnlock()
+ if p.isReady {
+ w.WriteHeader(http.StatusOK)
+ } else {
+ w.WriteHeader(http.StatusTeapot)
+ }
+}
+func (p *Probe) healthzFunc(w http.ResponseWriter, req *http.Request) {
+ p.mutex.RLock()
+ defer p.mutex.RUnlock()
+ if p.isHealthy {
+ w.WriteHeader(http.StatusOK)
+ } else {
+ w.WriteHeader(http.StatusTeapot)
+ }
+}
+func (p *Probe) detailzFunc(w http.ResponseWriter, req *http.Request) {
+ p.mutex.RLock()
+ defer p.mutex.RUnlock()
+ w.Header().Set("Content-Type", "application/json")
+ w.Write([]byte("{"))
+ comma := ""
+ for c, s := range p.status {
+ w.Write([]byte(fmt.Sprintf("%s\"%s\": \"%s\"", comma, c, s.String())))
+ comma = ", "
+ }
+ w.Write([]byte("}"))
+ w.WriteHeader(http.StatusOK)
+
+}
+
+// ListenAndServe implements 3 HTTP endpoints on the given port for healthz, readz, and detailz. Returns only on error
+func (p *Probe) ListenAndServe(address string) {
+ mux := http.NewServeMux()
+
+ // Returns the result of the readyFunc calculation
+ mux.HandleFunc("/readz", p.readzFunc)
+
+ // Returns the result of the healthFunc calculation
+ mux.HandleFunc("/healthz", p.healthzFunc)
+
+ // Returns the details of the services and their status as JSON
+ mux.HandleFunc("/detailz", p.detailzFunc)
+ s := &http.Server{
+ Addr: address,
+ Handler: mux,
+ }
+ log.Fatal(s.ListenAndServe())
+}
+
+func (p *Probe) IsReady() bool {
+ return p.isReady
+}
+
+// defaultReadyFunc if all services are running then ready, else not
+func defaultReadyFunc(services map[string]ServiceStatus) bool {
+ if len(services) == 0 {
+ return false
+ }
+ for _, status := range services {
+ if status != ServiceStatusRunning {
+ return false
+ }
+ }
+ return true
+}
+
+// defaultHealthFunc if no service is stopped or failed, then healthy, else not.
+// service is start as unknown, so they are considered healthy
+func defaultHealthFunc(services map[string]ServiceStatus) bool {
+ if len(services) == 0 {
+ return false
+ }
+ for _, status := range services {
+ if status == ServiceStatusStopped || status == ServiceStatusFailed {
+ return false
+ }
+ }
+ return true
+}
diff --git a/config/version/version.go b/vendor/github.com/opencord/voltha-lib-go/v2/pkg/version/version.go
similarity index 84%
rename from config/version/version.go
rename to vendor/github.com/opencord/voltha-lib-go/v2/pkg/version/version.go
index 269d748..49c0b10 100644
--- a/config/version/version.go
+++ b/vendor/github.com/opencord/voltha-lib-go/v2/pkg/version/version.go
@@ -13,8 +13,6 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
-// Package version is used to inject build time information via -X variables
package version
import (
@@ -35,8 +33,7 @@
arch = "unknown-arch"
)
-// InfoType is a collection of build time environment variables
-type InfoType struct {
+type VersionInfoType struct {
Version string `json:"version"`
GoVersion string `json:"goversion"`
VcsRef string `json:"vcsref"`
@@ -46,11 +43,10 @@
Arch string `json:"arch"`
}
-// VersionInfo is an instance of build time environment variables populated at build time via -X arguments
-var VersionInfo InfoType
+var VersionInfo VersionInfoType
func init() {
- VersionInfo = InfoType{
+ VersionInfo = VersionInfoType{
Version: version,
VcsRef: vcsRef,
VcsDirty: vcsDirty,
@@ -61,7 +57,7 @@
}
}
-func (v InfoType) String(indent string) string {
+func (v VersionInfoType) String(indent string) string {
builder := strings.Builder{}
builder.WriteString(fmt.Sprintf("%sVersion: %s\n", indent, VersionInfo.Version))
diff --git a/vendor/golang.org/x/sys/unix/mkasm_darwin.go b/vendor/golang.org/x/sys/unix/mkasm_darwin.go
deleted file mode 100644
index 4548b99..0000000
--- a/vendor/golang.org/x/sys/unix/mkasm_darwin.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// mkasm_darwin.go generates assembly trampolines to call libSystem routines from Go.
-//This program must be run after mksyscall.go.
-package main
-
-import (
- "bytes"
- "fmt"
- "io/ioutil"
- "log"
- "os"
- "strings"
-)
-
-func main() {
- in1, err := ioutil.ReadFile("syscall_darwin.go")
- if err != nil {
- log.Fatalf("can't open syscall_darwin.go: %s", err)
- }
- arch := os.Args[1]
- in2, err := ioutil.ReadFile(fmt.Sprintf("syscall_darwin_%s.go", arch))
- if err != nil {
- log.Fatalf("can't open syscall_darwin_%s.go: %s", arch, err)
- }
- in3, err := ioutil.ReadFile(fmt.Sprintf("zsyscall_darwin_%s.go", arch))
- if err != nil {
- log.Fatalf("can't open zsyscall_darwin_%s.go: %s", arch, err)
- }
- in := string(in1) + string(in2) + string(in3)
-
- trampolines := map[string]bool{}
-
- var out bytes.Buffer
-
- fmt.Fprintf(&out, "// go run mkasm_darwin.go %s\n", strings.Join(os.Args[1:], " "))
- fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
- fmt.Fprintf(&out, "\n")
- fmt.Fprintf(&out, "// +build go1.12\n")
- fmt.Fprintf(&out, "\n")
- fmt.Fprintf(&out, "#include \"textflag.h\"\n")
- for _, line := range strings.Split(in, "\n") {
- if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
- continue
- }
- fn := line[5 : len(line)-13]
- if !trampolines[fn] {
- trampolines[fn] = true
- fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
- fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
- }
- }
- err = ioutil.WriteFile(fmt.Sprintf("zsyscall_darwin_%s.s", arch), out.Bytes(), 0644)
- if err != nil {
- log.Fatalf("can't write zsyscall_darwin_%s.s: %s", arch, err)
- }
-}
diff --git a/vendor/golang.org/x/sys/unix/mkpost.go b/vendor/golang.org/x/sys/unix/mkpost.go
deleted file mode 100644
index eb43320..0000000
--- a/vendor/golang.org/x/sys/unix/mkpost.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// mkpost processes the output of cgo -godefs to
-// modify the generated types. It is used to clean up
-// the sys API in an architecture specific manner.
-//
-// mkpost is run after cgo -godefs; see README.md.
-package main
-
-import (
- "bytes"
- "fmt"
- "go/format"
- "io/ioutil"
- "log"
- "os"
- "regexp"
-)
-
-func main() {
- // Get the OS and architecture (using GOARCH_TARGET if it exists)
- goos := os.Getenv("GOOS")
- goarch := os.Getenv("GOARCH_TARGET")
- if goarch == "" {
- goarch = os.Getenv("GOARCH")
- }
- // Check that we are using the Docker-based build system if we should be.
- if goos == "linux" {
- if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
- os.Stderr.WriteString("In the Docker-based build system, mkpost should not be called directly.\n")
- os.Stderr.WriteString("See README.md\n")
- os.Exit(1)
- }
- }
-
- b, err := ioutil.ReadAll(os.Stdin)
- if err != nil {
- log.Fatal(err)
- }
-
- if goos == "aix" {
- // Replace type of Atim, Mtim and Ctim by Timespec in Stat_t
- // to avoid having both StTimespec and Timespec.
- sttimespec := regexp.MustCompile(`_Ctype_struct_st_timespec`)
- b = sttimespec.ReplaceAll(b, []byte("Timespec"))
- }
-
- // Intentionally export __val fields in Fsid and Sigset_t
- valRegex := regexp.MustCompile(`type (Fsid|Sigset_t) struct {(\s+)X__(bits|val)(\s+\S+\s+)}`)
- b = valRegex.ReplaceAll(b, []byte("type $1 struct {${2}Val$4}"))
-
- // Intentionally export __fds_bits field in FdSet
- fdSetRegex := regexp.MustCompile(`type (FdSet) struct {(\s+)X__fds_bits(\s+\S+\s+)}`)
- b = fdSetRegex.ReplaceAll(b, []byte("type $1 struct {${2}Bits$3}"))
-
- // If we have empty Ptrace structs, we should delete them. Only s390x emits
- // nonempty Ptrace structs.
- ptraceRexexp := regexp.MustCompile(`type Ptrace((Psw|Fpregs|Per) struct {\s*})`)
- b = ptraceRexexp.ReplaceAll(b, nil)
-
- // Replace the control_regs union with a blank identifier for now.
- controlRegsRegex := regexp.MustCompile(`(Control_regs)\s+\[0\]uint64`)
- b = controlRegsRegex.ReplaceAll(b, []byte("_ [0]uint64"))
-
- // Remove fields that are added by glibc
- // Note that this is unstable as the identifers are private.
- removeFieldsRegex := regexp.MustCompile(`X__glibc\S*`)
- b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
-
- // Convert [65]int8 to [65]byte in Utsname members to simplify
- // conversion to string; see golang.org/issue/20753
- convertUtsnameRegex := regexp.MustCompile(`((Sys|Node|Domain)name|Release|Version|Machine)(\s+)\[(\d+)\]u?int8`)
- b = convertUtsnameRegex.ReplaceAll(b, []byte("$1$3[$4]byte"))
-
- // Convert [1024]int8 to [1024]byte in Ptmget members
- convertPtmget := regexp.MustCompile(`([SC]n)(\s+)\[(\d+)\]u?int8`)
- b = convertPtmget.ReplaceAll(b, []byte("$1[$3]byte"))
-
- // Remove spare fields (e.g. in Statx_t)
- spareFieldsRegex := regexp.MustCompile(`X__spare\S*`)
- b = spareFieldsRegex.ReplaceAll(b, []byte("_"))
-
- // Remove cgo padding fields
- removePaddingFieldsRegex := regexp.MustCompile(`Pad_cgo_\d+`)
- b = removePaddingFieldsRegex.ReplaceAll(b, []byte("_"))
-
- // Remove padding, hidden, or unused fields
- removeFieldsRegex = regexp.MustCompile(`\b(X_\S+|Padding)`)
- b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
-
- // Remove the first line of warning from cgo
- b = b[bytes.IndexByte(b, '\n')+1:]
- // Modify the command in the header to include:
- // mkpost, our own warning, and a build tag.
- replacement := fmt.Sprintf(`$1 | go run mkpost.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s,%s`, goarch, goos)
- cgoCommandRegex := regexp.MustCompile(`(cgo -godefs .*)`)
- b = cgoCommandRegex.ReplaceAll(b, []byte(replacement))
-
- // Rename Stat_t time fields
- if goos == "freebsd" && goarch == "386" {
- // Hide Stat_t.[AMCB]tim_ext fields
- renameStatTimeExtFieldsRegex := regexp.MustCompile(`[AMCB]tim_ext`)
- b = renameStatTimeExtFieldsRegex.ReplaceAll(b, []byte("_"))
- }
- renameStatTimeFieldsRegex := regexp.MustCompile(`([AMCB])(?:irth)?time?(?:spec)?\s+(Timespec|StTimespec)`)
- b = renameStatTimeFieldsRegex.ReplaceAll(b, []byte("${1}tim ${2}"))
-
- // gofmt
- b, err = format.Source(b)
- if err != nil {
- log.Fatal(err)
- }
-
- os.Stdout.Write(b)
-}
diff --git a/vendor/golang.org/x/sys/unix/mksyscall.go b/vendor/golang.org/x/sys/unix/mksyscall.go
deleted file mode 100644
index e4af942..0000000
--- a/vendor/golang.org/x/sys/unix/mksyscall.go
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_darwin.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
- * The parameter lists must give a name for each argument.
- This includes return parameters.
- * The parameter lists must give a type for each argument:
- the (x, y, z int) shorthand is not allowed.
- * If the return parameter is an error number, it must be named errno.
-
-A line beginning with //sysnb is like //sys, except that the
-goroutine will not be suspended during the execution of the system
-call. This must only be used for system calls which can never
-block, as otherwise the system call could cause all goroutines to
-hang.
-*/
-package main
-
-import (
- "bufio"
- "flag"
- "fmt"
- "os"
- "regexp"
- "strings"
-)
-
-var (
- b32 = flag.Bool("b32", false, "32bit big-endian")
- l32 = flag.Bool("l32", false, "32bit little-endian")
- plan9 = flag.Bool("plan9", false, "plan9")
- openbsd = flag.Bool("openbsd", false, "openbsd")
- netbsd = flag.Bool("netbsd", false, "netbsd")
- dragonfly = flag.Bool("dragonfly", false, "dragonfly")
- arm = flag.Bool("arm", false, "arm") // 64-bit value should use (even, odd)-pair
- tags = flag.String("tags", "", "build tags")
- filename = flag.String("output", "", "output file name (standard output if omitted)")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
- return "go run mksyscall.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
- return *tags
-}
-
-// Param is function parameter
-type Param struct {
- Name string
- Type string
-}
-
-// usage prints the program usage
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: go run mksyscall.go [-b32 | -l32] [-tags x,y] [file ...]\n")
- os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
- list = strings.TrimSpace(list)
- if list == "" {
- return []string{}
- }
- return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
- ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
- if ps == nil {
- fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
- os.Exit(1)
- }
- return Param{ps[1], ps[2]}
-}
-
-func main() {
- // Get the OS and architecture (using GOARCH_TARGET if it exists)
- goos := os.Getenv("GOOS")
- if goos == "" {
- fmt.Fprintln(os.Stderr, "GOOS not defined in environment")
- os.Exit(1)
- }
- goarch := os.Getenv("GOARCH_TARGET")
- if goarch == "" {
- goarch = os.Getenv("GOARCH")
- }
-
- // Check that we are using the Docker-based build system if we should
- if goos == "linux" {
- if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
- fmt.Fprintf(os.Stderr, "In the Docker-based build system, mksyscall should not be called directly.\n")
- fmt.Fprintf(os.Stderr, "See README.md\n")
- os.Exit(1)
- }
- }
-
- flag.Usage = usage
- flag.Parse()
- if len(flag.Args()) <= 0 {
- fmt.Fprintf(os.Stderr, "no files to parse provided\n")
- usage()
- }
-
- endianness := ""
- if *b32 {
- endianness = "big-endian"
- } else if *l32 {
- endianness = "little-endian"
- }
-
- libc := false
- if goos == "darwin" && strings.Contains(buildTags(), ",go1.12") {
- libc = true
- }
- trampolines := map[string]bool{}
-
- text := ""
- for _, path := range flag.Args() {
- file, err := os.Open(path)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- s := bufio.NewScanner(file)
- for s.Scan() {
- t := s.Text()
- t = strings.TrimSpace(t)
- t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
- nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
- if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
- continue
- }
-
- // Line must be of the form
- // func Open(path string, mode int, perm int) (fd int, errno error)
- // Split into name, in params, out params.
- f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$`).FindStringSubmatch(t)
- if f == nil {
- fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
- os.Exit(1)
- }
- funct, inps, outps, sysname := f[2], f[3], f[4], f[5]
-
- // ClockGettime doesn't have a syscall number on Darwin, only generate libc wrappers.
- if goos == "darwin" && !libc && funct == "ClockGettime" {
- continue
- }
-
- // Split argument lists on comma.
- in := parseParamList(inps)
- out := parseParamList(outps)
-
- // Try in vain to keep people from editing this file.
- // The theory is that they jump into the middle of the file
- // without reading the header.
- text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
- // Go function header.
- outDecl := ""
- if len(out) > 0 {
- outDecl = fmt.Sprintf(" (%s)", strings.Join(out, ", "))
- }
- text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outDecl)
-
- // Check if err return available
- errvar := ""
- for _, param := range out {
- p := parseParam(param)
- if p.Type == "error" {
- errvar = p.Name
- break
- }
- }
-
- // Prepare arguments to Syscall.
- var args []string
- n := 0
- for _, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
- } else if p.Type == "string" && errvar != "" {
- text += fmt.Sprintf("\tvar _p%d *byte\n", n)
- text += fmt.Sprintf("\t_p%d, %s = BytePtrFromString(%s)\n", n, errvar, p.Name)
- text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
- args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- n++
- } else if p.Type == "string" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
- text += fmt.Sprintf("\tvar _p%d *byte\n", n)
- text += fmt.Sprintf("\t_p%d, _ = BytePtrFromString(%s)\n", n, p.Name)
- args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- n++
- } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
- // Convert slice into pointer, length.
- // Have to be careful not to take address of &a[0] if len == 0:
- // pass dummy pointer in that case.
- // Used to pass nil, but some OSes or simulators reject write(fd, nil, 0).
- text += fmt.Sprintf("\tvar _p%d unsafe.Pointer\n", n)
- text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = unsafe.Pointer(&%s[0])\n\t}", p.Name, n, p.Name)
- text += fmt.Sprintf(" else {\n\t\t_p%d = unsafe.Pointer(&_zero)\n\t}\n", n)
- args = append(args, fmt.Sprintf("uintptr(_p%d)", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
- n++
- } else if p.Type == "int64" && (*openbsd || *netbsd) {
- args = append(args, "0")
- if endianness == "big-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
- } else if endianness == "little-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
- }
- } else if p.Type == "int64" && *dragonfly {
- if regexp.MustCompile(`^(?i)extp(read|write)`).FindStringSubmatch(funct) == nil {
- args = append(args, "0")
- }
- if endianness == "big-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
- } else if endianness == "little-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
- }
- } else if (p.Type == "int64" || p.Type == "uint64") && endianness != "" {
- if len(args)%2 == 1 && *arm {
- // arm abi specifies 64-bit argument uses
- // (even, odd) pair
- args = append(args, "0")
- }
- if endianness == "big-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
- }
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
- }
- }
-
- // Determine which form to use; pad args with zeros.
- asm := "Syscall"
- if nonblock != nil {
- if errvar == "" && goos == "linux" {
- asm = "RawSyscallNoError"
- } else {
- asm = "RawSyscall"
- }
- } else {
- if errvar == "" && goos == "linux" {
- asm = "SyscallNoError"
- }
- }
- if len(args) <= 3 {
- for len(args) < 3 {
- args = append(args, "0")
- }
- } else if len(args) <= 6 {
- asm += "6"
- for len(args) < 6 {
- args = append(args, "0")
- }
- } else if len(args) <= 9 {
- asm += "9"
- for len(args) < 9 {
- args = append(args, "0")
- }
- } else {
- fmt.Fprintf(os.Stderr, "%s:%s too many arguments to system call\n", path, funct)
- }
-
- // System call number.
- if sysname == "" {
- sysname = "SYS_" + funct
- sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
- sysname = strings.ToUpper(sysname)
- }
-
- var libcFn string
- if libc {
- asm = "syscall_" + strings.ToLower(asm[:1]) + asm[1:] // internal syscall call
- sysname = strings.TrimPrefix(sysname, "SYS_") // remove SYS_
- sysname = strings.ToLower(sysname) // lowercase
- if sysname == "getdirentries64" {
- // Special case - libSystem name and
- // raw syscall name don't match.
- sysname = "__getdirentries64"
- }
- libcFn = sysname
- sysname = "funcPC(libc_" + sysname + "_trampoline)"
- }
-
- // Actual call.
- arglist := strings.Join(args, ", ")
- call := fmt.Sprintf("%s(%s, %s)", asm, sysname, arglist)
-
- // Assign return values.
- body := ""
- ret := []string{"_", "_", "_"}
- doErrno := false
- for i := 0; i < len(out); i++ {
- p := parseParam(out[i])
- reg := ""
- if p.Name == "err" && !*plan9 {
- reg = "e1"
- ret[2] = reg
- doErrno = true
- } else if p.Name == "err" && *plan9 {
- ret[0] = "r0"
- ret[2] = "e1"
- break
- } else {
- reg = fmt.Sprintf("r%d", i)
- ret[i] = reg
- }
- if p.Type == "bool" {
- reg = fmt.Sprintf("%s != 0", reg)
- }
- if p.Type == "int64" && endianness != "" {
- // 64-bit number in r1:r0 or r0:r1.
- if i+2 > len(out) {
- fmt.Fprintf(os.Stderr, "%s:%s not enough registers for int64 return\n", path, funct)
- }
- if endianness == "big-endian" {
- reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
- } else {
- reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
- }
- ret[i] = fmt.Sprintf("r%d", i)
- ret[i+1] = fmt.Sprintf("r%d", i+1)
- }
- if reg != "e1" || *plan9 {
- body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
- }
- }
- if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
- text += fmt.Sprintf("\t%s\n", call)
- } else {
- if errvar == "" && goos == "linux" {
- // raw syscall without error on Linux, see golang.org/issue/22924
- text += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], call)
- } else {
- text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
- }
- }
- text += body
-
- if *plan9 && ret[2] == "e1" {
- text += "\tif int32(r0) == -1 {\n"
- text += "\t\terr = e1\n"
- text += "\t}\n"
- } else if doErrno {
- text += "\tif e1 != 0 {\n"
- text += "\t\terr = errnoErr(e1)\n"
- text += "\t}\n"
- }
- text += "\treturn\n"
- text += "}\n\n"
-
- if libc && !trampolines[libcFn] {
- // some system calls share a trampoline, like read and readlen.
- trampolines[libcFn] = true
- // Declare assembly trampoline.
- text += fmt.Sprintf("func libc_%s_trampoline()\n", libcFn)
- // Assembly trampoline calls the libc_* function, which this magic
- // redirects to use the function from libSystem.
- text += fmt.Sprintf("//go:linkname libc_%s libc_%s\n", libcFn, libcFn)
- text += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"/usr/lib/libSystem.B.dylib\"\n", libcFn, libcFn)
- text += "\n"
- }
- }
- if err := s.Err(); err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- file.Close()
- }
- fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-import (
- "syscall"
- "unsafe"
-)
-
-var _ syscall.Errno
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
deleted file mode 100644
index 3be3cdf..0000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
+++ /dev/null
@@ -1,415 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_aix.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
- * The parameter lists must give a name for each argument.
- This includes return parameters.
- * The parameter lists must give a type for each argument:
- the (x, y, z int) shorthand is not allowed.
- * If the return parameter is an error number, it must be named err.
- * If go func name needs to be different than its libc name,
- * or the function is not in libc, name could be specified
- * at the end, after "=" sign, like
- //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-*/
-package main
-
-import (
- "bufio"
- "flag"
- "fmt"
- "os"
- "regexp"
- "strings"
-)
-
-var (
- b32 = flag.Bool("b32", false, "32bit big-endian")
- l32 = flag.Bool("l32", false, "32bit little-endian")
- aix = flag.Bool("aix", false, "aix")
- tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
- return "go run mksyscall_aix_ppc.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
- return *tags
-}
-
-// Param is function parameter
-type Param struct {
- Name string
- Type string
-}
-
-// usage prints the program usage
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc.go [-b32 | -l32] [-tags x,y] [file ...]\n")
- os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
- list = strings.TrimSpace(list)
- if list == "" {
- return []string{}
- }
- return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
- ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
- if ps == nil {
- fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
- os.Exit(1)
- }
- return Param{ps[1], ps[2]}
-}
-
-func main() {
- flag.Usage = usage
- flag.Parse()
- if len(flag.Args()) <= 0 {
- fmt.Fprintf(os.Stderr, "no files to parse provided\n")
- usage()
- }
-
- endianness := ""
- if *b32 {
- endianness = "big-endian"
- } else if *l32 {
- endianness = "little-endian"
- }
-
- pack := ""
- text := ""
- cExtern := "/*\n#include <stdint.h>\n#include <stddef.h>\n"
- for _, path := range flag.Args() {
- file, err := os.Open(path)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- s := bufio.NewScanner(file)
- for s.Scan() {
- t := s.Text()
- t = strings.TrimSpace(t)
- t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
- if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
- pack = p[1]
- }
- nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
- if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
- continue
- }
-
- // Line must be of the form
- // func Open(path string, mode int, perm int) (fd int, err error)
- // Split into name, in params, out params.
- f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
- if f == nil {
- fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
- os.Exit(1)
- }
- funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
- // Split argument lists on comma.
- in := parseParamList(inps)
- out := parseParamList(outps)
-
- inps = strings.Join(in, ", ")
- outps = strings.Join(out, ", ")
-
- // Try in vain to keep people from editing this file.
- // The theory is that they jump into the middle of the file
- // without reading the header.
- text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
- // Check if value return, err return available
- errvar := ""
- retvar := ""
- rettype := ""
- for _, param := range out {
- p := parseParam(param)
- if p.Type == "error" {
- errvar = p.Name
- } else {
- retvar = p.Name
- rettype = p.Type
- }
- }
-
- // System call name.
- if sysname == "" {
- sysname = funct
- }
- sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
- sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
- cRettype := ""
- if rettype == "unsafe.Pointer" {
- cRettype = "uintptr_t"
- } else if rettype == "uintptr" {
- cRettype = "uintptr_t"
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
- cRettype = "uintptr_t"
- } else if rettype == "int" {
- cRettype = "int"
- } else if rettype == "int32" {
- cRettype = "int"
- } else if rettype == "int64" {
- cRettype = "long long"
- } else if rettype == "uint32" {
- cRettype = "unsigned int"
- } else if rettype == "uint64" {
- cRettype = "unsigned long long"
- } else {
- cRettype = "int"
- }
- if sysname == "exit" {
- cRettype = "void"
- }
-
- // Change p.Types to c
- var cIn []string
- for _, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "string" {
- cIn = append(cIn, "uintptr_t")
- } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t", "size_t")
- } else if p.Type == "unsafe.Pointer" {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "uintptr" {
- cIn = append(cIn, "uintptr_t")
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "int" {
- cIn = append(cIn, "int")
- } else if p.Type == "int32" {
- cIn = append(cIn, "int")
- } else if p.Type == "int64" {
- cIn = append(cIn, "long long")
- } else if p.Type == "uint32" {
- cIn = append(cIn, "unsigned int")
- } else if p.Type == "uint64" {
- cIn = append(cIn, "unsigned long long")
- } else {
- cIn = append(cIn, "int")
- }
- }
-
- if funct != "fcntl" && funct != "FcntlInt" && funct != "readlen" && funct != "writelen" {
- if sysname == "select" {
- // select is a keyword of Go. Its name is
- // changed to c_select.
- cExtern += "#define c_select select\n"
- }
- // Imports of system calls from libc
- cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
- cIn := strings.Join(cIn, ", ")
- cExtern += fmt.Sprintf("(%s);\n", cIn)
- }
-
- // So file name.
- if *aix {
- if modname == "" {
- modname = "libc.a/shr_64.o"
- } else {
- fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
- os.Exit(1)
- }
- }
-
- strconvfunc := "C.CString"
-
- // Go function header.
- if outps != "" {
- outps = fmt.Sprintf(" (%s)", outps)
- }
- if text != "" {
- text += "\n"
- }
-
- text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
-
- // Prepare arguments to Syscall.
- var args []string
- n := 0
- argN := 0
- for _, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- args = append(args, "C.uintptr_t(uintptr(unsafe.Pointer("+p.Name+")))")
- } else if p.Type == "string" && errvar != "" {
- text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
- args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
- n++
- } else if p.Type == "string" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
- text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
- args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
- n++
- } else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
- // Convert slice into pointer, length.
- // Have to be careful not to take address of &a[0] if len == 0:
- // pass nil in that case.
- text += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
- text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
- args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(unsafe.Pointer(_p%d)))", n))
- n++
- text += fmt.Sprintf("\tvar _p%d int\n", n)
- text += fmt.Sprintf("\t_p%d = len(%s)\n", n, p.Name)
- args = append(args, fmt.Sprintf("C.size_t(_p%d)", n))
- n++
- } else if p.Type == "int64" && endianness != "" {
- if endianness == "big-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
- }
- n++
- } else if p.Type == "bool" {
- text += fmt.Sprintf("\tvar _p%d uint32\n", n)
- text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
- args = append(args, fmt.Sprintf("_p%d", n))
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
- args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
- } else if p.Type == "unsafe.Pointer" {
- args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
- } else if p.Type == "int" {
- if (argN == 2) && ((funct == "readlen") || (funct == "writelen")) {
- args = append(args, fmt.Sprintf("C.size_t(%s)", p.Name))
- } else if argN == 0 && funct == "fcntl" {
- args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else if (argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt")) {
- args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
- }
- } else if p.Type == "int32" {
- args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
- } else if p.Type == "int64" {
- args = append(args, fmt.Sprintf("C.longlong(%s)", p.Name))
- } else if p.Type == "uint32" {
- args = append(args, fmt.Sprintf("C.uint(%s)", p.Name))
- } else if p.Type == "uint64" {
- args = append(args, fmt.Sprintf("C.ulonglong(%s)", p.Name))
- } else if p.Type == "uintptr" {
- args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
- }
- argN++
- }
-
- // Actual call.
- arglist := strings.Join(args, ", ")
- call := ""
- if sysname == "exit" {
- if errvar != "" {
- call += "er :="
- } else {
- call += ""
- }
- } else if errvar != "" {
- call += "r0,er :="
- } else if retvar != "" {
- call += "r0,_ :="
- } else {
- call += ""
- }
- if sysname == "select" {
- // select is a keyword of Go. Its name is
- // changed to c_select.
- call += fmt.Sprintf("C.c_%s(%s)", sysname, arglist)
- } else {
- call += fmt.Sprintf("C.%s(%s)", sysname, arglist)
- }
-
- // Assign return values.
- body := ""
- for i := 0; i < len(out); i++ {
- p := parseParam(out[i])
- reg := ""
- if p.Name == "err" {
- reg = "e1"
- } else {
- reg = "r0"
- }
- if reg != "e1" {
- body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
- }
- }
-
- // verify return
- if sysname != "exit" && errvar != "" {
- if regexp.MustCompile(`^uintptr`).FindStringSubmatch(cRettype) != nil {
- body += "\tif (uintptr(r0) ==^uintptr(0) && er != nil) {\n"
- body += fmt.Sprintf("\t\t%s = er\n", errvar)
- body += "\t}\n"
- } else {
- body += "\tif (r0 ==-1 && er != nil) {\n"
- body += fmt.Sprintf("\t\t%s = er\n", errvar)
- body += "\t}\n"
- }
- } else if errvar != "" {
- body += "\tif (er != nil) {\n"
- body += fmt.Sprintf("\t\t%s = er\n", errvar)
- body += "\t}\n"
- }
-
- text += fmt.Sprintf("\t%s\n", call)
- text += body
-
- text += "\treturn\n"
- text += "}\n"
- }
- if err := s.Err(); err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- file.Close()
- }
- imp := ""
- if pack != "unix" {
- imp = "import \"golang.org/x/sys/unix\"\n"
-
- }
- fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, cExtern, imp, text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-
-%s
-*/
-import "C"
-import (
- "unsafe"
-)
-
-
-%s
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
deleted file mode 100644
index c960099..0000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
+++ /dev/null
@@ -1,614 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_aix.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
- * The parameter lists must give a name for each argument.
- This includes return parameters.
- * The parameter lists must give a type for each argument:
- the (x, y, z int) shorthand is not allowed.
- * If the return parameter is an error number, it must be named err.
- * If go func name needs to be different than its libc name,
- * or the function is not in libc, name could be specified
- * at the end, after "=" sign, like
- //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-
-
-This program will generate three files and handle both gc and gccgo implementation:
- - zsyscall_aix_ppc64.go: the common part of each implementation (error handler, pointer creation)
- - zsyscall_aix_ppc64_gc.go: gc part with //go_cgo_import_dynamic and a call to syscall6
- - zsyscall_aix_ppc64_gccgo.go: gccgo part with C function and conversion to C type.
-
- The generated code looks like this
-
-zsyscall_aix_ppc64.go
-func asyscall(...) (n int, err error) {
- // Pointer Creation
- r1, e1 := callasyscall(...)
- // Type Conversion
- // Error Handler
- return
-}
-
-zsyscall_aix_ppc64_gc.go
-//go:cgo_import_dynamic libc_asyscall asyscall "libc.a/shr_64.o"
-//go:linkname libc_asyscall libc_asyscall
-var asyscall syscallFunc
-
-func callasyscall(...) (r1 uintptr, e1 Errno) {
- r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_asyscall)), "nb_args", ... )
- return
-}
-
-zsyscall_aix_ppc64_ggcgo.go
-
-// int asyscall(...)
-
-import "C"
-
-func callasyscall(...) (r1 uintptr, e1 Errno) {
- r1 = uintptr(C.asyscall(...))
- e1 = syscall.GetErrno()
- return
-}
-*/
-
-package main
-
-import (
- "bufio"
- "flag"
- "fmt"
- "io/ioutil"
- "os"
- "regexp"
- "strings"
-)
-
-var (
- b32 = flag.Bool("b32", false, "32bit big-endian")
- l32 = flag.Bool("l32", false, "32bit little-endian")
- aix = flag.Bool("aix", false, "aix")
- tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
- return "go run mksyscall_aix_ppc64.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
- return *tags
-}
-
-// Param is function parameter
-type Param struct {
- Name string
- Type string
-}
-
-// usage prints the program usage
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc64.go [-b32 | -l32] [-tags x,y] [file ...]\n")
- os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
- list = strings.TrimSpace(list)
- if list == "" {
- return []string{}
- }
- return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
- ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
- if ps == nil {
- fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
- os.Exit(1)
- }
- return Param{ps[1], ps[2]}
-}
-
-func main() {
- flag.Usage = usage
- flag.Parse()
- if len(flag.Args()) <= 0 {
- fmt.Fprintf(os.Stderr, "no files to parse provided\n")
- usage()
- }
-
- endianness := ""
- if *b32 {
- endianness = "big-endian"
- } else if *l32 {
- endianness = "little-endian"
- }
-
- pack := ""
- // GCCGO
- textgccgo := ""
- cExtern := "/*\n#include <stdint.h>\n"
- // GC
- textgc := ""
- dynimports := ""
- linknames := ""
- var vars []string
- // COMMON
- textcommon := ""
- for _, path := range flag.Args() {
- file, err := os.Open(path)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- s := bufio.NewScanner(file)
- for s.Scan() {
- t := s.Text()
- t = strings.TrimSpace(t)
- t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
- if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
- pack = p[1]
- }
- nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
- if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
- continue
- }
-
- // Line must be of the form
- // func Open(path string, mode int, perm int) (fd int, err error)
- // Split into name, in params, out params.
- f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
- if f == nil {
- fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
- os.Exit(1)
- }
- funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
- // Split argument lists on comma.
- in := parseParamList(inps)
- out := parseParamList(outps)
-
- inps = strings.Join(in, ", ")
- outps = strings.Join(out, ", ")
-
- if sysname == "" {
- sysname = funct
- }
-
- onlyCommon := false
- if funct == "readlen" || funct == "writelen" || funct == "FcntlInt" || funct == "FcntlFlock" {
- // This function call another syscall which is already implemented.
- // Therefore, the gc and gccgo part must not be generated.
- onlyCommon = true
- }
-
- // Try in vain to keep people from editing this file.
- // The theory is that they jump into the middle of the file
- // without reading the header.
-
- textcommon += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
- if !onlyCommon {
- textgccgo += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
- textgc += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
- }
-
- // Check if value return, err return available
- errvar := ""
- rettype := ""
- for _, param := range out {
- p := parseParam(param)
- if p.Type == "error" {
- errvar = p.Name
- } else {
- rettype = p.Type
- }
- }
-
- sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
- sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
- // GCCGO Prototype return type
- cRettype := ""
- if rettype == "unsafe.Pointer" {
- cRettype = "uintptr_t"
- } else if rettype == "uintptr" {
- cRettype = "uintptr_t"
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
- cRettype = "uintptr_t"
- } else if rettype == "int" {
- cRettype = "int"
- } else if rettype == "int32" {
- cRettype = "int"
- } else if rettype == "int64" {
- cRettype = "long long"
- } else if rettype == "uint32" {
- cRettype = "unsigned int"
- } else if rettype == "uint64" {
- cRettype = "unsigned long long"
- } else {
- cRettype = "int"
- }
- if sysname == "exit" {
- cRettype = "void"
- }
-
- // GCCGO Prototype arguments type
- var cIn []string
- for i, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "string" {
- cIn = append(cIn, "uintptr_t")
- } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t", "size_t")
- } else if p.Type == "unsafe.Pointer" {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "uintptr" {
- cIn = append(cIn, "uintptr_t")
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
- cIn = append(cIn, "uintptr_t")
- } else if p.Type == "int" {
- if (i == 0 || i == 2) && funct == "fcntl" {
- // These fcntl arguments needs to be uintptr to be able to call FcntlInt and FcntlFlock
- cIn = append(cIn, "uintptr_t")
- } else {
- cIn = append(cIn, "int")
- }
-
- } else if p.Type == "int32" {
- cIn = append(cIn, "int")
- } else if p.Type == "int64" {
- cIn = append(cIn, "long long")
- } else if p.Type == "uint32" {
- cIn = append(cIn, "unsigned int")
- } else if p.Type == "uint64" {
- cIn = append(cIn, "unsigned long long")
- } else {
- cIn = append(cIn, "int")
- }
- }
-
- if !onlyCommon {
- // GCCGO Prototype Generation
- // Imports of system calls from libc
- if sysname == "select" {
- // select is a keyword of Go. Its name is
- // changed to c_select.
- cExtern += "#define c_select select\n"
- }
- cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
- cIn := strings.Join(cIn, ", ")
- cExtern += fmt.Sprintf("(%s);\n", cIn)
- }
- // GC Library name
- if modname == "" {
- modname = "libc.a/shr_64.o"
- } else {
- fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
- os.Exit(1)
- }
- sysvarname := fmt.Sprintf("libc_%s", sysname)
-
- if !onlyCommon {
- // GC Runtime import of function to allow cross-platform builds.
- dynimports += fmt.Sprintf("//go:cgo_import_dynamic %s %s \"%s\"\n", sysvarname, sysname, modname)
- // GC Link symbol to proc address variable.
- linknames += fmt.Sprintf("//go:linkname %s %s\n", sysvarname, sysvarname)
- // GC Library proc address variable.
- vars = append(vars, sysvarname)
- }
-
- strconvfunc := "BytePtrFromString"
- strconvtype := "*byte"
-
- // Go function header.
- if outps != "" {
- outps = fmt.Sprintf(" (%s)", outps)
- }
- if textcommon != "" {
- textcommon += "\n"
- }
-
- textcommon += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
-
- // Prepare arguments tocall.
- var argscommon []string // Arguments in the common part
- var argscall []string // Arguments for call prototype
- var argsgc []string // Arguments for gc call (with syscall6)
- var argsgccgo []string // Arguments for gccgo call (with C.name_of_syscall)
- n := 0
- argN := 0
- for _, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(%s))", p.Name))
- argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
- argsgc = append(argsgc, p.Name)
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else if p.Type == "string" && errvar != "" {
- textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
- textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
- textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-
- argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- argscall = append(argscall, fmt.Sprintf("_p%d uintptr ", n))
- argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
- n++
- } else if p.Type == "string" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
- textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
- textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
- textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-
- argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n))
- argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
- n++
- } else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
- // Convert slice into pointer, length.
- // Have to be careful not to take address of &a[0] if len == 0:
- // pass nil in that case.
- textcommon += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
- textcommon += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
- argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("len(%s)", p.Name))
- argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n), fmt.Sprintf("_lenp%d int", n))
- argsgc = append(argsgc, fmt.Sprintf("_p%d", n), fmt.Sprintf("uintptr(_lenp%d)", n))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n), fmt.Sprintf("C.size_t(_lenp%d)", n))
- n++
- } else if p.Type == "int64" && endianness != "" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses int64 with 32 bits mode. Case not yet implemented\n")
- } else if p.Type == "bool" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses bool. Case not yet implemented\n")
- } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil || p.Type == "unsafe.Pointer" {
- argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
- argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
- argsgc = append(argsgc, p.Name)
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else if p.Type == "int" {
- if (argN == 0 || argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt") || (funct == "FcntlFlock")) {
- // These fcntl arguments need to be uintptr to be able to call FcntlInt and FcntlFlock
- argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
- argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
- argsgc = append(argsgc, p.Name)
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-
- } else {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
- }
- } else if p.Type == "int32" {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s int32", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
- } else if p.Type == "int64" {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s int64", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.longlong(%s)", p.Name))
- } else if p.Type == "uint32" {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s uint32", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uint(%s)", p.Name))
- } else if p.Type == "uint64" {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s uint64", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.ulonglong(%s)", p.Name))
- } else if p.Type == "uintptr" {
- argscommon = append(argscommon, p.Name)
- argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
- argsgc = append(argsgc, p.Name)
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
- } else {
- argscommon = append(argscommon, fmt.Sprintf("int(%s)", p.Name))
- argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
- argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
- argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
- }
- argN++
- }
- nargs := len(argsgc)
-
- // COMMON function generation
- argscommonlist := strings.Join(argscommon, ", ")
- callcommon := fmt.Sprintf("call%s(%s)", sysname, argscommonlist)
- ret := []string{"_", "_"}
- body := ""
- doErrno := false
- for i := 0; i < len(out); i++ {
- p := parseParam(out[i])
- reg := ""
- if p.Name == "err" {
- reg = "e1"
- ret[1] = reg
- doErrno = true
- } else {
- reg = "r0"
- ret[0] = reg
- }
- if p.Type == "bool" {
- reg = fmt.Sprintf("%s != 0", reg)
- }
- if reg != "e1" {
- body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
- }
- }
- if ret[0] == "_" && ret[1] == "_" {
- textcommon += fmt.Sprintf("\t%s\n", callcommon)
- } else {
- textcommon += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], callcommon)
- }
- textcommon += body
-
- if doErrno {
- textcommon += "\tif e1 != 0 {\n"
- textcommon += "\t\terr = errnoErr(e1)\n"
- textcommon += "\t}\n"
- }
- textcommon += "\treturn\n"
- textcommon += "}\n"
-
- if onlyCommon {
- continue
- }
-
- // CALL Prototype
- callProto := fmt.Sprintf("func call%s(%s) (r1 uintptr, e1 Errno) {\n", sysname, strings.Join(argscall, ", "))
-
- // GC function generation
- asm := "syscall6"
- if nonblock != nil {
- asm = "rawSyscall6"
- }
-
- if len(argsgc) <= 6 {
- for len(argsgc) < 6 {
- argsgc = append(argsgc, "0")
- }
- } else {
- fmt.Fprintf(os.Stderr, "%s: too many arguments to system call", funct)
- os.Exit(1)
- }
- argsgclist := strings.Join(argsgc, ", ")
- callgc := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, argsgclist)
-
- textgc += callProto
- textgc += fmt.Sprintf("\tr1, _, e1 = %s\n", callgc)
- textgc += "\treturn\n}\n"
-
- // GCCGO function generation
- argsgccgolist := strings.Join(argsgccgo, ", ")
- var callgccgo string
- if sysname == "select" {
- // select is a keyword of Go. Its name is
- // changed to c_select.
- callgccgo = fmt.Sprintf("C.c_%s(%s)", sysname, argsgccgolist)
- } else {
- callgccgo = fmt.Sprintf("C.%s(%s)", sysname, argsgccgolist)
- }
- textgccgo += callProto
- textgccgo += fmt.Sprintf("\tr1 = uintptr(%s)\n", callgccgo)
- textgccgo += "\te1 = syscall.GetErrno()\n"
- textgccgo += "\treturn\n}\n"
- }
- if err := s.Err(); err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- file.Close()
- }
- imp := ""
- if pack != "unix" {
- imp = "import \"golang.org/x/sys/unix\"\n"
-
- }
-
- // Print zsyscall_aix_ppc64.go
- err := ioutil.WriteFile("zsyscall_aix_ppc64.go",
- []byte(fmt.Sprintf(srcTemplate1, cmdLine(), buildTags(), pack, imp, textcommon)),
- 0644)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
-
- // Print zsyscall_aix_ppc64_gc.go
- vardecls := "\t" + strings.Join(vars, ",\n\t")
- vardecls += " syscallFunc"
- err = ioutil.WriteFile("zsyscall_aix_ppc64_gc.go",
- []byte(fmt.Sprintf(srcTemplate2, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, textgc)),
- 0644)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
-
- // Print zsyscall_aix_ppc64_gccgo.go
- err = ioutil.WriteFile("zsyscall_aix_ppc64_gccgo.go",
- []byte(fmt.Sprintf(srcTemplate3, cmdLine(), buildTags(), pack, cExtern, imp, textgccgo)),
- 0644)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
-}
-
-const srcTemplate1 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-import (
- "unsafe"
-)
-
-
-%s
-
-%s
-`
-const srcTemplate2 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-// +build !gccgo
-
-package %s
-
-import (
- "unsafe"
-)
-%s
-%s
-%s
-type syscallFunc uintptr
-
-var (
-%s
-)
-
-// Implemented in runtime/syscall_aix.go.
-func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-
-%s
-`
-const srcTemplate3 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-// +build gccgo
-
-package %s
-
-%s
-*/
-import "C"
-import (
- "syscall"
-)
-
-
-%s
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_solaris.go b/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
deleted file mode 100644
index 3d86473..0000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
+++ /dev/null
@@ -1,335 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
- This program reads a file containing function prototypes
- (like syscall_solaris.go) and generates system call bodies.
- The prototypes are marked by lines beginning with "//sys"
- and read like func declarations if //sys is replaced by func, but:
- * The parameter lists must give a name for each argument.
- This includes return parameters.
- * The parameter lists must give a type for each argument:
- the (x, y, z int) shorthand is not allowed.
- * If the return parameter is an error number, it must be named err.
- * If go func name needs to be different than its libc name,
- * or the function is not in libc, name could be specified
- * at the end, after "=" sign, like
- //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-*/
-
-package main
-
-import (
- "bufio"
- "flag"
- "fmt"
- "os"
- "regexp"
- "strings"
-)
-
-var (
- b32 = flag.Bool("b32", false, "32bit big-endian")
- l32 = flag.Bool("l32", false, "32bit little-endian")
- tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
- return "go run mksyscall_solaris.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
- return *tags
-}
-
-// Param is function parameter
-type Param struct {
- Name string
- Type string
-}
-
-// usage prints the program usage
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: go run mksyscall_solaris.go [-b32 | -l32] [-tags x,y] [file ...]\n")
- os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
- list = strings.TrimSpace(list)
- if list == "" {
- return []string{}
- }
- return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
- ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
- if ps == nil {
- fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
- os.Exit(1)
- }
- return Param{ps[1], ps[2]}
-}
-
-func main() {
- flag.Usage = usage
- flag.Parse()
- if len(flag.Args()) <= 0 {
- fmt.Fprintf(os.Stderr, "no files to parse provided\n")
- usage()
- }
-
- endianness := ""
- if *b32 {
- endianness = "big-endian"
- } else if *l32 {
- endianness = "little-endian"
- }
-
- pack := ""
- text := ""
- dynimports := ""
- linknames := ""
- var vars []string
- for _, path := range flag.Args() {
- file, err := os.Open(path)
- if err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- s := bufio.NewScanner(file)
- for s.Scan() {
- t := s.Text()
- t = strings.TrimSpace(t)
- t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
- if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
- pack = p[1]
- }
- nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
- if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
- continue
- }
-
- // Line must be of the form
- // func Open(path string, mode int, perm int) (fd int, err error)
- // Split into name, in params, out params.
- f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
- if f == nil {
- fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
- os.Exit(1)
- }
- funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
- // Split argument lists on comma.
- in := parseParamList(inps)
- out := parseParamList(outps)
-
- inps = strings.Join(in, ", ")
- outps = strings.Join(out, ", ")
-
- // Try in vain to keep people from editing this file.
- // The theory is that they jump into the middle of the file
- // without reading the header.
- text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
- // So file name.
- if modname == "" {
- modname = "libc"
- }
-
- // System call name.
- if sysname == "" {
- sysname = funct
- }
-
- // System call pointer variable name.
- sysvarname := fmt.Sprintf("proc%s", sysname)
-
- strconvfunc := "BytePtrFromString"
- strconvtype := "*byte"
-
- sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
- // Runtime import of function to allow cross-platform builds.
- dynimports += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"%s.so\"\n", sysname, sysname, modname)
- // Link symbol to proc address variable.
- linknames += fmt.Sprintf("//go:linkname %s libc_%s\n", sysvarname, sysname)
- // Library proc address variable.
- vars = append(vars, sysvarname)
-
- // Go function header.
- outlist := strings.Join(out, ", ")
- if outlist != "" {
- outlist = fmt.Sprintf(" (%s)", outlist)
- }
- if text != "" {
- text += "\n"
- }
- text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outlist)
-
- // Check if err return available
- errvar := ""
- for _, param := range out {
- p := parseParam(param)
- if p.Type == "error" {
- errvar = p.Name
- continue
- }
- }
-
- // Prepare arguments to Syscall.
- var args []string
- n := 0
- for _, param := range in {
- p := parseParam(param)
- if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
- args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
- } else if p.Type == "string" && errvar != "" {
- text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
- text += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
- text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
- args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- n++
- } else if p.Type == "string" {
- fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
- text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
- text += fmt.Sprintf("\t_p%d, _ = %s(%s)\n", n, strconvfunc, p.Name)
- args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
- n++
- } else if s := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); s != nil {
- // Convert slice into pointer, length.
- // Have to be careful not to take address of &a[0] if len == 0:
- // pass nil in that case.
- text += fmt.Sprintf("\tvar _p%d *%s\n", n, s[1])
- text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
- args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
- n++
- } else if p.Type == "int64" && endianness != "" {
- if endianness == "big-endian" {
- args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
- }
- } else if p.Type == "bool" {
- text += fmt.Sprintf("\tvar _p%d uint32\n", n)
- text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
- args = append(args, fmt.Sprintf("uintptr(_p%d)", n))
- n++
- } else {
- args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
- }
- }
- nargs := len(args)
-
- // Determine which form to use; pad args with zeros.
- asm := "sysvicall6"
- if nonblock != nil {
- asm = "rawSysvicall6"
- }
- if len(args) <= 6 {
- for len(args) < 6 {
- args = append(args, "0")
- }
- } else {
- fmt.Fprintf(os.Stderr, "%s: too many arguments to system call\n", path)
- os.Exit(1)
- }
-
- // Actual call.
- arglist := strings.Join(args, ", ")
- call := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, arglist)
-
- // Assign return values.
- body := ""
- ret := []string{"_", "_", "_"}
- doErrno := false
- for i := 0; i < len(out); i++ {
- p := parseParam(out[i])
- reg := ""
- if p.Name == "err" {
- reg = "e1"
- ret[2] = reg
- doErrno = true
- } else {
- reg = fmt.Sprintf("r%d", i)
- ret[i] = reg
- }
- if p.Type == "bool" {
- reg = fmt.Sprintf("%d != 0", reg)
- }
- if p.Type == "int64" && endianness != "" {
- // 64-bit number in r1:r0 or r0:r1.
- if i+2 > len(out) {
- fmt.Fprintf(os.Stderr, "%s: not enough registers for int64 return\n", path)
- os.Exit(1)
- }
- if endianness == "big-endian" {
- reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
- } else {
- reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
- }
- ret[i] = fmt.Sprintf("r%d", i)
- ret[i+1] = fmt.Sprintf("r%d", i+1)
- }
- if reg != "e1" {
- body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
- }
- }
- if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
- text += fmt.Sprintf("\t%s\n", call)
- } else {
- text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
- }
- text += body
-
- if doErrno {
- text += "\tif e1 != 0 {\n"
- text += "\t\terr = e1\n"
- text += "\t}\n"
- }
- text += "\treturn\n"
- text += "}\n"
- }
- if err := s.Err(); err != nil {
- fmt.Fprintf(os.Stderr, err.Error())
- os.Exit(1)
- }
- file.Close()
- }
- imp := ""
- if pack != "unix" {
- imp = "import \"golang.org/x/sys/unix\"\n"
-
- }
- vardecls := "\t" + strings.Join(vars, ",\n\t")
- vardecls += " syscallFunc"
- fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-import (
- "syscall"
- "unsafe"
-)
-%s
-%s
-%s
-var (
-%s
-)
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
deleted file mode 100644
index b6b4099..0000000
--- a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
+++ /dev/null
@@ -1,355 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Parse the header files for OpenBSD and generate a Go usable sysctl MIB.
-//
-// Build a MIB with each entry being an array containing the level, type and
-// a hash that will contain additional entries if the current entry is a node.
-// We then walk this MIB and create a flattened sysctl name to OID hash.
-
-package main
-
-import (
- "bufio"
- "fmt"
- "os"
- "path/filepath"
- "regexp"
- "sort"
- "strings"
-)
-
-var (
- goos, goarch string
-)
-
-// cmdLine returns this programs's commandline arguments.
-func cmdLine() string {
- return "go run mksysctl_openbsd.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags.
-func buildTags() string {
- return fmt.Sprintf("%s,%s", goarch, goos)
-}
-
-// reMatch performs regular expression match and stores the substring slice to value pointed by m.
-func reMatch(re *regexp.Regexp, str string, m *[]string) bool {
- *m = re.FindStringSubmatch(str)
- if *m != nil {
- return true
- }
- return false
-}
-
-type nodeElement struct {
- n int
- t string
- pE *map[string]nodeElement
-}
-
-var (
- debugEnabled bool
- mib map[string]nodeElement
- node *map[string]nodeElement
- nodeMap map[string]string
- sysCtl []string
-)
-
-var (
- ctlNames1RE = regexp.MustCompile(`^#define\s+(CTL_NAMES)\s+{`)
- ctlNames2RE = regexp.MustCompile(`^#define\s+(CTL_(.*)_NAMES)\s+{`)
- ctlNames3RE = regexp.MustCompile(`^#define\s+((.*)CTL_NAMES)\s+{`)
- netInetRE = regexp.MustCompile(`^netinet/`)
- netInet6RE = regexp.MustCompile(`^netinet6/`)
- netRE = regexp.MustCompile(`^net/`)
- bracesRE = regexp.MustCompile(`{.*}`)
- ctlTypeRE = regexp.MustCompile(`{\s+"(\w+)",\s+(CTLTYPE_[A-Z]+)\s+}`)
- fsNetKernRE = regexp.MustCompile(`^(fs|net|kern)_`)
-)
-
-func debug(s string) {
- if debugEnabled {
- fmt.Fprintln(os.Stderr, s)
- }
-}
-
-// Walk the MIB and build a sysctl name to OID mapping.
-func buildSysctl(pNode *map[string]nodeElement, name string, oid []int) {
- lNode := pNode // local copy of pointer to node
- var keys []string
- for k := range *lNode {
- keys = append(keys, k)
- }
- sort.Strings(keys)
-
- for _, key := range keys {
- nodename := name
- if name != "" {
- nodename += "."
- }
- nodename += key
-
- nodeoid := append(oid, (*pNode)[key].n)
-
- if (*pNode)[key].t == `CTLTYPE_NODE` {
- if _, ok := nodeMap[nodename]; ok {
- lNode = &mib
- ctlName := nodeMap[nodename]
- for _, part := range strings.Split(ctlName, ".") {
- lNode = ((*lNode)[part]).pE
- }
- } else {
- lNode = (*pNode)[key].pE
- }
- buildSysctl(lNode, nodename, nodeoid)
- } else if (*pNode)[key].t != "" {
- oidStr := []string{}
- for j := range nodeoid {
- oidStr = append(oidStr, fmt.Sprintf("%d", nodeoid[j]))
- }
- text := "\t{ \"" + nodename + "\", []_C_int{ " + strings.Join(oidStr, ", ") + " } }, \n"
- sysCtl = append(sysCtl, text)
- }
- }
-}
-
-func main() {
- // Get the OS (using GOOS_TARGET if it exist)
- goos = os.Getenv("GOOS_TARGET")
- if goos == "" {
- goos = os.Getenv("GOOS")
- }
- // Get the architecture (using GOARCH_TARGET if it exists)
- goarch = os.Getenv("GOARCH_TARGET")
- if goarch == "" {
- goarch = os.Getenv("GOARCH")
- }
- // Check if GOOS and GOARCH environment variables are defined
- if goarch == "" || goos == "" {
- fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
- os.Exit(1)
- }
-
- mib = make(map[string]nodeElement)
- headers := [...]string{
- `sys/sysctl.h`,
- `sys/socket.h`,
- `sys/tty.h`,
- `sys/malloc.h`,
- `sys/mount.h`,
- `sys/namei.h`,
- `sys/sem.h`,
- `sys/shm.h`,
- `sys/vmmeter.h`,
- `uvm/uvmexp.h`,
- `uvm/uvm_param.h`,
- `uvm/uvm_swap_encrypt.h`,
- `ddb/db_var.h`,
- `net/if.h`,
- `net/if_pfsync.h`,
- `net/pipex.h`,
- `netinet/in.h`,
- `netinet/icmp_var.h`,
- `netinet/igmp_var.h`,
- `netinet/ip_ah.h`,
- `netinet/ip_carp.h`,
- `netinet/ip_divert.h`,
- `netinet/ip_esp.h`,
- `netinet/ip_ether.h`,
- `netinet/ip_gre.h`,
- `netinet/ip_ipcomp.h`,
- `netinet/ip_ipip.h`,
- `netinet/pim_var.h`,
- `netinet/tcp_var.h`,
- `netinet/udp_var.h`,
- `netinet6/in6.h`,
- `netinet6/ip6_divert.h`,
- `netinet6/pim6_var.h`,
- `netinet/icmp6.h`,
- `netmpls/mpls.h`,
- }
-
- ctls := [...]string{
- `kern`,
- `vm`,
- `fs`,
- `net`,
- //debug /* Special handling required */
- `hw`,
- //machdep /* Arch specific */
- `user`,
- `ddb`,
- //vfs /* Special handling required */
- `fs.posix`,
- `kern.forkstat`,
- `kern.intrcnt`,
- `kern.malloc`,
- `kern.nchstats`,
- `kern.seminfo`,
- `kern.shminfo`,
- `kern.timecounter`,
- `kern.tty`,
- `kern.watchdog`,
- `net.bpf`,
- `net.ifq`,
- `net.inet`,
- `net.inet.ah`,
- `net.inet.carp`,
- `net.inet.divert`,
- `net.inet.esp`,
- `net.inet.etherip`,
- `net.inet.gre`,
- `net.inet.icmp`,
- `net.inet.igmp`,
- `net.inet.ip`,
- `net.inet.ip.ifq`,
- `net.inet.ipcomp`,
- `net.inet.ipip`,
- `net.inet.mobileip`,
- `net.inet.pfsync`,
- `net.inet.pim`,
- `net.inet.tcp`,
- `net.inet.udp`,
- `net.inet6`,
- `net.inet6.divert`,
- `net.inet6.ip6`,
- `net.inet6.icmp6`,
- `net.inet6.pim6`,
- `net.inet6.tcp6`,
- `net.inet6.udp6`,
- `net.mpls`,
- `net.mpls.ifq`,
- `net.key`,
- `net.pflow`,
- `net.pfsync`,
- `net.pipex`,
- `net.rt`,
- `vm.swapencrypt`,
- //vfsgenctl /* Special handling required */
- }
-
- // Node name "fixups"
- ctlMap := map[string]string{
- "ipproto": "net.inet",
- "net.inet.ipproto": "net.inet",
- "net.inet6.ipv6proto": "net.inet6",
- "net.inet6.ipv6": "net.inet6.ip6",
- "net.inet.icmpv6": "net.inet6.icmp6",
- "net.inet6.divert6": "net.inet6.divert",
- "net.inet6.tcp6": "net.inet.tcp",
- "net.inet6.udp6": "net.inet.udp",
- "mpls": "net.mpls",
- "swpenc": "vm.swapencrypt",
- }
-
- // Node mappings
- nodeMap = map[string]string{
- "net.inet.ip.ifq": "net.ifq",
- "net.inet.pfsync": "net.pfsync",
- "net.mpls.ifq": "net.ifq",
- }
-
- mCtls := make(map[string]bool)
- for _, ctl := range ctls {
- mCtls[ctl] = true
- }
-
- for _, header := range headers {
- debug("Processing " + header)
- file, err := os.Open(filepath.Join("/usr/include", header))
- if err != nil {
- fmt.Fprintf(os.Stderr, "%v\n", err)
- os.Exit(1)
- }
- s := bufio.NewScanner(file)
- for s.Scan() {
- var sub []string
- if reMatch(ctlNames1RE, s.Text(), &sub) ||
- reMatch(ctlNames2RE, s.Text(), &sub) ||
- reMatch(ctlNames3RE, s.Text(), &sub) {
- if sub[1] == `CTL_NAMES` {
- // Top level.
- node = &mib
- } else {
- // Node.
- nodename := strings.ToLower(sub[2])
- ctlName := ""
- if reMatch(netInetRE, header, &sub) {
- ctlName = "net.inet." + nodename
- } else if reMatch(netInet6RE, header, &sub) {
- ctlName = "net.inet6." + nodename
- } else if reMatch(netRE, header, &sub) {
- ctlName = "net." + nodename
- } else {
- ctlName = nodename
- ctlName = fsNetKernRE.ReplaceAllString(ctlName, `$1.`)
- }
-
- if val, ok := ctlMap[ctlName]; ok {
- ctlName = val
- }
- if _, ok := mCtls[ctlName]; !ok {
- debug("Ignoring " + ctlName + "...")
- continue
- }
-
- // Walk down from the top of the MIB.
- node = &mib
- for _, part := range strings.Split(ctlName, ".") {
- if _, ok := (*node)[part]; !ok {
- debug("Missing node " + part)
- (*node)[part] = nodeElement{n: 0, t: "", pE: &map[string]nodeElement{}}
- }
- node = (*node)[part].pE
- }
- }
-
- // Populate current node with entries.
- i := -1
- for !strings.HasPrefix(s.Text(), "}") {
- s.Scan()
- if reMatch(bracesRE, s.Text(), &sub) {
- i++
- }
- if !reMatch(ctlTypeRE, s.Text(), &sub) {
- continue
- }
- (*node)[sub[1]] = nodeElement{n: i, t: sub[2], pE: &map[string]nodeElement{}}
- }
- }
- }
- err = s.Err()
- if err != nil {
- fmt.Fprintf(os.Stderr, "%v\n", err)
- os.Exit(1)
- }
- file.Close()
- }
- buildSysctl(&mib, "", []int{})
-
- sort.Strings(sysCtl)
- text := strings.Join(sysCtl, "")
-
- fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-type mibentry struct {
- ctlname string
- ctloid []_C_int
-}
-
-var sysctlMib = []mibentry {
-%s
-}
-`
diff --git a/vendor/golang.org/x/sys/unix/mksysnum.go b/vendor/golang.org/x/sys/unix/mksysnum.go
deleted file mode 100644
index baa6ecd..0000000
--- a/vendor/golang.org/x/sys/unix/mksysnum.go
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Generate system call table for DragonFly, NetBSD,
-// FreeBSD, OpenBSD or Darwin from master list
-// (for example, /usr/src/sys/kern/syscalls.master or
-// sys/syscall.h).
-package main
-
-import (
- "bufio"
- "fmt"
- "io"
- "io/ioutil"
- "net/http"
- "os"
- "regexp"
- "strings"
-)
-
-var (
- goos, goarch string
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
- return "go run mksysnum.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
- return fmt.Sprintf("%s,%s", goarch, goos)
-}
-
-func checkErr(err error) {
- if err != nil {
- fmt.Fprintf(os.Stderr, "%v\n", err)
- os.Exit(1)
- }
-}
-
-// source string and substring slice for regexp
-type re struct {
- str string // source string
- sub []string // matched sub-string
-}
-
-// Match performs regular expression match
-func (r *re) Match(exp string) bool {
- r.sub = regexp.MustCompile(exp).FindStringSubmatch(r.str)
- if r.sub != nil {
- return true
- }
- return false
-}
-
-// fetchFile fetches a text file from URL
-func fetchFile(URL string) io.Reader {
- resp, err := http.Get(URL)
- checkErr(err)
- defer resp.Body.Close()
- body, err := ioutil.ReadAll(resp.Body)
- checkErr(err)
- return strings.NewReader(string(body))
-}
-
-// readFile reads a text file from path
-func readFile(path string) io.Reader {
- file, err := os.Open(os.Args[1])
- checkErr(err)
- return file
-}
-
-func format(name, num, proto string) string {
- name = strings.ToUpper(name)
- // There are multiple entries for enosys and nosys, so comment them out.
- nm := re{str: name}
- if nm.Match(`^SYS_E?NOSYS$`) {
- name = fmt.Sprintf("// %s", name)
- }
- if name == `SYS_SYS_EXIT` {
- name = `SYS_EXIT`
- }
- return fmt.Sprintf(" %s = %s; // %s\n", name, num, proto)
-}
-
-func main() {
- // Get the OS (using GOOS_TARGET if it exist)
- goos = os.Getenv("GOOS_TARGET")
- if goos == "" {
- goos = os.Getenv("GOOS")
- }
- // Get the architecture (using GOARCH_TARGET if it exists)
- goarch = os.Getenv("GOARCH_TARGET")
- if goarch == "" {
- goarch = os.Getenv("GOARCH")
- }
- // Check if GOOS and GOARCH environment variables are defined
- if goarch == "" || goos == "" {
- fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
- os.Exit(1)
- }
-
- file := strings.TrimSpace(os.Args[1])
- var syscalls io.Reader
- if strings.HasPrefix(file, "https://") || strings.HasPrefix(file, "http://") {
- // Download syscalls.master file
- syscalls = fetchFile(file)
- } else {
- syscalls = readFile(file)
- }
-
- var text, line string
- s := bufio.NewScanner(syscalls)
- for s.Scan() {
- t := re{str: line}
- if t.Match(`^(.*)\\$`) {
- // Handle continuation
- line = t.sub[1]
- line += strings.TrimLeft(s.Text(), " \t")
- } else {
- // New line
- line = s.Text()
- }
- t = re{str: line}
- if t.Match(`\\$`) {
- continue
- }
- t = re{str: line}
-
- switch goos {
- case "dragonfly":
- if t.Match(`^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$`) {
- num, proto := t.sub[1], t.sub[2]
- name := fmt.Sprintf("SYS_%s", t.sub[3])
- text += format(name, num, proto)
- }
- case "freebsd":
- if t.Match(`^([0-9]+)\s+\S+\s+(?:(?:NO)?STD|COMPAT10)\s+({ \S+\s+(\w+).*)$`) {
- num, proto := t.sub[1], t.sub[2]
- name := fmt.Sprintf("SYS_%s", t.sub[3])
- text += format(name, num, proto)
- }
- case "openbsd":
- if t.Match(`^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\*?(\w+).*)$`) {
- num, proto, name := t.sub[1], t.sub[3], t.sub[4]
- text += format(name, num, proto)
- }
- case "netbsd":
- if t.Match(`^([0-9]+)\s+((STD)|(NOERR))\s+(RUMP\s+)?({\s+\S+\s*\*?\s*\|(\S+)\|(\S*)\|(\w+).*\s+})(\s+(\S+))?$`) {
- num, proto, compat := t.sub[1], t.sub[6], t.sub[8]
- name := t.sub[7] + "_" + t.sub[9]
- if t.sub[11] != "" {
- name = t.sub[7] + "_" + t.sub[11]
- }
- name = strings.ToUpper(name)
- if compat == "" || compat == "13" || compat == "30" || compat == "50" {
- text += fmt.Sprintf(" %s = %s; // %s\n", name, num, proto)
- }
- }
- case "darwin":
- if t.Match(`^#define\s+SYS_(\w+)\s+([0-9]+)`) {
- name, num := t.sub[1], t.sub[2]
- name = strings.ToUpper(name)
- text += fmt.Sprintf(" SYS_%s = %s;\n", name, num)
- }
- default:
- fmt.Fprintf(os.Stderr, "unrecognized GOOS=%s\n", goos)
- os.Exit(1)
-
- }
- }
- err := s.Err()
- checkErr(err)
-
- fmt.Printf(template, cmdLine(), buildTags(), text)
-}
-
-const template = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-const(
-%s)`
diff --git a/vendor/golang.org/x/sys/unix/types_aix.go b/vendor/golang.org/x/sys/unix/types_aix.go
deleted file mode 100644
index 40d2bee..0000000
--- a/vendor/golang.org/x/sys/unix/types_aix.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-// +build aix
-
-/*
-Input to cgo -godefs. See also mkerrors.sh and mkall.sh
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/limits.h>
-#include <sys/un.h>
-#include <utime.h>
-#include <sys/utsname.h>
-#include <sys/poll.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
-#include <sys/termio.h>
-#include <sys/ioctl.h>
-
-#include <termios.h>
-
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-
-
-#include <dirent.h>
-#include <fcntl.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
- PathMax = C.PATH_MAX
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-type off64 C.off64_t
-type off C.off_t
-type Mode_t C.mode_t
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-type Timex C.struct_timex
-
-type Time_t C.time_t
-
-type Tms C.struct_tms
-
-type Utimbuf C.struct_utimbuf
-
-type Timezone C.struct_timezone
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit64
-
-type Pid_t C.pid_t
-
-type _Gid_t C.gid_t
-
-type dev_t C.dev_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type StatxTimestamp C.struct_statx_timestamp
-
-type Statx_t C.struct_statx
-
-type Dirent C.struct_dirent
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Cmsghdr C.struct_cmsghdr
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type Linger C.struct_linger
-
-type Msghdr C.struct_msghdr
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
-)
-
-type IfMsgHdr C.struct_if_msghdr
-
-// Misc
-
-type FdSet C.fd_set
-
-type Utsname C.struct_utsname
-
-type Ustat_t C.struct_ustat
-
-type Sigset_t C.sigset_t
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_REMOVEDIR = C.AT_REMOVEDIR
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Termio C.struct_termio
-
-type Winsize C.struct_winsize
-
-//poll
-
-type PollFd struct {
- Fd int32
- Events uint16
- Revents uint16
-}
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-//flock_t
-
-type Flock_t C.struct_flock64
-
-// Statfs
-
-type Fsid_t C.struct_fsid_t
-type Fsid64_t C.struct_fsid64_t
-
-type Statfs_t C.struct_statfs
-
-const RNDGETENTCNT = 0x80045200
diff --git a/vendor/golang.org/x/sys/unix/types_darwin.go b/vendor/golang.org/x/sys/unix/types_darwin.go
deleted file mode 100644
index 155c2e6..0000000
--- a/vendor/golang.org/x/sys/unix/types_darwin.go
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define __DARWIN_UNIX03 0
-#define KERNEL
-#define _DARWIN_USE_64_BIT_INODE
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <unistd.h>
-#include <mach/mach.h>
-#include <mach/message.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/if_var.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat64
-
-type Statfs_t C.struct_statfs64
-
-type Flock_t C.struct_flock
-
-type Fstore_t C.struct_fstore
-
-type Radvisory_t C.struct_radvisory
-
-type Fbootstraptransfer_t C.struct_fbootstraptransfer
-
-type Log2phys_t C.struct_log2phys
-
-type Fsid C.struct_fsid
-
-type Dirent C.struct_dirent
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet4Pktinfo C.struct_in_pktinfo
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet4Pktinfo = C.sizeof_struct_in_pktinfo
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
- PTRACE_TRACEME = C.PT_TRACE_ME
- PTRACE_CONT = C.PT_CONTINUE
- PTRACE_KILL = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfData = C.sizeof_struct_if_data
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofIfmaMsghdr = C.sizeof_struct_ifma_msghdr
- SizeofIfmaMsghdr2 = C.sizeof_struct_ifma_msghdr2
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfmaMsghdr2 C.struct_ifma_msghdr2
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_REMOVEDIR = C.AT_REMOVEDIR
- AT_SYMLINK_FOLLOW = C.AT_SYMLINK_FOLLOW
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-// uname
-
-type Utsname C.struct_utsname
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_dragonfly.go b/vendor/golang.org/x/sys/unix/types_dragonfly.go
deleted file mode 100644
index 3365dd7..0000000
--- a/vendor/golang.org/x/sys/unix/types_dragonfly.go
+++ /dev/null
@@ -1,263 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.struct_fsid
-
-// File system limits
-
-const (
- PathMax = C.PATH_MAX
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
- PTRACE_TRACEME = C.PT_TRACE_ME
- PTRACE_CONT = C.PT_CONTINUE
- PTRACE_KILL = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfData = C.sizeof_struct_if_data
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofIfmaMsghdr = C.sizeof_struct_ifma_msghdr
- SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-// Uname
-
-type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_freebsd.go b/vendor/golang.org/x/sys/unix/types_freebsd.go
deleted file mode 100644
index a121dc3..0000000
--- a/vendor/golang.org/x/sys/unix/types_freebsd.go
+++ /dev/null
@@ -1,400 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define _WANT_FREEBSD11_STAT 1
-#define _WANT_FREEBSD11_STATFS 1
-#define _WANT_FREEBSD11_DIRENT 1
-#define _WANT_FREEBSD11_KEVENT 1
-
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/capsicum.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-// This structure is a duplicate of if_data on FreeBSD 8-STABLE.
-// See /usr/include/net/if.h.
-struct if_data8 {
- u_char ifi_type;
- u_char ifi_physical;
- u_char ifi_addrlen;
- u_char ifi_hdrlen;
- u_char ifi_link_state;
- u_char ifi_spare_char1;
- u_char ifi_spare_char2;
- u_char ifi_datalen;
- u_long ifi_mtu;
- u_long ifi_metric;
- u_long ifi_baudrate;
- u_long ifi_ipackets;
- u_long ifi_ierrors;
- u_long ifi_opackets;
- u_long ifi_oerrors;
- u_long ifi_collisions;
- u_long ifi_ibytes;
- u_long ifi_obytes;
- u_long ifi_imcasts;
- u_long ifi_omcasts;
- u_long ifi_iqdrops;
- u_long ifi_noproto;
- u_long ifi_hwassist;
-// FIXME: these are now unions, so maybe need to change definitions?
-#undef ifi_epoch
- time_t ifi_epoch;
-#undef ifi_lastchange
- struct timeval ifi_lastchange;
-};
-
-// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE.
-// See /usr/include/net/if.h.
-struct if_msghdr8 {
- u_short ifm_msglen;
- u_char ifm_version;
- u_char ifm_type;
- int ifm_addrs;
- int ifm_flags;
- u_short ifm_index;
- struct if_data8 ifm_data;
-};
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-const (
- _statfsVersion = C.STATFS_VERSION
- _dirblksiz = C.DIRBLKSIZ
-)
-
-type Stat_t C.struct_stat
-
-type stat_freebsd11_t C.struct_freebsd11_stat
-
-type Statfs_t C.struct_statfs
-
-type statfs_freebsd11_t C.struct_freebsd11_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type dirent_freebsd11 C.struct_freebsd11_dirent
-
-type Fsid C.struct_fsid
-
-// File system limits
-
-const (
- PathMax = C.PATH_MAX
-)
-
-// Advice to Fadvise
-
-const (
- FADV_NORMAL = C.POSIX_FADV_NORMAL
- FADV_RANDOM = C.POSIX_FADV_RANDOM
- FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
- FADV_WILLNEED = C.POSIX_FADV_WILLNEED
- FADV_DONTNEED = C.POSIX_FADV_DONTNEED
- FADV_NOREUSE = C.POSIX_FADV_NOREUSE
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPMreqn C.struct_ip_mreqn
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPMreqn = C.sizeof_struct_ip_mreqn
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
- PTRACE_ATTACH = C.PT_ATTACH
- PTRACE_CONT = C.PT_CONTINUE
- PTRACE_DETACH = C.PT_DETACH
- PTRACE_GETFPREGS = C.PT_GETFPREGS
- PTRACE_GETFSBASE = C.PT_GETFSBASE
- PTRACE_GETLWPLIST = C.PT_GETLWPLIST
- PTRACE_GETNUMLWPS = C.PT_GETNUMLWPS
- PTRACE_GETREGS = C.PT_GETREGS
- PTRACE_GETXSTATE = C.PT_GETXSTATE
- PTRACE_IO = C.PT_IO
- PTRACE_KILL = C.PT_KILL
- PTRACE_LWPEVENTS = C.PT_LWP_EVENTS
- PTRACE_LWPINFO = C.PT_LWPINFO
- PTRACE_SETFPREGS = C.PT_SETFPREGS
- PTRACE_SETREGS = C.PT_SETREGS
- PTRACE_SINGLESTEP = C.PT_STEP
- PTRACE_TRACEME = C.PT_TRACE_ME
-)
-
-const (
- PIOD_READ_D = C.PIOD_READ_D
- PIOD_WRITE_D = C.PIOD_WRITE_D
- PIOD_READ_I = C.PIOD_READ_I
- PIOD_WRITE_I = C.PIOD_WRITE_I
-)
-
-const (
- PL_FLAG_BORN = C.PL_FLAG_BORN
- PL_FLAG_EXITED = C.PL_FLAG_EXITED
- PL_FLAG_SI = C.PL_FLAG_SI
-)
-
-const (
- TRAP_BRKPT = C.TRAP_BRKPT
- TRAP_TRACE = C.TRAP_TRACE
-)
-
-type PtraceLwpInfoStruct C.struct_ptrace_lwpinfo
-
-type __Siginfo C.struct___siginfo
-
-type Sigset_t C.sigset_t
-
-type Reg C.struct_reg
-
-type FpReg C.struct_fpreg
-
-type PtraceIoDesc C.struct_ptrace_io_desc
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent_freebsd11
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
- sizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr8
- sizeofIfData = C.sizeof_struct_if_data
- SizeofIfData = C.sizeof_struct_if_data8
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofIfmaMsghdr = C.sizeof_struct_ifma_msghdr
- SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type ifMsghdr C.struct_if_msghdr
-
-type IfMsghdr C.struct_if_msghdr8
-
-type ifData C.struct_if_data
-
-type IfData C.struct_if_data8
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfZbuf = C.sizeof_struct_bpf_zbuf
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
- SizeofBpfZbufHeader = C.sizeof_struct_bpf_zbuf_header
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfZbuf C.struct_bpf_zbuf
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfZbufHeader C.struct_bpf_zbuf_header
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_REMOVEDIR = C.AT_REMOVEDIR
- AT_SYMLINK_FOLLOW = C.AT_SYMLINK_FOLLOW
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLINIGNEOF = C.POLLINIGNEOF
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-// Capabilities
-
-type CapRights C.struct_cap_rights
-
-// Uname
-
-type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_netbsd.go b/vendor/golang.org/x/sys/unix/types_netbsd.go
deleted file mode 100644
index 4a96d72..0000000
--- a/vendor/golang.org/x/sys/unix/types_netbsd.go
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/sysctl.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.fsid_t
-
-// File system limits
-
-const (
- PathMax = C.PATH_MAX
-)
-
-// Advice to Fadvise
-
-const (
- FADV_NORMAL = C.POSIX_FADV_NORMAL
- FADV_RANDOM = C.POSIX_FADV_RANDOM
- FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
- FADV_WILLNEED = C.POSIX_FADV_WILLNEED
- FADV_DONTNEED = C.POSIX_FADV_DONTNEED
- FADV_NOREUSE = C.POSIX_FADV_NOREUSE
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
- PTRACE_TRACEME = C.PT_TRACE_ME
- PTRACE_CONT = C.PT_CONTINUE
- PTRACE_KILL = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfData = C.sizeof_struct_if_data
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-type Mclpool C.struct_mclpool
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfTimeval C.struct_bpf_timeval
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-type Ptmget C.struct_ptmget
-
-// fchmodat-like syscalls.
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_SYMLINK_FOLLOW = C.AT_SYMLINK_FOLLOW
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-// Sysctl
-
-type Sysctlnode C.struct_sysctlnode
-
-// Uname
-
-type Utsname C.struct_utsname
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_openbsd.go b/vendor/golang.org/x/sys/unix/types_openbsd.go
deleted file mode 100644
index 775cb57..0000000
--- a/vendor/golang.org/x/sys/unix/types_openbsd.go
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <uvm/uvmexp.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.fsid_t
-
-// File system limits
-
-const (
- PathMax = C.PATH_MAX
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
- PTRACE_TRACEME = C.PT_TRACE_ME
- PTRACE_CONT = C.PT_CONTINUE
- PTRACE_KILL = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfData = C.sizeof_struct_if_data
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-type Mclpool C.struct_mclpool
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfTimeval C.struct_bpf_timeval
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_SYMLINK_FOLLOW = C.AT_SYMLINK_FOLLOW
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
-
-// Signal Sets
-
-type Sigset_t C.sigset_t
-
-// Uname
-
-type Utsname C.struct_utsname
-
-// Uvmexp
-
-const SizeofUvmexp = C.sizeof_struct_uvmexp
-
-type Uvmexp C.struct_uvmexp
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_solaris.go b/vendor/golang.org/x/sys/unix/types_solaris.go
deleted file mode 100644
index 2b716f9..0000000
--- a/vendor/golang.org/x/sys/unix/types_solaris.go
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-Input to cgo -godefs. See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-// These defines ensure that builds done on newer versions of Solaris are
-// backwards-compatible with older versions of Solaris and
-// OpenSolaris-based derivatives.
-#define __USE_SUNOS_SOCKETS__ // msghdr
-#define __USE_LEGACY_PROTOTYPES__ // iovec
-#include <dirent.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <limits.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <termio.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sys/time.h>
-#include <sys/times.h>
-#include <sys/types.h>
-#include <sys/utsname.h>
-#include <sys/un.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-#include <ustat.h>
-#include <utime.h>
-
-enum {
- sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
- struct sockaddr s1; // this one gets used for fields
- struct sockaddr_in s2; // these pad it out
- struct sockaddr_in6 s3;
- struct sockaddr_un s4;
- struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
- struct sockaddr addr;
- char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
- SizeofPtr = C.sizeofPtr
- SizeofShort = C.sizeof_short
- SizeofInt = C.sizeof_int
- SizeofLong = C.sizeof_long
- SizeofLongLong = C.sizeof_longlong
- PathMax = C.PATH_MAX
- MaxHostNameLen = C.MAXHOSTNAMELEN
-)
-
-// Basic types
-
-type (
- _C_short C.short
- _C_int C.int
- _C_long C.long
- _C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-type Tms C.struct_tms
-
-type Utimbuf C.struct_utimbuf
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-// Filesystems
-
-type _Fsblkcnt_t C.fsblkcnt_t
-
-type Statvfs_t C.struct_statvfs
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
- SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in
- SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6
- SizeofSockaddrAny = C.sizeof_struct_sockaddr_any
- SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un
- SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
- SizeofLinger = C.sizeof_struct_linger
- SizeofIPMreq = C.sizeof_struct_ip_mreq
- SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq
- SizeofMsghdr = C.sizeof_struct_msghdr
- SizeofCmsghdr = C.sizeof_struct_cmsghdr
- SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo
- SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo
- SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter
-)
-
-// Select
-
-type FdSet C.fd_set
-
-// Misc
-
-type Utsname C.struct_utsname
-
-type Ustat_t C.struct_ustat
-
-const (
- AT_FDCWD = C.AT_FDCWD
- AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
- AT_SYMLINK_FOLLOW = C.AT_SYMLINK_FOLLOW
- AT_REMOVEDIR = C.AT_REMOVEDIR
- AT_EACCESS = C.AT_EACCESS
-)
-
-// Routing and interface messages
-
-const (
- SizeofIfMsghdr = C.sizeof_struct_if_msghdr
- SizeofIfData = C.sizeof_struct_if_data
- SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
- SizeofRtMsghdr = C.sizeof_struct_rt_msghdr
- SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
- SizeofBpfVersion = C.sizeof_struct_bpf_version
- SizeofBpfStat = C.sizeof_struct_bpf_stat
- SizeofBpfProgram = C.sizeof_struct_bpf_program
- SizeofBpfInsn = C.sizeof_struct_bpf_insn
- SizeofBpfHdr = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfTimeval C.struct_bpf_timeval
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Termio C.struct_termio
-
-type Winsize C.struct_winsize
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
- POLLERR = C.POLLERR
- POLLHUP = C.POLLHUP
- POLLIN = C.POLLIN
- POLLNVAL = C.POLLNVAL
- POLLOUT = C.POLLOUT
- POLLPRI = C.POLLPRI
- POLLRDBAND = C.POLLRDBAND
- POLLRDNORM = C.POLLRDNORM
- POLLWRBAND = C.POLLWRBAND
- POLLWRNORM = C.POLLWRNORM
-)
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen.go b/vendor/golang.org/x/text/unicode/bidi/gen.go
deleted file mode 100644
index 987fc16..0000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
- "flag"
- "log"
-
- "golang.org/x/text/internal/gen"
- "golang.org/x/text/internal/triegen"
- "golang.org/x/text/internal/ucd"
-)
-
-var outputFile = flag.String("out", "tables.go", "output file")
-
-func main() {
- gen.Init()
- gen.Repackage("gen_trieval.go", "trieval.go", "bidi")
- gen.Repackage("gen_ranges.go", "ranges_test.go", "bidi")
-
- genTables()
-}
-
-// bidiClass names and codes taken from class "bc" in
-// https://www.unicode.org/Public/8.0.0/ucd/PropertyValueAliases.txt
-var bidiClass = map[string]Class{
- "AL": AL, // ArabicLetter
- "AN": AN, // ArabicNumber
- "B": B, // ParagraphSeparator
- "BN": BN, // BoundaryNeutral
- "CS": CS, // CommonSeparator
- "EN": EN, // EuropeanNumber
- "ES": ES, // EuropeanSeparator
- "ET": ET, // EuropeanTerminator
- "L": L, // LeftToRight
- "NSM": NSM, // NonspacingMark
- "ON": ON, // OtherNeutral
- "R": R, // RightToLeft
- "S": S, // SegmentSeparator
- "WS": WS, // WhiteSpace
-
- "FSI": Control,
- "PDF": Control,
- "PDI": Control,
- "LRE": Control,
- "LRI": Control,
- "LRO": Control,
- "RLE": Control,
- "RLI": Control,
- "RLO": Control,
-}
-
-func genTables() {
- if numClass > 0x0F {
- log.Fatalf("Too many Class constants (%#x > 0x0F).", numClass)
- }
- w := gen.NewCodeWriter()
- defer w.WriteVersionedGoFile(*outputFile, "bidi")
-
- gen.WriteUnicodeVersion(w)
-
- t := triegen.NewTrie("bidi")
-
- // Build data about bracket mapping. These bits need to be or-ed with
- // any other bits.
- orMask := map[rune]uint64{}
-
- xorMap := map[rune]int{}
- xorMasks := []rune{0} // First value is no-op.
-
- ucd.Parse(gen.OpenUCDFile("BidiBrackets.txt"), func(p *ucd.Parser) {
- r1 := p.Rune(0)
- r2 := p.Rune(1)
- xor := r1 ^ r2
- if _, ok := xorMap[xor]; !ok {
- xorMap[xor] = len(xorMasks)
- xorMasks = append(xorMasks, xor)
- }
- entry := uint64(xorMap[xor]) << xorMaskShift
- switch p.String(2) {
- case "o":
- entry |= openMask
- case "c", "n":
- default:
- log.Fatalf("Unknown bracket class %q.", p.String(2))
- }
- orMask[r1] = entry
- })
-
- w.WriteComment(`
- xorMasks contains masks to be xor-ed with brackets to get the reverse
- version.`)
- w.WriteVar("xorMasks", xorMasks)
-
- done := map[rune]bool{}
-
- insert := func(r rune, c Class) {
- if !done[r] {
- t.Insert(r, orMask[r]|uint64(c))
- done[r] = true
- }
- }
-
- // Insert the derived BiDi properties.
- ucd.Parse(gen.OpenUCDFile("extracted/DerivedBidiClass.txt"), func(p *ucd.Parser) {
- r := p.Rune(0)
- class, ok := bidiClass[p.String(1)]
- if !ok {
- log.Fatalf("%U: Unknown BiDi class %q", r, p.String(1))
- }
- insert(r, class)
- })
- visitDefaults(insert)
-
- // TODO: use sparse blocks. This would reduce table size considerably
- // from the looks of it.
-
- sz, err := t.Gen(w)
- if err != nil {
- log.Fatal(err)
- }
- w.Size += sz
-}
-
-// dummy values to make methods in gen_common compile. The real versions
-// will be generated by this file to tables.go.
-var (
- xorMasks []rune
-)
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go b/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
deleted file mode 100644
index 02c3b50..0000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
- "unicode"
-
- "golang.org/x/text/internal/gen"
- "golang.org/x/text/internal/ucd"
- "golang.org/x/text/unicode/rangetable"
-)
-
-// These tables are hand-extracted from:
-// https://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedBidiClass.txt
-func visitDefaults(fn func(r rune, c Class)) {
- // first write default values for ranges listed above.
- visitRunes(fn, AL, []rune{
- 0x0600, 0x07BF, // Arabic
- 0x08A0, 0x08FF, // Arabic Extended-A
- 0xFB50, 0xFDCF, // Arabic Presentation Forms
- 0xFDF0, 0xFDFF,
- 0xFE70, 0xFEFF,
- 0x0001EE00, 0x0001EEFF, // Arabic Mathematical Alpha Symbols
- })
- visitRunes(fn, R, []rune{
- 0x0590, 0x05FF, // Hebrew
- 0x07C0, 0x089F, // Nko et al.
- 0xFB1D, 0xFB4F,
- 0x00010800, 0x00010FFF, // Cypriot Syllabary et. al.
- 0x0001E800, 0x0001EDFF,
- 0x0001EF00, 0x0001EFFF,
- })
- visitRunes(fn, ET, []rune{ // European Terminator
- 0x20A0, 0x20Cf, // Currency symbols
- })
- rangetable.Visit(unicode.Noncharacter_Code_Point, func(r rune) {
- fn(r, BN) // Boundary Neutral
- })
- ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
- if p.String(1) == "Default_Ignorable_Code_Point" {
- fn(p.Rune(0), BN) // Boundary Neutral
- }
- })
-}
-
-func visitRunes(fn func(r rune, c Class), c Class, runes []rune) {
- for i := 0; i < len(runes); i += 2 {
- lo, hi := runes[i], runes[i+1]
- for j := lo; j <= hi; j++ {
- fn(j, c)
- }
- }
-}
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go b/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
deleted file mode 100644
index 9cb9942..0000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-// Class is the Unicode BiDi class. Each rune has a single class.
-type Class uint
-
-const (
- L Class = iota // LeftToRight
- R // RightToLeft
- EN // EuropeanNumber
- ES // EuropeanSeparator
- ET // EuropeanTerminator
- AN // ArabicNumber
- CS // CommonSeparator
- B // ParagraphSeparator
- S // SegmentSeparator
- WS // WhiteSpace
- ON // OtherNeutral
- BN // BoundaryNeutral
- NSM // NonspacingMark
- AL // ArabicLetter
- Control // Control LRO - PDI
-
- numClass
-
- LRO // LeftToRightOverride
- RLO // RightToLeftOverride
- LRE // LeftToRightEmbedding
- RLE // RightToLeftEmbedding
- PDF // PopDirectionalFormat
- LRI // LeftToRightIsolate
- RLI // RightToLeftIsolate
- FSI // FirstStrongIsolate
- PDI // PopDirectionalIsolate
-
- unknownClass = ^Class(0)
-)
-
-var controlToClass = map[rune]Class{
- 0x202D: LRO, // LeftToRightOverride,
- 0x202E: RLO, // RightToLeftOverride,
- 0x202A: LRE, // LeftToRightEmbedding,
- 0x202B: RLE, // RightToLeftEmbedding,
- 0x202C: PDF, // PopDirectionalFormat,
- 0x2066: LRI, // LeftToRightIsolate,
- 0x2067: RLI, // RightToLeftIsolate,
- 0x2068: FSI, // FirstStrongIsolate,
- 0x2069: PDI, // PopDirectionalIsolate,
-}
-
-// A trie entry has the following bits:
-// 7..5 XOR mask for brackets
-// 4 1: Bracket open, 0: Bracket close
-// 3..0 Class type
-
-const (
- openMask = 0x10
- xorMaskShift = 5
-)
diff --git a/vendor/golang.org/x/text/unicode/norm/maketables.go b/vendor/golang.org/x/text/unicode/norm/maketables.go
deleted file mode 100644
index 30a3aa9..0000000
--- a/vendor/golang.org/x/text/unicode/norm/maketables.go
+++ /dev/null
@@ -1,986 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Normalization table generator.
-// Data read from the web.
-// See forminfo.go for a description of the trie values associated with each rune.
-
-package main
-
-import (
- "bytes"
- "encoding/binary"
- "flag"
- "fmt"
- "io"
- "log"
- "sort"
- "strconv"
- "strings"
-
- "golang.org/x/text/internal/gen"
- "golang.org/x/text/internal/triegen"
- "golang.org/x/text/internal/ucd"
-)
-
-func main() {
- gen.Init()
- loadUnicodeData()
- compactCCC()
- loadCompositionExclusions()
- completeCharFields(FCanonical)
- completeCharFields(FCompatibility)
- computeNonStarterCounts()
- verifyComputed()
- printChars()
- testDerived()
- printTestdata()
- makeTables()
-}
-
-var (
- tablelist = flag.String("tables",
- "all",
- "comma-separated list of which tables to generate; "+
- "can be 'decomp', 'recomp', 'info' and 'all'")
- test = flag.Bool("test",
- false,
- "test existing tables against DerivedNormalizationProps and generate test data for regression testing")
- verbose = flag.Bool("verbose",
- false,
- "write data to stdout as it is parsed")
-)
-
-const MaxChar = 0x10FFFF // anything above this shouldn't exist
-
-// Quick Check properties of runes allow us to quickly
-// determine whether a rune may occur in a normal form.
-// For a given normal form, a rune may be guaranteed to occur
-// verbatim (QC=Yes), may or may not combine with another
-// rune (QC=Maybe), or may not occur (QC=No).
-type QCResult int
-
-const (
- QCUnknown QCResult = iota
- QCYes
- QCNo
- QCMaybe
-)
-
-func (r QCResult) String() string {
- switch r {
- case QCYes:
- return "Yes"
- case QCNo:
- return "No"
- case QCMaybe:
- return "Maybe"
- }
- return "***UNKNOWN***"
-}
-
-const (
- FCanonical = iota // NFC or NFD
- FCompatibility // NFKC or NFKD
- FNumberOfFormTypes
-)
-
-const (
- MComposed = iota // NFC or NFKC
- MDecomposed // NFD or NFKD
- MNumberOfModes
-)
-
-// This contains only the properties we're interested in.
-type Char struct {
- name string
- codePoint rune // if zero, this index is not a valid code point.
- ccc uint8 // canonical combining class
- origCCC uint8
- excludeInComp bool // from CompositionExclusions.txt
- compatDecomp bool // it has a compatibility expansion
-
- nTrailingNonStarters uint8
- nLeadingNonStarters uint8 // must be equal to trailing if non-zero
-
- forms [FNumberOfFormTypes]FormInfo // For FCanonical and FCompatibility
-
- state State
-}
-
-var chars = make([]Char, MaxChar+1)
-var cccMap = make(map[uint8]uint8)
-
-func (c Char) String() string {
- buf := new(bytes.Buffer)
-
- fmt.Fprintf(buf, "%U [%s]:\n", c.codePoint, c.name)
- fmt.Fprintf(buf, " ccc: %v\n", c.ccc)
- fmt.Fprintf(buf, " excludeInComp: %v\n", c.excludeInComp)
- fmt.Fprintf(buf, " compatDecomp: %v\n", c.compatDecomp)
- fmt.Fprintf(buf, " state: %v\n", c.state)
- fmt.Fprintf(buf, " NFC:\n")
- fmt.Fprint(buf, c.forms[FCanonical])
- fmt.Fprintf(buf, " NFKC:\n")
- fmt.Fprint(buf, c.forms[FCompatibility])
-
- return buf.String()
-}
-
-// In UnicodeData.txt, some ranges are marked like this:
-// 3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
-// 4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
-// parseCharacter keeps a state variable indicating the weirdness.
-type State int
-
-const (
- SNormal State = iota // known to be zero for the type
- SFirst
- SLast
- SMissing
-)
-
-var lastChar = rune('\u0000')
-
-func (c Char) isValid() bool {
- return c.codePoint != 0 && c.state != SMissing
-}
-
-type FormInfo struct {
- quickCheck [MNumberOfModes]QCResult // index: MComposed or MDecomposed
- verified [MNumberOfModes]bool // index: MComposed or MDecomposed
-
- combinesForward bool // May combine with rune on the right
- combinesBackward bool // May combine with rune on the left
- isOneWay bool // Never appears in result
- inDecomp bool // Some decompositions result in this char.
- decomp Decomposition
- expandedDecomp Decomposition
-}
-
-func (f FormInfo) String() string {
- buf := bytes.NewBuffer(make([]byte, 0))
-
- fmt.Fprintf(buf, " quickCheck[C]: %v\n", f.quickCheck[MComposed])
- fmt.Fprintf(buf, " quickCheck[D]: %v\n", f.quickCheck[MDecomposed])
- fmt.Fprintf(buf, " cmbForward: %v\n", f.combinesForward)
- fmt.Fprintf(buf, " cmbBackward: %v\n", f.combinesBackward)
- fmt.Fprintf(buf, " isOneWay: %v\n", f.isOneWay)
- fmt.Fprintf(buf, " inDecomp: %v\n", f.inDecomp)
- fmt.Fprintf(buf, " decomposition: %X\n", f.decomp)
- fmt.Fprintf(buf, " expandedDecomp: %X\n", f.expandedDecomp)
-
- return buf.String()
-}
-
-type Decomposition []rune
-
-func parseDecomposition(s string, skipfirst bool) (a []rune, err error) {
- decomp := strings.Split(s, " ")
- if len(decomp) > 0 && skipfirst {
- decomp = decomp[1:]
- }
- for _, d := range decomp {
- point, err := strconv.ParseUint(d, 16, 64)
- if err != nil {
- return a, err
- }
- a = append(a, rune(point))
- }
- return a, nil
-}
-
-func loadUnicodeData() {
- f := gen.OpenUCDFile("UnicodeData.txt")
- defer f.Close()
- p := ucd.New(f)
- for p.Next() {
- r := p.Rune(ucd.CodePoint)
- char := &chars[r]
-
- char.ccc = uint8(p.Uint(ucd.CanonicalCombiningClass))
- decmap := p.String(ucd.DecompMapping)
-
- exp, err := parseDecomposition(decmap, false)
- isCompat := false
- if err != nil {
- if len(decmap) > 0 {
- exp, err = parseDecomposition(decmap, true)
- if err != nil {
- log.Fatalf(`%U: bad decomp |%v|: "%s"`, r, decmap, err)
- }
- isCompat = true
- }
- }
-
- char.name = p.String(ucd.Name)
- char.codePoint = r
- char.forms[FCompatibility].decomp = exp
- if !isCompat {
- char.forms[FCanonical].decomp = exp
- } else {
- char.compatDecomp = true
- }
- if len(decmap) > 0 {
- char.forms[FCompatibility].decomp = exp
- }
- }
- if err := p.Err(); err != nil {
- log.Fatal(err)
- }
-}
-
-// compactCCC converts the sparse set of CCC values to a continguous one,
-// reducing the number of bits needed from 8 to 6.
-func compactCCC() {
- m := make(map[uint8]uint8)
- for i := range chars {
- c := &chars[i]
- m[c.ccc] = 0
- }
- cccs := []int{}
- for v, _ := range m {
- cccs = append(cccs, int(v))
- }
- sort.Ints(cccs)
- for i, c := range cccs {
- cccMap[uint8(i)] = uint8(c)
- m[uint8(c)] = uint8(i)
- }
- for i := range chars {
- c := &chars[i]
- c.origCCC = c.ccc
- c.ccc = m[c.ccc]
- }
- if len(m) >= 1<<6 {
- log.Fatalf("too many difference CCC values: %d >= 64", len(m))
- }
-}
-
-// CompositionExclusions.txt has form:
-// 0958 # ...
-// See https://unicode.org/reports/tr44/ for full explanation
-func loadCompositionExclusions() {
- f := gen.OpenUCDFile("CompositionExclusions.txt")
- defer f.Close()
- p := ucd.New(f)
- for p.Next() {
- c := &chars[p.Rune(0)]
- if c.excludeInComp {
- log.Fatalf("%U: Duplicate entry in exclusions.", c.codePoint)
- }
- c.excludeInComp = true
- }
- if e := p.Err(); e != nil {
- log.Fatal(e)
- }
-}
-
-// hasCompatDecomp returns true if any of the recursive
-// decompositions contains a compatibility expansion.
-// In this case, the character may not occur in NFK*.
-func hasCompatDecomp(r rune) bool {
- c := &chars[r]
- if c.compatDecomp {
- return true
- }
- for _, d := range c.forms[FCompatibility].decomp {
- if hasCompatDecomp(d) {
- return true
- }
- }
- return false
-}
-
-// Hangul related constants.
-const (
- HangulBase = 0xAC00
- HangulEnd = 0xD7A4 // hangulBase + Jamo combinations (19 * 21 * 28)
-
- JamoLBase = 0x1100
- JamoLEnd = 0x1113
- JamoVBase = 0x1161
- JamoVEnd = 0x1176
- JamoTBase = 0x11A8
- JamoTEnd = 0x11C3
-
- JamoLVTCount = 19 * 21 * 28
- JamoTCount = 28
-)
-
-func isHangul(r rune) bool {
- return HangulBase <= r && r < HangulEnd
-}
-
-func isHangulWithoutJamoT(r rune) bool {
- if !isHangul(r) {
- return false
- }
- r -= HangulBase
- return r < JamoLVTCount && r%JamoTCount == 0
-}
-
-func ccc(r rune) uint8 {
- return chars[r].ccc
-}
-
-// Insert a rune in a buffer, ordered by Canonical Combining Class.
-func insertOrdered(b Decomposition, r rune) Decomposition {
- n := len(b)
- b = append(b, 0)
- cc := ccc(r)
- if cc > 0 {
- // Use bubble sort.
- for ; n > 0; n-- {
- if ccc(b[n-1]) <= cc {
- break
- }
- b[n] = b[n-1]
- }
- }
- b[n] = r
- return b
-}
-
-// Recursively decompose.
-func decomposeRecursive(form int, r rune, d Decomposition) Decomposition {
- dcomp := chars[r].forms[form].decomp
- if len(dcomp) == 0 {
- return insertOrdered(d, r)
- }
- for _, c := range dcomp {
- d = decomposeRecursive(form, c, d)
- }
- return d
-}
-
-func completeCharFields(form int) {
- // Phase 0: pre-expand decomposition.
- for i := range chars {
- f := &chars[i].forms[form]
- if len(f.decomp) == 0 {
- continue
- }
- exp := make(Decomposition, 0)
- for _, c := range f.decomp {
- exp = decomposeRecursive(form, c, exp)
- }
- f.expandedDecomp = exp
- }
-
- // Phase 1: composition exclusion, mark decomposition.
- for i := range chars {
- c := &chars[i]
- f := &c.forms[form]
-
- // Marks script-specific exclusions and version restricted.
- f.isOneWay = c.excludeInComp
-
- // Singletons
- f.isOneWay = f.isOneWay || len(f.decomp) == 1
-
- // Non-starter decompositions
- if len(f.decomp) > 1 {
- chk := c.ccc != 0 || chars[f.decomp[0]].ccc != 0
- f.isOneWay = f.isOneWay || chk
- }
-
- // Runes that decompose into more than two runes.
- f.isOneWay = f.isOneWay || len(f.decomp) > 2
-
- if form == FCompatibility {
- f.isOneWay = f.isOneWay || hasCompatDecomp(c.codePoint)
- }
-
- for _, r := range f.decomp {
- chars[r].forms[form].inDecomp = true
- }
- }
-
- // Phase 2: forward and backward combining.
- for i := range chars {
- c := &chars[i]
- f := &c.forms[form]
-
- if !f.isOneWay && len(f.decomp) == 2 {
- f0 := &chars[f.decomp[0]].forms[form]
- f1 := &chars[f.decomp[1]].forms[form]
- if !f0.isOneWay {
- f0.combinesForward = true
- }
- if !f1.isOneWay {
- f1.combinesBackward = true
- }
- }
- if isHangulWithoutJamoT(rune(i)) {
- f.combinesForward = true
- }
- }
-
- // Phase 3: quick check values.
- for i := range chars {
- c := &chars[i]
- f := &c.forms[form]
-
- switch {
- case len(f.decomp) > 0:
- f.quickCheck[MDecomposed] = QCNo
- case isHangul(rune(i)):
- f.quickCheck[MDecomposed] = QCNo
- default:
- f.quickCheck[MDecomposed] = QCYes
- }
- switch {
- case f.isOneWay:
- f.quickCheck[MComposed] = QCNo
- case (i & 0xffff00) == JamoLBase:
- f.quickCheck[MComposed] = QCYes
- if JamoLBase <= i && i < JamoLEnd {
- f.combinesForward = true
- }
- if JamoVBase <= i && i < JamoVEnd {
- f.quickCheck[MComposed] = QCMaybe
- f.combinesBackward = true
- f.combinesForward = true
- }
- if JamoTBase <= i && i < JamoTEnd {
- f.quickCheck[MComposed] = QCMaybe
- f.combinesBackward = true
- }
- case !f.combinesBackward:
- f.quickCheck[MComposed] = QCYes
- default:
- f.quickCheck[MComposed] = QCMaybe
- }
- }
-}
-
-func computeNonStarterCounts() {
- // Phase 4: leading and trailing non-starter count
- for i := range chars {
- c := &chars[i]
-
- runes := []rune{rune(i)}
- // We always use FCompatibility so that the CGJ insertion points do not
- // change for repeated normalizations with different forms.
- if exp := c.forms[FCompatibility].expandedDecomp; len(exp) > 0 {
- runes = exp
- }
- // We consider runes that combine backwards to be non-starters for the
- // purpose of Stream-Safe Text Processing.
- for _, r := range runes {
- if cr := &chars[r]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
- break
- }
- c.nLeadingNonStarters++
- }
- for i := len(runes) - 1; i >= 0; i-- {
- if cr := &chars[runes[i]]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
- break
- }
- c.nTrailingNonStarters++
- }
- if c.nTrailingNonStarters > 3 {
- log.Fatalf("%U: Decomposition with more than 3 (%d) trailing modifiers (%U)", i, c.nTrailingNonStarters, runes)
- }
-
- if isHangul(rune(i)) {
- c.nTrailingNonStarters = 2
- if isHangulWithoutJamoT(rune(i)) {
- c.nTrailingNonStarters = 1
- }
- }
-
- if l, t := c.nLeadingNonStarters, c.nTrailingNonStarters; l > 0 && l != t {
- log.Fatalf("%U: number of leading and trailing non-starters should be equal (%d vs %d)", i, l, t)
- }
- if t := c.nTrailingNonStarters; t > 3 {
- log.Fatalf("%U: number of trailing non-starters is %d > 3", t)
- }
- }
-}
-
-func printBytes(w io.Writer, b []byte, name string) {
- fmt.Fprintf(w, "// %s: %d bytes\n", name, len(b))
- fmt.Fprintf(w, "var %s = [...]byte {", name)
- for i, c := range b {
- switch {
- case i%64 == 0:
- fmt.Fprintf(w, "\n// Bytes %x - %x\n", i, i+63)
- case i%8 == 0:
- fmt.Fprintf(w, "\n")
- }
- fmt.Fprintf(w, "0x%.2X, ", c)
- }
- fmt.Fprint(w, "\n}\n\n")
-}
-
-// See forminfo.go for format.
-func makeEntry(f *FormInfo, c *Char) uint16 {
- e := uint16(0)
- if r := c.codePoint; HangulBase <= r && r < HangulEnd {
- e |= 0x40
- }
- if f.combinesForward {
- e |= 0x20
- }
- if f.quickCheck[MDecomposed] == QCNo {
- e |= 0x4
- }
- switch f.quickCheck[MComposed] {
- case QCYes:
- case QCNo:
- e |= 0x10
- case QCMaybe:
- e |= 0x18
- default:
- log.Fatalf("Illegal quickcheck value %v.", f.quickCheck[MComposed])
- }
- e |= uint16(c.nTrailingNonStarters)
- return e
-}
-
-// decompSet keeps track of unique decompositions, grouped by whether
-// the decomposition is followed by a trailing and/or leading CCC.
-type decompSet [7]map[string]bool
-
-const (
- normalDecomp = iota
- firstMulti
- firstCCC
- endMulti
- firstLeadingCCC
- firstCCCZeroExcept
- firstStarterWithNLead
- lastDecomp
-)
-
-var cname = []string{"firstMulti", "firstCCC", "endMulti", "firstLeadingCCC", "firstCCCZeroExcept", "firstStarterWithNLead", "lastDecomp"}
-
-func makeDecompSet() decompSet {
- m := decompSet{}
- for i := range m {
- m[i] = make(map[string]bool)
- }
- return m
-}
-func (m *decompSet) insert(key int, s string) {
- m[key][s] = true
-}
-
-func printCharInfoTables(w io.Writer) int {
- mkstr := func(r rune, f *FormInfo) (int, string) {
- d := f.expandedDecomp
- s := string([]rune(d))
- if max := 1 << 6; len(s) >= max {
- const msg = "%U: too many bytes in decomposition: %d >= %d"
- log.Fatalf(msg, r, len(s), max)
- }
- head := uint8(len(s))
- if f.quickCheck[MComposed] != QCYes {
- head |= 0x40
- }
- if f.combinesForward {
- head |= 0x80
- }
- s = string([]byte{head}) + s
-
- lccc := ccc(d[0])
- tccc := ccc(d[len(d)-1])
- cc := ccc(r)
- if cc != 0 && lccc == 0 && tccc == 0 {
- log.Fatalf("%U: trailing and leading ccc are 0 for non-zero ccc %d", r, cc)
- }
- if tccc < lccc && lccc != 0 {
- const msg = "%U: lccc (%d) must be <= tcc (%d)"
- log.Fatalf(msg, r, lccc, tccc)
- }
- index := normalDecomp
- nTrail := chars[r].nTrailingNonStarters
- nLead := chars[r].nLeadingNonStarters
- if tccc > 0 || lccc > 0 || nTrail > 0 {
- tccc <<= 2
- tccc |= nTrail
- s += string([]byte{tccc})
- index = endMulti
- for _, r := range d[1:] {
- if ccc(r) == 0 {
- index = firstCCC
- }
- }
- if lccc > 0 || nLead > 0 {
- s += string([]byte{lccc})
- if index == firstCCC {
- log.Fatalf("%U: multi-segment decomposition not supported for decompositions with leading CCC != 0", r)
- }
- index = firstLeadingCCC
- }
- if cc != lccc {
- if cc != 0 {
- log.Fatalf("%U: for lccc != ccc, expected ccc to be 0; was %d", r, cc)
- }
- index = firstCCCZeroExcept
- }
- } else if len(d) > 1 {
- index = firstMulti
- }
- return index, s
- }
-
- decompSet := makeDecompSet()
- const nLeadStr = "\x00\x01" // 0-byte length and tccc with nTrail.
- decompSet.insert(firstStarterWithNLead, nLeadStr)
-
- // Store the uniqued decompositions in a byte buffer,
- // preceded by their byte length.
- for _, c := range chars {
- for _, f := range c.forms {
- if len(f.expandedDecomp) == 0 {
- continue
- }
- if f.combinesBackward {
- log.Fatalf("%U: combinesBackward and decompose", c.codePoint)
- }
- index, s := mkstr(c.codePoint, &f)
- decompSet.insert(index, s)
- }
- }
-
- decompositions := bytes.NewBuffer(make([]byte, 0, 10000))
- size := 0
- positionMap := make(map[string]uint16)
- decompositions.WriteString("\000")
- fmt.Fprintln(w, "const (")
- for i, m := range decompSet {
- sa := []string{}
- for s := range m {
- sa = append(sa, s)
- }
- sort.Strings(sa)
- for _, s := range sa {
- p := decompositions.Len()
- decompositions.WriteString(s)
- positionMap[s] = uint16(p)
- }
- if cname[i] != "" {
- fmt.Fprintf(w, "%s = 0x%X\n", cname[i], decompositions.Len())
- }
- }
- fmt.Fprintln(w, "maxDecomp = 0x8000")
- fmt.Fprintln(w, ")")
- b := decompositions.Bytes()
- printBytes(w, b, "decomps")
- size += len(b)
-
- varnames := []string{"nfc", "nfkc"}
- for i := 0; i < FNumberOfFormTypes; i++ {
- trie := triegen.NewTrie(varnames[i])
-
- for r, c := range chars {
- f := c.forms[i]
- d := f.expandedDecomp
- if len(d) != 0 {
- _, key := mkstr(c.codePoint, &f)
- trie.Insert(rune(r), uint64(positionMap[key]))
- if c.ccc != ccc(d[0]) {
- // We assume the lead ccc of a decomposition !=0 in this case.
- if ccc(d[0]) == 0 {
- log.Fatalf("Expected leading CCC to be non-zero; ccc is %d", c.ccc)
- }
- }
- } else if c.nLeadingNonStarters > 0 && len(f.expandedDecomp) == 0 && c.ccc == 0 && !f.combinesBackward {
- // Handle cases where it can't be detected that the nLead should be equal
- // to nTrail.
- trie.Insert(c.codePoint, uint64(positionMap[nLeadStr]))
- } else if v := makeEntry(&f, &c)<<8 | uint16(c.ccc); v != 0 {
- trie.Insert(c.codePoint, uint64(0x8000|v))
- }
- }
- sz, err := trie.Gen(w, triegen.Compact(&normCompacter{name: varnames[i]}))
- if err != nil {
- log.Fatal(err)
- }
- size += sz
- }
- return size
-}
-
-func contains(sa []string, s string) bool {
- for _, a := range sa {
- if a == s {
- return true
- }
- }
- return false
-}
-
-func makeTables() {
- w := &bytes.Buffer{}
-
- size := 0
- if *tablelist == "" {
- return
- }
- list := strings.Split(*tablelist, ",")
- if *tablelist == "all" {
- list = []string{"recomp", "info"}
- }
-
- // Compute maximum decomposition size.
- max := 0
- for _, c := range chars {
- if n := len(string(c.forms[FCompatibility].expandedDecomp)); n > max {
- max = n
- }
- }
- fmt.Fprintln(w, `import "sync"`)
- fmt.Fprintln(w)
-
- fmt.Fprintln(w, "const (")
- fmt.Fprintln(w, "\t// Version is the Unicode edition from which the tables are derived.")
- fmt.Fprintf(w, "\tVersion = %q\n", gen.UnicodeVersion())
- fmt.Fprintln(w)
- fmt.Fprintln(w, "\t// MaxTransformChunkSize indicates the maximum number of bytes that Transform")
- fmt.Fprintln(w, "\t// may need to write atomically for any Form. Making a destination buffer at")
- fmt.Fprintln(w, "\t// least this size ensures that Transform can always make progress and that")
- fmt.Fprintln(w, "\t// the user does not need to grow the buffer on an ErrShortDst.")
- fmt.Fprintf(w, "\tMaxTransformChunkSize = %d+maxNonStarters*4\n", len(string(0x034F))+max)
- fmt.Fprintln(w, ")\n")
-
- // Print the CCC remap table.
- size += len(cccMap)
- fmt.Fprintf(w, "var ccc = [%d]uint8{", len(cccMap))
- for i := 0; i < len(cccMap); i++ {
- if i%8 == 0 {
- fmt.Fprintln(w)
- }
- fmt.Fprintf(w, "%3d, ", cccMap[uint8(i)])
- }
- fmt.Fprintln(w, "\n}\n")
-
- if contains(list, "info") {
- size += printCharInfoTables(w)
- }
-
- if contains(list, "recomp") {
- // Note that we use 32 bit keys, instead of 64 bit.
- // This clips the bits of three entries, but we know
- // this won't cause a collision. The compiler will catch
- // any changes made to UnicodeData.txt that introduces
- // a collision.
- // Note that the recomposition map for NFC and NFKC
- // are identical.
-
- // Recomposition map
- nrentries := 0
- for _, c := range chars {
- f := c.forms[FCanonical]
- if !f.isOneWay && len(f.decomp) > 0 {
- nrentries++
- }
- }
- sz := nrentries * 8
- size += sz
- fmt.Fprintf(w, "// recompMap: %d bytes (entries only)\n", sz)
- fmt.Fprintln(w, "var recompMap map[uint32]rune")
- fmt.Fprintln(w, "var recompMapOnce sync.Once\n")
- fmt.Fprintln(w, `const recompMapPacked = "" +`)
- var buf [8]byte
- for i, c := range chars {
- f := c.forms[FCanonical]
- d := f.decomp
- if !f.isOneWay && len(d) > 0 {
- key := uint32(uint16(d[0]))<<16 + uint32(uint16(d[1]))
- binary.BigEndian.PutUint32(buf[:4], key)
- binary.BigEndian.PutUint32(buf[4:], uint32(i))
- fmt.Fprintf(w, "\t\t%q + // 0x%.8X: 0x%.8X\n", string(buf[:]), key, uint32(i))
- }
- }
- // hack so we don't have to special case the trailing plus sign
- fmt.Fprintf(w, ` ""`)
- fmt.Fprintln(w)
- }
-
- fmt.Fprintf(w, "// Total size of tables: %dKB (%d bytes)\n", (size+512)/1024, size)
- gen.WriteVersionedGoFile("tables.go", "norm", w.Bytes())
-}
-
-func printChars() {
- if *verbose {
- for _, c := range chars {
- if !c.isValid() || c.state == SMissing {
- continue
- }
- fmt.Println(c)
- }
- }
-}
-
-// verifyComputed does various consistency tests.
-func verifyComputed() {
- for i, c := range chars {
- for _, f := range c.forms {
- isNo := (f.quickCheck[MDecomposed] == QCNo)
- if (len(f.decomp) > 0) != isNo && !isHangul(rune(i)) {
- log.Fatalf("%U: NF*D QC must be No if rune decomposes", i)
- }
-
- isMaybe := f.quickCheck[MComposed] == QCMaybe
- if f.combinesBackward != isMaybe {
- log.Fatalf("%U: NF*C QC must be Maybe if combinesBackward", i)
- }
- if len(f.decomp) > 0 && f.combinesForward && isMaybe {
- log.Fatalf("%U: NF*C QC must be Yes or No if combinesForward and decomposes", i)
- }
-
- if len(f.expandedDecomp) != 0 {
- continue
- }
- if a, b := c.nLeadingNonStarters > 0, (c.ccc > 0 || f.combinesBackward); a != b {
- // We accept these runes to be treated differently (it only affects
- // segment breaking in iteration, most likely on improper use), but
- // reconsider if more characters are added.
- // U+FF9E HALFWIDTH KATAKANA VOICED SOUND MARK;Lm;0;L;<narrow> 3099;;;;N;;;;;
- // U+FF9F HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK;Lm;0;L;<narrow> 309A;;;;N;;;;;
- // U+3133 HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<compat> 11AA;;;;N;HANGUL LETTER GIYEOG SIOS;;;;
- // U+318E HANGUL LETTER ARAEAE;Lo;0;L;<compat> 11A1;;;;N;HANGUL LETTER ALAE AE;;;;
- // U+FFA3 HALFWIDTH HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<narrow> 3133;;;;N;HALFWIDTH HANGUL LETTER GIYEOG SIOS;;;;
- // U+FFDC HALFWIDTH HANGUL LETTER I;Lo;0;L;<narrow> 3163;;;;N;;;;;
- if i != 0xFF9E && i != 0xFF9F && !(0x3133 <= i && i <= 0x318E) && !(0xFFA3 <= i && i <= 0xFFDC) {
- log.Fatalf("%U: nLead was %v; want %v", i, a, b)
- }
- }
- }
- nfc := c.forms[FCanonical]
- nfkc := c.forms[FCompatibility]
- if nfc.combinesBackward != nfkc.combinesBackward {
- log.Fatalf("%U: Cannot combine combinesBackward\n", c.codePoint)
- }
- }
-}
-
-// Use values in DerivedNormalizationProps.txt to compare against the
-// values we computed.
-// DerivedNormalizationProps.txt has form:
-// 00C0..00C5 ; NFD_QC; N # ...
-// 0374 ; NFD_QC; N # ...
-// See https://unicode.org/reports/tr44/ for full explanation
-func testDerived() {
- f := gen.OpenUCDFile("DerivedNormalizationProps.txt")
- defer f.Close()
- p := ucd.New(f)
- for p.Next() {
- r := p.Rune(0)
- c := &chars[r]
-
- var ftype, mode int
- qt := p.String(1)
- switch qt {
- case "NFC_QC":
- ftype, mode = FCanonical, MComposed
- case "NFD_QC":
- ftype, mode = FCanonical, MDecomposed
- case "NFKC_QC":
- ftype, mode = FCompatibility, MComposed
- case "NFKD_QC":
- ftype, mode = FCompatibility, MDecomposed
- default:
- continue
- }
- var qr QCResult
- switch p.String(2) {
- case "Y":
- qr = QCYes
- case "N":
- qr = QCNo
- case "M":
- qr = QCMaybe
- default:
- log.Fatalf(`Unexpected quick check value "%s"`, p.String(2))
- }
- if got := c.forms[ftype].quickCheck[mode]; got != qr {
- log.Printf("%U: FAILED %s (was %v need %v)\n", r, qt, got, qr)
- }
- c.forms[ftype].verified[mode] = true
- }
- if err := p.Err(); err != nil {
- log.Fatal(err)
- }
- // Any unspecified value must be QCYes. Verify this.
- for i, c := range chars {
- for j, fd := range c.forms {
- for k, qr := range fd.quickCheck {
- if !fd.verified[k] && qr != QCYes {
- m := "%U: FAIL F:%d M:%d (was %v need Yes) %s\n"
- log.Printf(m, i, j, k, qr, c.name)
- }
- }
- }
- }
-}
-
-var testHeader = `const (
- Yes = iota
- No
- Maybe
-)
-
-type formData struct {
- qc uint8
- combinesForward bool
- decomposition string
-}
-
-type runeData struct {
- r rune
- ccc uint8
- nLead uint8
- nTrail uint8
- f [2]formData // 0: canonical; 1: compatibility
-}
-
-func f(qc uint8, cf bool, dec string) [2]formData {
- return [2]formData{{qc, cf, dec}, {qc, cf, dec}}
-}
-
-func g(qc, qck uint8, cf, cfk bool, d, dk string) [2]formData {
- return [2]formData{{qc, cf, d}, {qck, cfk, dk}}
-}
-
-var testData = []runeData{
-`
-
-func printTestdata() {
- type lastInfo struct {
- ccc uint8
- nLead uint8
- nTrail uint8
- f string
- }
-
- last := lastInfo{}
- w := &bytes.Buffer{}
- fmt.Fprintf(w, testHeader)
- for r, c := range chars {
- f := c.forms[FCanonical]
- qc, cf, d := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
- f = c.forms[FCompatibility]
- qck, cfk, dk := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
- s := ""
- if d == dk && qc == qck && cf == cfk {
- s = fmt.Sprintf("f(%s, %v, %q)", qc, cf, d)
- } else {
- s = fmt.Sprintf("g(%s, %s, %v, %v, %q, %q)", qc, qck, cf, cfk, d, dk)
- }
- current := lastInfo{c.ccc, c.nLeadingNonStarters, c.nTrailingNonStarters, s}
- if last != current {
- fmt.Fprintf(w, "\t{0x%x, %d, %d, %d, %s},\n", r, c.origCCC, c.nLeadingNonStarters, c.nTrailingNonStarters, s)
- last = current
- }
- }
- fmt.Fprintln(w, "}")
- gen.WriteVersionedGoFile("data_test.go", "norm", w.Bytes())
-}
diff --git a/vendor/golang.org/x/text/unicode/norm/triegen.go b/vendor/golang.org/x/text/unicode/norm/triegen.go
deleted file mode 100644
index 45d7119..0000000
--- a/vendor/golang.org/x/text/unicode/norm/triegen.go
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Trie table generator.
-// Used by make*tables tools to generate a go file with trie data structures
-// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
-// sequence are used to lookup offsets in the index table to be used for the
-// next byte. The last byte is used to index into a table with 16-bit values.
-
-package main
-
-import (
- "fmt"
- "io"
-)
-
-const maxSparseEntries = 16
-
-type normCompacter struct {
- sparseBlocks [][]uint64
- sparseOffset []uint16
- sparseCount int
- name string
-}
-
-func mostFrequentStride(a []uint64) int {
- counts := make(map[int]int)
- var v int
- for _, x := range a {
- if stride := int(x) - v; v != 0 && stride >= 0 {
- counts[stride]++
- }
- v = int(x)
- }
- var maxs, maxc int
- for stride, cnt := range counts {
- if cnt > maxc || (cnt == maxc && stride < maxs) {
- maxs, maxc = stride, cnt
- }
- }
- return maxs
-}
-
-func countSparseEntries(a []uint64) int {
- stride := mostFrequentStride(a)
- var v, count int
- for _, tv := range a {
- if int(tv)-v != stride {
- if tv != 0 {
- count++
- }
- }
- v = int(tv)
- }
- return count
-}
-
-func (c *normCompacter) Size(v []uint64) (sz int, ok bool) {
- if n := countSparseEntries(v); n <= maxSparseEntries {
- return (n+1)*4 + 2, true
- }
- return 0, false
-}
-
-func (c *normCompacter) Store(v []uint64) uint32 {
- h := uint32(len(c.sparseOffset))
- c.sparseBlocks = append(c.sparseBlocks, v)
- c.sparseOffset = append(c.sparseOffset, uint16(c.sparseCount))
- c.sparseCount += countSparseEntries(v) + 1
- return h
-}
-
-func (c *normCompacter) Handler() string {
- return c.name + "Sparse.lookup"
-}
-
-func (c *normCompacter) Print(w io.Writer) (retErr error) {
- p := func(f string, x ...interface{}) {
- if _, err := fmt.Fprintf(w, f, x...); retErr == nil && err != nil {
- retErr = err
- }
- }
-
- ls := len(c.sparseBlocks)
- p("// %sSparseOffset: %d entries, %d bytes\n", c.name, ls, ls*2)
- p("var %sSparseOffset = %#v\n\n", c.name, c.sparseOffset)
-
- ns := c.sparseCount
- p("// %sSparseValues: %d entries, %d bytes\n", c.name, ns, ns*4)
- p("var %sSparseValues = [%d]valueRange {", c.name, ns)
- for i, b := range c.sparseBlocks {
- p("\n// Block %#x, offset %#x", i, c.sparseOffset[i])
- var v int
- stride := mostFrequentStride(b)
- n := countSparseEntries(b)
- p("\n{value:%#04x,lo:%#02x},", stride, uint8(n))
- for i, nv := range b {
- if int(nv)-v != stride {
- if v != 0 {
- p(",hi:%#02x},", 0x80+i-1)
- }
- if nv != 0 {
- p("\n{value:%#04x,lo:%#02x", nv, 0x80+i)
- }
- }
- v = int(nv)
- }
- if v != 0 {
- p(",hi:%#02x},", 0x80+len(b)-1)
- }
- }
- p("\n}\n\n")
- return
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a1f00f1..be672b9 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -2,46 +2,48 @@
github.com/donNewtonAlpha/goloxi
github.com/donNewtonAlpha/goloxi/of13
# github.com/golang/protobuf v1.3.2
-github.com/golang/protobuf/ptypes/empty
github.com/golang/protobuf/proto
-github.com/golang/protobuf/ptypes/any
github.com/golang/protobuf/protoc-gen-go/descriptor
github.com/golang/protobuf/ptypes
+github.com/golang/protobuf/ptypes/any
github.com/golang/protobuf/ptypes/duration
+github.com/golang/protobuf/ptypes/empty
github.com/golang/protobuf/ptypes/timestamp
# github.com/opencord/voltha-lib-go/v2 v2.2.23
github.com/opencord/voltha-lib-go/v2/pkg/log
+github.com/opencord/voltha-lib-go/v2/pkg/probe
+github.com/opencord/voltha-lib-go/v2/pkg/version
# github.com/opencord/voltha-protos/v2 v2.1.0
-github.com/opencord/voltha-protos/v2/go/openflow_13
-github.com/opencord/voltha-protos/v2/go/voltha
github.com/opencord/voltha-protos/v2/go/common
github.com/opencord/voltha-protos/v2/go/omci
+github.com/opencord/voltha-protos/v2/go/openflow_13
+github.com/opencord/voltha-protos/v2/go/voltha
# go.uber.org/atomic v1.4.0
go.uber.org/atomic
# go.uber.org/multierr v1.2.0
go.uber.org/multierr
# go.uber.org/zap v1.10.0
go.uber.org/zap
-go.uber.org/zap/zapcore
-go.uber.org/zap/internal/bufferpool
go.uber.org/zap/buffer
+go.uber.org/zap/internal/bufferpool
go.uber.org/zap/internal/color
go.uber.org/zap/internal/exit
+go.uber.org/zap/zapcore
# golang.org/x/net v0.0.0-20191112182307-2180aed22343
golang.org/x/net/context
-golang.org/x/net/trace
-golang.org/x/net/internal/timeseries
+golang.org/x/net/http/httpguts
golang.org/x/net/http2
golang.org/x/net/http2/hpack
-golang.org/x/net/http/httpguts
golang.org/x/net/idna
+golang.org/x/net/internal/timeseries
+golang.org/x/net/trace
# golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24
golang.org/x/sys/unix
# golang.org/x/text v0.3.2
golang.org/x/text/secure/bidirule
+golang.org/x/text/transform
golang.org/x/text/unicode/bidi
golang.org/x/text/unicode/norm
-golang.org/x/text/transform
# google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c
google.golang.org/genproto/googleapis/api/annotations
google.golang.org/genproto/googleapis/rpc/status
@@ -51,9 +53,11 @@
google.golang.org/grpc/balancer
google.golang.org/grpc/balancer/base
google.golang.org/grpc/balancer/roundrobin
+google.golang.org/grpc/binarylog/grpc_binarylog_v1
google.golang.org/grpc/codes
google.golang.org/grpc/connectivity
google.golang.org/grpc/credentials
+google.golang.org/grpc/credentials/internal
google.golang.org/grpc/encoding
google.golang.org/grpc/encoding/proto
google.golang.org/grpc/grpclog
@@ -68,6 +72,7 @@
google.golang.org/grpc/internal/grpcsync
google.golang.org/grpc/internal/resolver/dns
google.golang.org/grpc/internal/resolver/passthrough
+google.golang.org/grpc/internal/syscall
google.golang.org/grpc/internal/transport
google.golang.org/grpc/keepalive
google.golang.org/grpc/metadata
@@ -78,6 +83,3 @@
google.golang.org/grpc/stats
google.golang.org/grpc/status
google.golang.org/grpc/tap
-google.golang.org/grpc/credentials/internal
-google.golang.org/grpc/binarylog/grpc_binarylog_v1
-google.golang.org/grpc/internal/syscall