-## GoVPP
-
-This set of packages provide the API for communication with VPP from Go. It consists of the following packages:
-
-- [govpp](govpp.go): provides the entry point to govpp functionality
-- [api](api/api.go): API for communication with govpp core using Go channels (without the need of importing the govpp core package itself),
-- [core](core/): main functionality of the govpp, sends and receives the messages to/from VPP using the adapter, marshalls/unmarshalls them and forwards them between the client Go channels and the VPP,
-- [adapter](adapter/): adapter between govpp core and the VPP, responsible for sending and receiving binary-encoded data via shared memory,
-- [binapi-generator](cmd/binapi-generator/generator.go): Generator of Go structs out of the VPP binary API definitions in JSON format,
-- [examples](examples/): example VPP management application that exercises the govpp API on real-world use-cases.
-
-The design with separated govpp API package ([api](api/api.go)) and the govpp core package ([core](core/)) enables
-plugin-based infrastructure, where one entity acts as a master responsible for talking with VPP (e.g. Agent
-Core on the schema below) and multiple entities act as clients that are using the master for the communication with
-VPP (Agent Plugins on the schema below). The clients can be built into standalone shared libraries without the need
-of linking the govpp core and all its dependencies into them.
+# GoVPP
+
+This set of packages provide the API for communication with VPP from Go.
+
+It consists of the following packages:
+- [adapter](adapter/): adapter between GoVPP core and the VPP
+- [api](api/api.go): API for communication with GoVPP core
+- [binapi-generator](cmd/binapi-generator/): Generator for the VPP binary API definitions in JSON format to Go code
+- [codec](codec/): handles encoding/decoding of generated messages into binary form
+- [core](core/): main functionality of the GoVPP
+- [examples](examples/): examples that use the GoVPP API in real use-cases of VPP management application
+- [extras](extras/): contains Go implementation for libmemif library
+- [govpp](govpp.go): provides the entry point to GoVPP functionality
+
+The design with separated GoVPP [API package](api/api.go) and the GoVPP [core package](core/) enables
+plugin-based infrastructure, where one entity acts as a master responsible for talking with VPP and multiple
+entities act as clients that are using the master for the communication with VPP.
+The clients can be built into standalone shared libraries without the need
+of linking the GoVPP core and all its dependencies into them.
```
+--------------+
+--------------+ | |
- | | | Agent Plugin |
+ | | | App plugin |
| | | |
- | Agent Core | +--------------+
- | | +------+ govpp API |
+ | App | +--------------+
+ | | +------+ GoVPP API |
| | | +--------------+
+--------------+ Go |
| | channels | +--------------+
- | govpp core +------------+ | |
- | | | | Agent Plugin |
+ | GoVPP core +------------+ | |
+ | | | | App plugin |
+------+-------+ | | |
| | +--------------+
-binary API | +------+ govpp API |
- (shmem) | +--------------+
+binary API | +------+ GoVPP API |
+ (shmem) | +--------------+
|
+------+-------+
| |
- | VPP |
+ | VPP process |
| |
+--------------+
```
+## Quick Start
+
+#### Code Generator
-## Example usage
Generating Go bindings from the JSON files located in the `/usr/share/vpp/api/` directory
into the Go packages that will be created inside of the `bin_api` directory:
```
binapi-generator --input-dir=/usr/share/vpp/api/ --output-dir=bin_api
```
+#### Example Usage
+
Usage of the generated bindings:
+
```go
func main() {
conn, _ := govpp.Connect()
The example above uses simple wrapper API over underlying go channels, see [example client](examples/cmd/simple-client/simple_client.go)
for more examples, including the example on how to use the Go channels directly.
-
## Build & Installation Procedure
-Govpp uses `vppapiclient` library from VPP codebase to communicate with VPP. To build govpp, vpp-dev package must be installed,
+
+Govpp uses `vppapiclient` library from VPP codebase to communicate with VPP. To build GoVPP, vpp-dev package must be installed,
either [from packages](https://wiki.fd.io/view/VPP/Installing_VPP_binaries_from_packages) or
[from sources](https://wiki.fd.io/view/VPP/Build,_install,_and_test_images#Build_A_VPP_Package).
To build & install `vpp-dev` from sources:
+
```
git clone https://gerrit.fd.io/r/vpp
cd vpp
sudo dpkg -i vpp*.deb
```
-To build & install all govpp binaries into your `$GOPATH`:
+To build & install all GoVPP binaries into your `$GOPATH`:
+
```
go get git.fd.io/govpp.git
cd $GOPATH/src/git.fd.io/govpp.git
make install
```
-
## Building Go bindings from VPP binary APIs
+
Once you have `binapi-generator` installed in your `$GOPATH`, you can use it to generate Go bindings from
VPP APis in JSON format. The JSON input can be specified as a single file (`input-file` argument), or
as a directory that will be scanned for all `.json` files (`input-dir`). The generated Go bindings will
process. It allows to specify generator instructions in any one of the regular (non-generated) `.go` files
that are dependent on generated code using special comments, e.g. the one from
[example client](examples/cmd/simple-client/simple_client.go):
-```go
-// go:generate binapi-generator --input-dir=bin_api --output-dir=bin_api
-```
-
-The comment must start at the beginning of the line and have no spaces between the `//` and the `go:generate`.
-After that marker, the rest of the line specifies a command for `go generate` to run.
-The `go generate` tool automatically traverses the code base, looks for the special comments in Go code and
-invokes the code generation, e.g.:
-```
-go generate ./...
+```go
+//go:generate binapi-generator --input-dir=bin_api --output-dir=bin_api
```
-Invokes all `go:generate` rules in all Go packages recursively.
package adapter
+import (
+ "errors"
+)
+
+// ErrNotImplemented is an error returned when missing implementation.
+var ErrNotImplemented = errors.New("not implemented for this OS")
+
+// MsgCallback defines func signature for message callback.
+type MsgCallback func(msgID uint16, context uint32, data []byte)
+
// VppAdapter provides connection to VPP. It is responsible for sending and receiving of binary-encoded messages to/from VPP.
type VppAdapter interface {
// Connect connects the process to VPP.
SendMsg(context uint32, data []byte) error
// SetMsgCallback sets a callback function that will be called by the adapter whenever a message comes from VPP.
- SetMsgCallback(func(context uint32, msgId uint16, data []byte))
+ SetMsgCallback(cb MsgCallback)
// WaitReady waits until adapter is ready.
WaitReady() error
"git.fd.io/govpp.git/adapter"
"git.fd.io/govpp.git/adapter/mock/binapi"
"git.fd.io/govpp.git/api"
-
"git.fd.io/govpp.git/codec"
"github.com/lunixbochs/struc"
)
type replyMode int
const (
- _ replyMode = 0
- useRepliesQueue = 1 // use replies in the queue
- useReplyHandlers = 2 // use reply handler
+ _ replyMode = iota
+ useRepliesQueue // use replies in the queue
+ useReplyHandlers // use reply handler
)
// VppAdapter represents a mock VPP adapter that can be used for unit/integration testing instead of the vppapiclient adapter.
type VppAdapter struct {
- callback func(context uint32, msgId uint16, data []byte)
+ callback adapter.MsgCallback
+ msgIDSeq uint16
+ access sync.RWMutex
msgNameToIds map[string]uint16
msgIDsToName map[uint16]string
- msgIDSeq uint16
binAPITypes map[string]reflect.Type
- access sync.RWMutex
+ repliesLock sync.Mutex // mutex for the queue
replies []reply // FIFO queue of messages
replyHandlers []ReplyHandler // callbacks that are able to calculate mock responses
- repliesLock sync.Mutex // mutex for the queue
mode replyMode // mode in which the mock operates
}
a.msgNameToIds[msgName] = msgID
a.msgIDsToName[msgID] = msgName
- log.Println("VPP GetMessageId ", msgID, " name:", msgName, " crc:", msgCrc)
-
return msgID, nil
}
Data: data,
})
if finished {
- a.callback(clientID, msgID, reply)
+ a.callback(msgID, clientID, reply)
return nil
}
}
fallthrough
+
case useRepliesQueue:
a.repliesLock.Lock()
defer a.repliesLock.Unlock()
}
if msg.Msg.GetMessageType() == api.ReplyMessage {
struc.Pack(buf, &codec.VppReplyHeader{VlMsgID: msgID, Context: context})
- } else if msg.Msg.GetMessageType() == api.EventMessage {
- struc.Pack(buf, &codec.VppEventHeader{VlMsgID: msgID, Context: context})
} else if msg.Msg.GetMessageType() == api.RequestMessage {
struc.Pack(buf, &codec.VppRequestHeader{VlMsgID: msgID, Context: context})
+ } else if msg.Msg.GetMessageType() == api.EventMessage {
+ struc.Pack(buf, &codec.VppEventHeader{VlMsgID: msgID})
} else {
struc.Pack(buf, &codec.VppOtherHeader{VlMsgID: msgID})
}
struc.Pack(buf, msg.Msg)
- a.callback(context, msgID, buf.Bytes())
+ a.callback(msgID, context, buf.Bytes())
}
a.replies = a.replies[1:]
msgID := uint16(defaultReplyMsgID)
struc.Pack(buf, &codec.VppReplyHeader{VlMsgID: msgID, Context: clientID})
struc.Pack(buf, &defaultReply{})
- a.callback(clientID, msgID, buf.Bytes())
+ a.callback(msgID, clientID, buf.Bytes())
}
return nil
}
// SetMsgCallback sets a callback function that will be called by the adapter whenever a message comes from the mock.
-func (a *VppAdapter) SetMsgCallback(cb func(context uint32, msgID uint16, data []byte)) {
+func (a *VppAdapter) SetMsgCallback(cb adapter.MsgCallback) {
a.callback = cb
}
}
func (a *vppAPIClientAdapter) Connect() error {
- return nil
+ return adapter.ErrNotImplemented
}
func (a *vppAPIClientAdapter) Disconnect() {
return nil
}
-func (a *vppAPIClientAdapter) SetMsgCallback(cb func(context uint32, msgID uint16, data []byte)) {
+func (a *vppAPIClientAdapter) SetMsgCallback(cb adapter.MsgCallback) {
// no op
}
#include <arpa/inet.h>
#include <vpp-api/client/vppapiclient.h>
-extern void go_msg_callback(uint16_t, uint32_t, void*, size_t);
+extern void go_msg_callback(uint16_t msg_id, uint32_t context, void* data, size_t size);
typedef struct __attribute__((__packed__)) _req_header {
uint16_t msg_id;
typedef struct __attribute__((__packed__)) _reply_header {
uint16_t msg_id;
- uint32_t context;
+ uint32_t context; // currently not all reply messages contain context field
} reply_header_t;
static void
}
static int
-govpp_connect (char *shm)
+govpp_send(uint32_t context, void *data, size_t size)
{
- return vac_connect("govpp", shm, govpp_msg_callback, 32);
+ req_header_t *header = ((req_header_t *)data);
+ header->context = htonl(context);
+ return vac_write(data, size);
}
static int
-govvp_disconnect()
+govpp_connect (char *shm)
{
- return vac_disconnect();
+ return vac_connect("govpp", shm, govpp_msg_callback, 32);
}
static int
-govpp_send(uint32_t context, void *data, size_t size)
+govvp_disconnect()
{
- req_header_t *header = ((req_header_t *)data);
- header->context = htonl(context);
- return vac_write(data, size);
+ return vac_disconnect();
}
static uint32_t
import (
"fmt"
"os"
+ "path/filepath"
"reflect"
"unsafe"
// vppAPIClientAdapter is the opaque context of the adapter.
type vppAPIClientAdapter struct {
shmPrefix string
- callback func(context uint32, msgId uint16, data []byte)
+ callback adapter.MsgCallback
}
var vppClient *vppAPIClientAdapter // global vpp API client adapter context
msgID := uint16(C.govpp_get_msg_index(nameAndCrc))
if msgID == ^uint16(0) {
+ // VPP does not know this message
return msgID, fmt.Errorf("unknown message: %v (crc: %v)", msgName, msgCrc)
}
}
// SetMsgCallback sets a callback function that will be called by the adapter whenever a message comes from VPP.
-func (a *vppAPIClientAdapter) SetMsgCallback(cb func(context uint32, msgID uint16, data []byte)) {
+func (a *vppAPIClientAdapter) SetMsgCallback(cb adapter.MsgCallback) {
a.callback = cb
}
// WaitReady blocks until shared memory for sending
// binary api calls is present on the file system.
func (a *vppAPIClientAdapter) WaitReady() error {
- watcher, err := fsnotify.NewWatcher()
- if err != nil {
- return err
- }
- defer watcher.Close()
-
- err = watcher.Add(watchedFolder)
- if err != nil {
- return err
- }
- // Path to the shared memory segment with prefix, if set
+ // Path to the shared memory segment
var path string
if a.shmPrefix == "" {
- path = watchedFolder + watchedFile
+ path = filepath.Join(watchedFolder, watchedFile)
} else {
- path = watchedFolder + a.shmPrefix + "-" + watchedFile
- }
- if fileExists(path) {
- return nil
+ path = filepath.Join(watchedFolder, a.shmPrefix+"-"+watchedFile)
}
- for {
- ev := <-watcher.Events
- if ev.Name == path && (ev.Op&fsnotify.Create) == fsnotify.Create {
- break
+ // Watch folder if file does not exist yet
+ if !fileExists(path) {
+ watcher, err := fsnotify.NewWatcher()
+ if err != nil {
+ return err
+ }
+ defer watcher.Close()
+
+ if err := watcher.Add(watchedFolder); err != nil {
+ return err
+ }
+
+ for {
+ ev := <-watcher.Events
+ if ev.Name == path && (ev.Op&fsnotify.Create) == fsnotify.Create {
+ break
+ }
}
}
+
return nil
}
slice := &reflect.SliceHeader{Data: uintptr(data), Len: int(size), Cap: int(size)}
byteArr := *(*[]byte)(unsafe.Pointer(slice))
- vppClient.callback(uint32(context), uint16(msgID), byteArr)
-}
\ No newline at end of file
+ vppClient.callback(uint16(msgID), uint32(context), byteArr)
+}
package api
import (
+ "fmt"
"time"
)
// MessageType represents the type of a VPP message.
+// Note: this is currently derived from the message header (fields),
+// and in many cases it does not represent the actual type of VPP message.
+// This means that some replies can be identified as requests, etc.
+// TODO: use services to identify type of message
type MessageType int
const (
RequestMessage MessageType = iota
// ReplyMessage represents a VPP reply message
ReplyMessage
- // EventMessage represents a VPP notification event message
+ // EventMessage represents a VPP event message
EventMessage
- // OtherMessage represents other VPP message (e.g. counters)
+ // OtherMessage represents other VPP message
OtherMessage
)
// GetMessageName returns the original VPP name of the message, as defined in the VPP API.
GetMessageName() string
- // GetMessageType returns the type of the VPP message.
- GetMessageType() MessageType
-
// GetCrcString returns the string with CRC checksum of the message definition (the string represents a hexadecimal number).
GetCrcString() string
+
+ // GetMessageType returns the type of the VPP message.
+ GetMessageType() MessageType
}
// DataType is an interface that is implemented by all VPP Binary API data types by the binapi_generator.
GetCrcString() string
}
-// ChannelProvider provides the communication channel with govpp core.
-type ChannelProvider interface {
- // NewAPIChannel returns a new channel for communication with VPP via govpp core.
- // It uses default buffer sizes for the request and reply Go channels.
- NewAPIChannel() (Channel, error)
-
- // NewAPIChannelBuffered returns a new channel for communication with VPP via govpp core.
- // It allows to specify custom buffer sizes for the request and reply Go channels.
- NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (Channel, error)
-}
-
// MessageDecoder provides functionality for decoding binary data to generated API messages.
type MessageDecoder interface {
// DecodeMsg decodes binary-encoded data of a message into provided Message structure.
type MessageIdentifier interface {
// GetMessageID returns message identifier of given API message.
GetMessageID(msg Message) (uint16, error)
+
// LookupByID looks up message name and crc by ID
- LookupByID(ID uint16) (string, error)
+ LookupByID(msgID uint16) (Message, error)
+}
+
+// ChannelProvider provides the communication channel with govpp core.
+type ChannelProvider interface {
+ // NewAPIChannel returns a new channel for communication with VPP via govpp core.
+ // It uses default buffer sizes for the request and reply Go channels.
+ NewAPIChannel() (Channel, error)
+
+ // NewAPIChannelBuffered returns a new channel for communication with VPP via govpp core.
+ // It allows to specify custom buffer sizes for the request and reply Go channels.
+ NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (Channel, error)
}
// Channel provides methods for direct communication with VPP channel.
type Channel interface {
+ // GetID returns channel's ID
+ GetID() uint16
+
// SendRequest asynchronously sends a request to VPP. Returns a request context, that can be used to call ReceiveReply.
// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
SendRequest(msg Message) RequestCtx
+
// SendMultiRequest asynchronously sends a multipart request (request to which multiple responses are expected) to VPP.
// Returns a multipart request context, that can be used to call ReceiveReply.
// In case of any errors by sending, the error will be delivered to ReplyChan (and returned by ReceiveReply).
SendMultiRequest(msg Message) MultiRequestCtx
+
// SubscribeNotification subscribes for receiving of the specified notification messages via provided Go channel.
// Note that the caller is responsible for creating the Go channel with preferred buffer size. If the channel's
// buffer is full, the notifications will not be delivered into it.
SubscribeNotification(notifChan chan Message, msgFactory func() Message) (*NotifSubscription, error)
+
// UnsubscribeNotification unsubscribes from receiving the notifications tied to the provided notification subscription.
UnsubscribeNotification(subscription *NotifSubscription) error
- // CheckMessageCompatibility checks whether provided messages are compatible with the version of VPP
- // which the library is connected to.
- CheckMessageCompatibility(messages ...Message) error
+
// SetReplyTimeout sets the timeout for replies from VPP. It represents the maximum time the API waits for a reply
// from VPP before returning an error.
SetReplyTimeout(timeout time.Duration)
- // GetRequestChannel returns request go channel of the VPP channel
- GetRequestChannel() chan<- *VppRequest
- // GetReplyChannel returns reply go channel of the VPP channel
- GetReplyChannel() <-chan *VppReply
- // GetNotificationChannel returns notification go channel of the VPP channel
- GetNotificationChannel() chan<- *NotifSubscribeRequest
- // GetNotificationReplyChannel returns notification reply go channel of the VPP channel
- GetNotificationReplyChannel() <-chan error
- // GetMessageDecoder returns message decoder instance
- GetMessageDecoder() MessageDecoder
- // GetID returns channel's ID
- GetID() uint16
+
// Close closes the API channel and releases all API channel-related resources in the ChannelProvider.
Close()
}
ReceiveReply(msg Message) (lastReplyReceived bool, err error)
}
-// VppRequest is a request that will be sent to VPP.
-type VppRequest struct {
- SeqNum uint16 // sequence number
- Message Message // binary API message to be send to VPP
- Multipart bool // true if multipart response is expected, false otherwise
+// NotifSubscription represents a subscription for delivery of specific notification messages.
+type NotifSubscription struct {
+ NotifChan chan Message // channel where notification messages will be delivered to
+ MsgFactory func() Message // function that returns a new instance of the specific message that is expected as a notification
+ // TODO: use Message directly here, not a factory, eliminating need to allocation
}
-// VppReply is a reply received from VPP.
-type VppReply struct {
- MessageID uint16 // ID of the message
- SeqNum uint16 // sequence number
- Data []byte // encoded data with the message - MessageDecoder can be used for decoding
- LastReplyReceived bool // in case of multipart replies, true if the last reply has been already received and this one should be ignored
- Error error // in case of error, data is nil and this member contains error description
-}
+var registeredMessages = make(map[string]Message)
-// NotifSubscribeRequest is a request to subscribe for delivery of specific notification messages.
-type NotifSubscribeRequest struct {
- Subscription *NotifSubscription // subscription details
- Subscribe bool // true if this is a request to subscribe, false if unsubscribe
+// RegisterMessage is called from generated code to register message.
+func RegisterMessage(x Message, name string) {
+ if _, ok := registeredMessages[name]; ok {
+ panic(fmt.Errorf("govpp: duplicate message registered: %s (%s)", name, x.GetCrcString()))
+ }
+ registeredMessages[name] = x
}
-// NotifSubscription represents a subscription for delivery of specific notification messages.
-type NotifSubscription struct {
- NotifChan chan Message // channel where notification messages will be delivered to
- MsgFactory func() Message // function that returns a new instance of the specific message that is expected as a notification
+// GetAllMessages returns list of all registered messages.
+func GetAllMessages() map[string]Message {
+ return registeredMessages
}
--- /dev/null
+package api
+
+import (
+ "fmt"
+ "strconv"
+)
+
+// VPPApiError represents VPP's vnet API error that is usually
+// returned as Retval field in replies from VPP binary API.
+type VPPApiError int32
+
+func (e VPPApiError) Error() string {
+ var errstr string
+ if s, ok := vppApiErrors[e]; ok {
+ errstr = s
+ } else {
+ errstr = strconv.Itoa(int(e))
+ }
+ return fmt.Sprintf("VPPApiError: %s", errstr)
+}
+
+// definitions from: vpp/src/vnet/api_errno.h
+const (
+ _ VPPApiError = 0
+ UNSPECIFIED = -1
+ INVALID_SW_IF_INDEX = -2
+ NO_SUCH_FIB = -3
+ NO_SUCH_INNER_FIB = -4
+ NO_SUCH_LABEL = -5
+ NO_SUCH_ENTRY = -6
+ INVALID_VALUE = -7
+ INVALID_VALUE_2 = -8
+ UNIMPLEMENTED = -9
+ INVALID_SW_IF_INDEX_2 = -10
+ SYSCALL_ERROR_1 = -11
+ SYSCALL_ERROR_2 = -12
+ SYSCALL_ERROR_3 = -13
+ SYSCALL_ERROR_4 = -14
+ SYSCALL_ERROR_5 = -15
+ SYSCALL_ERROR_6 = -16
+ SYSCALL_ERROR_7 = -17
+ SYSCALL_ERROR_8 = -18
+ SYSCALL_ERROR_9 = -19
+ SYSCALL_ERROR_10 = -20
+ FEATURE_DISABLED = -30
+ INVALID_REGISTRATION = -31
+ NEXT_HOP_NOT_IN_FIB = -50
+ UNKNOWN_DESTINATION = -51
+ PREFIX_MATCHES_NEXT_HOP = -52
+ NEXT_HOP_NOT_FOUND_MP = -53
+ NO_MATCHING_INTERFACE = -54
+ INVALID_VLAN = -55
+ VLAN_ALREADY_EXISTS = -56
+ INVALID_SRC_ADDRESS = -57
+ INVALID_DST_ADDRESS = -58
+ ADDRESS_LENGTH_MISMATCH = -59
+ ADDRESS_NOT_FOUND_FOR_INTERFACE = -60
+ ADDRESS_NOT_LINK_LOCAL = -61
+ IP6_NOT_ENABLED = -62
+ IN_PROGRESS = 10
+ NO_SUCH_NODE = -63
+ NO_SUCH_NODE2 = -64
+ NO_SUCH_TABLE = -65
+ NO_SUCH_TABLE2 = -66
+ NO_SUCH_TABLE3 = -67
+ SUBIF_ALREADY_EXISTS = -68
+ SUBIF_CREATE_FAILED = -69
+ INVALID_MEMORY_SIZE = -70
+ INVALID_INTERFACE = -71
+ INVALID_VLAN_TAG_COUNT = -72
+ INVALID_ARGUMENT = -73
+ UNEXPECTED_INTF_STATE = -74
+ TUNNEL_EXIST = -75
+ INVALID_DECAP_NEXT = -76
+ RESPONSE_NOT_READY = -77
+ NOT_CONNECTED = -78
+ IF_ALREADY_EXISTS = -79
+ BOND_SLAVE_NOT_ALLOWED = -80
+ VALUE_EXIST = -81
+ SAME_SRC_DST = -82
+ IP6_MULTICAST_ADDRESS_NOT_PRESENT = -83
+ SR_POLICY_NAME_NOT_PRESENT = -84
+ NOT_RUNNING_AS_ROOT = -85
+ ALREADY_CONNECTED = -86
+ UNSUPPORTED_JNI_VERSION = -87
+ FAILED_TO_ATTACH_TO_JAVA_THREAD = -88
+ INVALID_WORKER = -89
+ LISP_DISABLED = -90
+ CLASSIFY_TABLE_NOT_FOUND = -91
+ INVALID_EID_TYPE = -92
+ CANNOT_CREATE_PCAP_FILE = -93
+ INCORRECT_ADJACENCY_TYPE = -94
+ EXCEEDED_NUMBER_OF_RANGES_CAPACITY = -95
+ EXCEEDED_NUMBER_OF_PORTS_CAPACITY = -96
+ INVALID_ADDRESS_FAMILY = -97
+ INVALID_SUB_SW_IF_INDEX = -98
+ TABLE_TOO_BIG = -99
+ CANNOT_ENABLE_DISABLE_FEATURE = -100
+ BFD_EEXIST = -101
+ BFD_ENOENT = -102
+ BFD_EINUSE = -103
+ BFD_NOTSUPP = -104
+ ADDRESS_IN_USE = -105
+ ADDRESS_NOT_IN_USE = -106
+ QUEUE_FULL = -107
+ APP_UNSUPPORTED_CFG = -108
+ URI_FIFO_CREATE_FAILED = -109
+ LISP_RLOC_LOCAL = -110
+ BFD_EAGAIN = -111
+ INVALID_GPE_MODE = -112
+ LISP_GPE_ENTRIES_PRESENT = -113
+ ADDRESS_FOUND_FOR_INTERFACE = -114
+ SESSION_CONNECT = -115
+ ENTRY_ALREADY_EXISTS = -116
+ SVM_SEGMENT_CREATE_FAIL = -117
+ APPLICATION_NOT_ATTACHED = -118
+ BD_ALREADY_EXISTS = -119
+ BD_IN_USE = -120
+ BD_NOT_MODIFIABLE = -121
+ BD_ID_EXCEED_MAX = -122
+ SUBIF_DOESNT_EXIST = -123
+ L2_MACS_EVENT_CLINET_PRESENT = -124
+ INVALID_QUEUE = -125
+ UNSUPPORTED = -126
+ DUPLICATE_IF_ADDRESS = -127
+ APP_INVALID_NS = -128
+ APP_WRONG_NS_SECRET = -129
+ APP_CONNECT_SCOPE = -130
+ APP_ALREADY_ATTACHED = -131
+ SESSION_REDIRECT = -132
+ ILLEGAL_NAME = -133
+ NO_NAME_SERVERS = -134
+ NAME_SERVER_NOT_FOUND = -135
+ NAME_RESOLUTION_NOT_ENABLED = -136
+ NAME_SERVER_FORMAT_ERROR = -137
+ NAME_SERVER_NO_SUCH_NAME = -138
+ NAME_SERVER_NO_ADDRESSES = -139
+ NAME_SERVER_NEXT_SERVER = -140
+ APP_CONNECT_FILTERED = -141
+ ACL_IN_USE_INBOUND = -142
+ ACL_IN_USE_OUTBOUND = -143
+ INIT_FAILED = -144
+ NETLINK_ERROR = -145
+ BIER_BSL_UNSUP = -146
+ INSTANCE_IN_USE = -147
+ INVALID_SESSION_ID = -148
+ ACL_IN_USE_BY_LOOKUP_CONTEXT = -149
+)
+
+var vppApiErrors = map[VPPApiError]string{
+ UNSPECIFIED: "Unspecified Error",
+ INVALID_SW_IF_INDEX: "Invalid sw_if_index",
+ NO_SUCH_FIB: "No such FIB / VRF",
+ NO_SUCH_INNER_FIB: "No such inner FIB / VRF",
+ NO_SUCH_LABEL: "No such label",
+ NO_SUCH_ENTRY: "No such entry",
+ INVALID_VALUE: "Invalid value",
+ INVALID_VALUE_2: "Invalid value #2",
+ UNIMPLEMENTED: "Unimplemented",
+ INVALID_SW_IF_INDEX_2: "Invalid sw_if_index #2",
+ SYSCALL_ERROR_1: "System call error #1",
+ SYSCALL_ERROR_2: "System call error #2",
+ SYSCALL_ERROR_3: "System call error #3",
+ SYSCALL_ERROR_4: "System call error #4",
+ SYSCALL_ERROR_5: "System call error #5",
+ SYSCALL_ERROR_6: "System call error #6",
+ SYSCALL_ERROR_7: "System call error #7",
+ SYSCALL_ERROR_8: "System call error #8",
+ SYSCALL_ERROR_9: "System call error #9",
+ SYSCALL_ERROR_10: "System call error #10",
+ FEATURE_DISABLED: "Feature disabled by configuration",
+ INVALID_REGISTRATION: "Invalid registration",
+ NEXT_HOP_NOT_IN_FIB: "Next hop not in FIB",
+ UNKNOWN_DESTINATION: "Unknown destination",
+ PREFIX_MATCHES_NEXT_HOP: "Prefix matches next hop",
+ NEXT_HOP_NOT_FOUND_MP: "Next hop not found (multipath)",
+ NO_MATCHING_INTERFACE: "No matching interface for probe",
+ INVALID_VLAN: "Invalid VLAN",
+ VLAN_ALREADY_EXISTS: "VLAN subif already exists",
+ INVALID_SRC_ADDRESS: "Invalid src address",
+ INVALID_DST_ADDRESS: "Invalid dst address",
+ ADDRESS_LENGTH_MISMATCH: "Address length mismatch",
+ ADDRESS_NOT_FOUND_FOR_INTERFACE: "Address not found for interface",
+ ADDRESS_NOT_LINK_LOCAL: "Address not link-local",
+ IP6_NOT_ENABLED: "ip6 not enabled",
+ IN_PROGRESS: "Operation in progress",
+ NO_SUCH_NODE: "No such graph node",
+ NO_SUCH_NODE2: "No such graph node #2",
+ NO_SUCH_TABLE: "No such table",
+ NO_SUCH_TABLE2: "No such table #2",
+ NO_SUCH_TABLE3: "No such table #3",
+ SUBIF_ALREADY_EXISTS: "Subinterface already exists",
+ SUBIF_CREATE_FAILED: "Subinterface creation failed",
+ INVALID_MEMORY_SIZE: "Invalid memory size requested",
+ INVALID_INTERFACE: "Invalid interface",
+ INVALID_VLAN_TAG_COUNT: "Invalid number of tags for requested operation",
+ INVALID_ARGUMENT: "Invalid argument",
+ UNEXPECTED_INTF_STATE: "Unexpected interface state",
+ TUNNEL_EXIST: "Tunnel already exists",
+ INVALID_DECAP_NEXT: "Invalid decap-next",
+ RESPONSE_NOT_READY: "Response not ready",
+ NOT_CONNECTED: "Not connected to the data plane",
+ IF_ALREADY_EXISTS: "Interface already exists",
+ BOND_SLAVE_NOT_ALLOWED: "Operation not allowed on slave of BondEthernet",
+ VALUE_EXIST: "Value already exists",
+ SAME_SRC_DST: "Source and destination are the same",
+ IP6_MULTICAST_ADDRESS_NOT_PRESENT: "IP6 multicast address required",
+ SR_POLICY_NAME_NOT_PRESENT: "Segement routing policy name required",
+ NOT_RUNNING_AS_ROOT: "Not running as root",
+ ALREADY_CONNECTED: "Connection to the data plane already exists",
+ UNSUPPORTED_JNI_VERSION: "Unsupported JNI version",
+ FAILED_TO_ATTACH_TO_JAVA_THREAD: "Failed to attach to Java thread",
+ INVALID_WORKER: "Invalid worker thread",
+ LISP_DISABLED: "LISP is disabled",
+ CLASSIFY_TABLE_NOT_FOUND: "Classify table not found",
+ INVALID_EID_TYPE: "Unsupported LSIP EID type",
+ CANNOT_CREATE_PCAP_FILE: "Cannot create pcap file",
+ INCORRECT_ADJACENCY_TYPE: "Invalid adjacency type for this operation",
+ EXCEEDED_NUMBER_OF_RANGES_CAPACITY: "Operation would exceed configured capacity of ranges",
+ EXCEEDED_NUMBER_OF_PORTS_CAPACITY: "Operation would exceed capacity of number of ports",
+ INVALID_ADDRESS_FAMILY: "Invalid address family",
+ INVALID_SUB_SW_IF_INDEX: "Invalid sub-interface sw_if_index",
+ TABLE_TOO_BIG: "Table too big",
+ CANNOT_ENABLE_DISABLE_FEATURE: "Cannot enable/disable feature",
+ BFD_EEXIST: "Duplicate BFD object",
+ BFD_ENOENT: "No such BFD object",
+ BFD_EINUSE: "BFD object in use",
+ BFD_NOTSUPP: "BFD feature not supported",
+ ADDRESS_IN_USE: "Address in use",
+ ADDRESS_NOT_IN_USE: "Address not in use",
+ QUEUE_FULL: "Queue full",
+ APP_UNSUPPORTED_CFG: "Unsupported application config",
+ URI_FIFO_CREATE_FAILED: "URI FIFO segment create failed",
+ LISP_RLOC_LOCAL: "RLOC address is local",
+ BFD_EAGAIN: "BFD object cannot be manipulated at this time",
+ INVALID_GPE_MODE: "Invalid GPE mode",
+ LISP_GPE_ENTRIES_PRESENT: "LISP GPE entries are present",
+ ADDRESS_FOUND_FOR_INTERFACE: "Address found for interface",
+ SESSION_CONNECT: "Session failed to connect",
+ ENTRY_ALREADY_EXISTS: "Entry already exists",
+ SVM_SEGMENT_CREATE_FAIL: "svm segment create fail",
+ APPLICATION_NOT_ATTACHED: "application not attached",
+ BD_ALREADY_EXISTS: "Bridge domain already exists",
+ BD_IN_USE: "Bridge domain has member interfaces",
+ BD_NOT_MODIFIABLE: "Bridge domain 0 can't be deleted/modified",
+ BD_ID_EXCEED_MAX: "Bridge domain ID exceed 16M limit",
+ SUBIF_DOESNT_EXIST: "Subinterface doesn't exist",
+ L2_MACS_EVENT_CLINET_PRESENT: "Client already exist for L2 MACs events",
+ INVALID_QUEUE: "Invalid queue",
+ UNSUPPORTED: "Unsupported",
+ DUPLICATE_IF_ADDRESS: "Address already present on another interface",
+ APP_INVALID_NS: "Invalid application namespace",
+ APP_WRONG_NS_SECRET: "Wrong app namespace secret",
+ APP_CONNECT_SCOPE: "Connect scope",
+ APP_ALREADY_ATTACHED: "App already attached",
+ SESSION_REDIRECT: "Redirect failed",
+ ILLEGAL_NAME: "Illegal name",
+ NO_NAME_SERVERS: "No name servers configured",
+ NAME_SERVER_NOT_FOUND: "Name server not found",
+ NAME_RESOLUTION_NOT_ENABLED: "Name resolution not enabled",
+ NAME_SERVER_FORMAT_ERROR: "Server format error (bug!)",
+ NAME_SERVER_NO_SUCH_NAME: "No such name",
+ NAME_SERVER_NO_ADDRESSES: "No addresses available",
+ NAME_SERVER_NEXT_SERVER: "Retry with new server",
+ APP_CONNECT_FILTERED: "Connect was filtered",
+ ACL_IN_USE_INBOUND: "Inbound ACL in use",
+ ACL_IN_USE_OUTBOUND: "Outbound ACL in use",
+ INIT_FAILED: "Initialization Failed",
+ NETLINK_ERROR: "netlink error",
+ BIER_BSL_UNSUP: "BIER bit-string-length unsupported",
+ INSTANCE_IN_USE: "Instance in use",
+ INVALID_SESSION_ID: "session ID out of range",
+ ACL_IN_USE_BY_LOOKUP_CONTEXT: "ACL in use by a lookup context",
+}
--- /dev/null
+// Copyright (c) 2018 Cisco and/or its affiliates.
+//
+// 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 (
+ "strconv"
+ "strings"
+ "unicode"
+)
+
+func getBinapiTypeSize(binapiType string) int {
+ if _, ok := binapiTypes[binapiType]; ok {
+ b, err := strconv.Atoi(strings.TrimLeft(binapiType, "uif"))
+ if err == nil {
+ return b / 8
+ }
+ }
+ return -1
+}
+
+// binapiTypes is a set of types used VPP binary API for translation to Go types
+var binapiTypes = map[string]string{
+ "u8": "uint8",
+ "i8": "int8",
+ "u16": "uint16",
+ "i16": "int16",
+ "u32": "uint32",
+ "i32": "int32",
+ "u64": "uint64",
+ "i64": "int64",
+ "f64": "float64",
+}
+
+func usesInitialism(s string) string {
+ if u := strings.ToUpper(s); commonInitialisms[u] {
+ return u
+ } else if su, ok := specialInitialisms[u]; ok {
+ return su
+ }
+ return ""
+}
+
+// commonInitialisms is a set of common initialisms that need to stay in upper case.
+var commonInitialisms = map[string]bool{
+ "ACL": true,
+ "API": true,
+ //"ASCII": true, // there are only two use cases for ASCII which already have initialism before and after
+ "CPU": true,
+ "CSS": true,
+ "DNS": true,
+ "DHCP": true,
+ "EOF": true,
+ "GUID": true,
+ "HTML": true,
+ "HTTP": true,
+ "HTTPS": true,
+ "ID": true,
+ "IP": true,
+ "ICMP": true,
+ "JSON": true,
+ "LHS": true,
+ "QPS": true,
+ "PID": true,
+ "RAM": true,
+ "RHS": true,
+ "RPC": true,
+ "SLA": true,
+ "SMTP": true,
+ "SQL": true,
+ "SSH": true,
+ "TCP": true,
+ "TLS": true,
+ "TTL": true,
+ "UDP": true,
+ "UI": true,
+ "UID": true,
+ "UUID": true,
+ "URI": true,
+ "URL": true,
+ "UTF8": true,
+ "VM": true,
+ "VPN": true,
+ "XML": true,
+ "XMPP": true,
+ "XSRF": true,
+ "XSS": true,
+}
+
+// specialInitialisms is a set of special initialisms that need part to stay in upper case.
+var specialInitialisms = map[string]string{
+ "IPV": "IPv",
+ //"IPV4": "IPv4",
+ //"IPV6": "IPv6",
+}
+
+// camelCaseName returns correct name identifier (camelCase).
+func camelCaseName(name string) (should string) {
+ name = strings.Title(name)
+
+ // Fast path for simple cases: "_" and all lowercase.
+ if name == "_" {
+ return name
+ }
+ allLower := true
+ for _, r := range name {
+ if !unicode.IsLower(r) {
+ allLower = false
+ break
+ }
+ }
+ if allLower {
+ return name
+ }
+
+ // Split camelCase at any lower->upper transition, and split on underscores.
+ // Check each word for common initialisms.
+ runes := []rune(name)
+ w, i := 0, 0 // index of start of word, scan
+ for i+1 <= len(runes) {
+ eow := false // whether we hit the end of a word
+ if i+1 == len(runes) {
+ eow = true
+ } else if runes[i+1] == '_' {
+ // underscore; shift the remainder forward over any run of underscores
+ eow = true
+ n := 1
+ for i+n+1 < len(runes) && runes[i+n+1] == '_' {
+ n++
+ }
+
+ // Leave at most one underscore if the underscore is between two digits
+ if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) {
+ n--
+ }
+
+ copy(runes[i+1:], runes[i+n+1:])
+ runes = runes[:len(runes)-n]
+ } else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) {
+ // lower->non-lower
+ eow = true
+ }
+ i++
+ if !eow {
+ continue
+ }
+
+ // [w,i) is a word.
+ word := string(runes[w:i])
+ if u := usesInitialism(word); u != "" {
+ // Keep consistent case, which is lowercase only at the start.
+ if w == 0 && unicode.IsLower(runes[w]) {
+ u = strings.ToLower(u)
+ }
+ // All the common initialisms are ASCII,
+ // so we can replace the bytes exactly.
+ copy(runes[w:], []rune(u))
+ } else if w > 0 && strings.ToLower(word) == word {
+ // already all lowercase, and not the first word, so uppercase the first character.
+ runes[w] = unicode.ToUpper(runes[w])
+ }
+ w = i
+ }
+ return string(runes)
+}
--- /dev/null
+package main
+
+import (
+ "testing"
+)
+
+func TestInitialism(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ expOutput string
+ }{
+ {name: "id", input: "id", expOutput: "ID"},
+ {name: "ipv6", input: "is_ipv6", expOutput: "IsIPv6"},
+ {name: "ip6", input: "is_ip6", expOutput: "IsIP6"},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ output := camelCaseName(test.input)
+ if output != test.expOutput {
+ t.Errorf("expected %q, got %q", test.expOutput, output)
+ }
+ })
+ }
+}
--- /dev/null
+// Copyright (c) 2017 Cisco and/or its affiliates.
+//
+// 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 (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+ "path/filepath"
+ "strings"
+ "unicode"
+)
+
+const (
+ govppApiImportPath = "git.fd.io/govpp.git/api" // import path of the govpp API package
+ inputFileExt = ".api.json" // file extension of the VPP binary API files
+ outputFileExt = ".ba.go" // file extension of the Go generated files
+)
+
+// context is a structure storing data for code generation
+type context struct {
+ inputFile string // input file with VPP API in JSON
+ outputFile string // output file with generated Go package
+
+ inputData []byte // contents of the input file
+ inputBuff *bytes.Buffer // contents of the input file currently being read
+ inputLine int // currently processed line in the input file
+
+ moduleName string // name of the source VPP module
+ packageName string // name of the Go package being generated
+
+ packageData *Package // parsed package data
+}
+
+// getContext returns context details of the code generation task
+func getContext(inputFile, outputDir string) (*context, error) {
+ if !strings.HasSuffix(inputFile, inputFileExt) {
+ return nil, fmt.Errorf("invalid input file name: %q", inputFile)
+ }
+
+ ctx := &context{
+ inputFile: inputFile,
+ }
+
+ // package name
+ inputFileName := filepath.Base(inputFile)
+ ctx.moduleName = inputFileName[:strings.Index(inputFileName, ".")]
+
+ // alter package names for modules that are reserved keywords in Go
+ switch ctx.moduleName {
+ case "interface":
+ ctx.packageName = "interfaces"
+ case "map":
+ ctx.packageName = "maps"
+ default:
+ ctx.packageName = ctx.moduleName
+ }
+
+ // output file
+ packageDir := filepath.Join(outputDir, ctx.packageName)
+ outputFileName := ctx.packageName + outputFileExt
+ ctx.outputFile = filepath.Join(packageDir, outputFileName)
+
+ return ctx, nil
+}
+
+// generatePackage generates code for the parsed package data and writes it into w
+func generatePackage(ctx *context, w *bufio.Writer) error {
+ logf("generating package %q", ctx.packageName)
+
+ // generate file header
+ generateHeader(ctx, w)
+ generateImports(ctx, w)
+
+ if *includeAPIVer {
+ const APIVerConstName = "VlAPIVersion"
+ fmt.Fprintf(w, "// %s represents version of the API.\n", APIVerConstName)
+ fmt.Fprintf(w, "const %s = %v\n", APIVerConstName, ctx.packageData.APIVersion)
+ fmt.Fprintln(w)
+ }
+
+ // generate enums
+ if len(ctx.packageData.Enums) > 0 {
+ fmt.Fprintf(w, "/* Enums */\n\n")
+
+ ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
+ ctx.inputLine = 0
+ for _, enum := range ctx.packageData.Enums {
+ generateEnum(ctx, w, &enum)
+ }
+ }
+
+ // generate types
+ if len(ctx.packageData.Types) > 0 {
+ fmt.Fprintf(w, "/* Types */\n\n")
+
+ ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
+ ctx.inputLine = 0
+ for _, typ := range ctx.packageData.Types {
+ generateType(ctx, w, &typ)
+ }
+ }
+
+ // generate unions
+ if len(ctx.packageData.Unions) > 0 {
+ fmt.Fprintf(w, "/* Unions */\n\n")
+
+ ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
+ ctx.inputLine = 0
+ for _, union := range ctx.packageData.Unions {
+ generateUnion(ctx, w, &union)
+ }
+ }
+
+ // generate messages
+ if len(ctx.packageData.Messages) > 0 {
+ fmt.Fprintf(w, "/* Messages */\n\n")
+
+ ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
+ ctx.inputLine = 0
+ for _, msg := range ctx.packageData.Messages {
+ generateMessage(ctx, w, &msg)
+ }
+ }
+
+ // generate services
+ if len(ctx.packageData.Services) > 0 {
+ fmt.Fprintf(w, "/* Services */\n\n")
+
+ fmt.Fprintf(w, "type %s interface {\n", "Services")
+ ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
+ ctx.inputLine = 0
+ for _, svc := range ctx.packageData.Services {
+ generateService(ctx, w, &svc)
+ }
+ fmt.Fprintln(w, "}")
+ }
+
+ // TODO: generate implementation for Services interface
+
+ // generate message registrations
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "func init() {")
+ for _, msg := range ctx.packageData.Messages {
+ name := camelCaseName(msg.Name)
+ fmt.Fprintf(w, "\tapi.RegisterMessage((*%s)(nil), \"%s\")\n", name, ctx.moduleName+"."+name)
+ }
+ fmt.Fprintln(w, "}")
+
+ // flush the data:
+ if err := w.Flush(); err != nil {
+ return fmt.Errorf("flushing data to %s failed: %v", ctx.outputFile, err)
+ }
+
+ return nil
+}
+
+// generateHeader writes generated package header into w
+func generateHeader(ctx *context, w io.Writer) {
+ fmt.Fprintln(w, "// Code generated by GoVPP binapi-generator. DO NOT EDIT.")
+ fmt.Fprintf(w, "// source: %s\n", ctx.inputFile)
+ fmt.Fprintln(w)
+
+ fmt.Fprintln(w, "/*")
+ fmt.Fprintf(w, "Package %s is a generated VPP binary API of the '%s' VPP module.\n", ctx.packageName, ctx.moduleName)
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "It is generated from this file:")
+ fmt.Fprintf(w, "\t%s\n", filepath.Base(ctx.inputFile))
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "It contains these VPP binary API objects:")
+ var printObjNum = func(obj string, num int) {
+ if num > 0 {
+ if num > 1 {
+ obj += "s"
+ }
+ fmt.Fprintf(w, "\t%d %s\n", num, obj)
+ }
+ }
+ printObjNum("message", len(ctx.packageData.Messages))
+ printObjNum("type", len(ctx.packageData.Types))
+ printObjNum("enum", len(ctx.packageData.Enums))
+ printObjNum("union", len(ctx.packageData.Unions))
+ printObjNum("service", len(ctx.packageData.Services))
+ fmt.Fprintln(w, "*/")
+ fmt.Fprintf(w, "package %s\n", ctx.packageName)
+ fmt.Fprintln(w)
+}
+
+// generateImports writes generated package imports into w
+func generateImports(ctx *context, w io.Writer) {
+ fmt.Fprintf(w, "import \"%s\"\n", govppApiImportPath)
+ fmt.Fprintf(w, "import \"%s\"\n", "github.com/lunixbochs/struc")
+ fmt.Fprintf(w, "import \"%s\"\n", "bytes")
+ fmt.Fprintln(w)
+
+ fmt.Fprintf(w, "// Reference imports to suppress errors if they are not otherwise used.\n")
+ fmt.Fprintf(w, "var _ = struc.Pack\n")
+ fmt.Fprintf(w, "var _ = bytes.NewBuffer\n")
+ fmt.Fprintln(w)
+}
+
+// generateComment writes generated comment for the object into w
+func generateComment(ctx *context, w io.Writer, goName string, vppName string, objKind string) {
+ fmt.Fprintf(w, "// %s represents the VPP binary API %s '%s'.\n", goName, objKind, vppName)
+
+ var isNotSpace = func(r rune) bool {
+ return !unicode.IsSpace(r)
+ }
+
+ // print out the source of the generated object
+ objFound := false
+ objTitle := fmt.Sprintf(`"%s",`, vppName)
+ var indent int
+ for {
+ line, err := ctx.inputBuff.ReadString('\n')
+ if err != nil {
+ break
+ }
+ ctx.inputLine++
+
+ if !objFound {
+ indent = strings.Index(line, objTitle)
+ if indent == -1 {
+ continue
+ }
+ // If no other non-whitespace character then we are at the message header.
+ if trimmed := strings.TrimSpace(line); trimmed == objTitle {
+ objFound = true
+ fmt.Fprintf(w, "// Generated from '%s', line %d:\n", filepath.Base(ctx.inputFile), ctx.inputLine)
+ fmt.Fprintln(w, "//")
+ }
+ } else {
+ if strings.IndexFunc(line, isNotSpace) < indent {
+ break // end of the object definition in JSON
+ }
+ }
+ fmt.Fprint(w, "//", line)
+ }
+
+ fmt.Fprintln(w, "//")
+}
+
+// generateEnum writes generated code for the enum into w
+func generateEnum(ctx *context, w io.Writer, enum *Enum) {
+ name := camelCaseName(enum.Name)
+ typ := binapiTypes[enum.Type]
+
+ logf(" writing enum %q (%s) with %d entries", enum.Name, name, len(enum.Entries))
+
+ // generate enum comment
+ generateComment(ctx, w, name, enum.Name, "enum")
+
+ // generate enum definition
+ fmt.Fprintf(w, "type %s %s\n", name, typ)
+ fmt.Fprintln(w)
+
+ fmt.Fprintln(w, "const (")
+
+ // generate enum entries
+ for _, entry := range enum.Entries {
+ fmt.Fprintf(w, "\t%s %s = %v\n", entry.Name, name, entry.Value)
+ }
+
+ fmt.Fprintln(w, ")")
+
+ fmt.Fprintln(w)
+}
+
+// generateType writes generated code for the type into w
+func generateType(ctx *context, w io.Writer, typ *Type) {
+ name := camelCaseName(typ.Name)
+
+ logf(" writing type %q (%s) with %d fields", typ.Name, name, len(typ.Fields))
+
+ // generate struct comment
+ generateComment(ctx, w, name, typ.Name, "type")
+
+ // generate struct definition
+ fmt.Fprintf(w, "type %s struct {\n", name)
+
+ // generate struct fields
+ for i, field := range typ.Fields {
+ // skip internal fields
+ switch strings.ToLower(field.Name) {
+ case "crc", "_vl_msg_id":
+ continue
+ }
+
+ generateField(ctx, w, typ.Fields, i)
+ }
+
+ // generate end of the struct
+ fmt.Fprintln(w, "}")
+
+ // generate name getter
+ generateTypeNameGetter(w, name, typ.Name)
+
+ // generate CRC getter
+ generateCrcGetter(w, name, typ.CRC)
+
+ fmt.Fprintln(w)
+}
+
+// generateUnion writes generated code for the union into w
+func generateUnion(ctx *context, w io.Writer, union *Union) {
+ name := camelCaseName(union.Name)
+
+ logf(" writing union %q (%s) with %d fields", union.Name, name, len(union.Fields))
+
+ // generate struct comment
+ generateComment(ctx, w, name, union.Name, "union")
+
+ // generate struct definition
+ fmt.Fprintln(w, "type", name, "struct {")
+
+ // maximum size for union
+ maxSize := getUnionSize(ctx, union)
+
+ // generate data field
+ fieldName := "Union_data"
+ fmt.Fprintf(w, "\t%s [%d]byte\n", fieldName, maxSize)
+
+ // generate end of the struct
+ fmt.Fprintln(w, "}")
+
+ // generate name getter
+ generateTypeNameGetter(w, name, union.Name)
+
+ // generate CRC getter
+ generateCrcGetter(w, name, union.CRC)
+
+ // generate getters for fields
+ for _, field := range union.Fields {
+ fieldName := camelCaseName(field.Name)
+ fieldType := convertToGoType(ctx, field.Type)
+ generateUnionGetterSetter(w, name, fieldName, fieldType)
+ }
+
+ // generate union methods
+ //generateUnionMethods(w, name)
+
+ fmt.Fprintln(w)
+}
+
+// generateUnionMethods generates methods that implement struc.Custom
+// interface to allow having Union_data field unexported
+// TODO: do more testing when unions are actually used in some messages
+func generateUnionMethods(w io.Writer, structName string) {
+ // generate struc.Custom implementation for union
+ fmt.Fprintf(w, `
+func (u *%[1]s) Pack(p []byte, opt *struc.Options) (int, error) {
+ var b = new(bytes.Buffer)
+ if err := struc.PackWithOptions(b, u.union_data, opt); err != nil {
+ return 0, err
+ }
+ copy(p, b.Bytes())
+ return b.Len(), nil
+}
+func (u *%[1]s) Unpack(r io.Reader, length int, opt *struc.Options) error {
+ return struc.UnpackWithOptions(r, u.union_data[:], opt)
+}
+func (u *%[1]s) Size(opt *struc.Options) int {
+ return len(u.union_data)
+}
+func (u *%[1]s) String() string {
+ return string(u.union_data[:])
+}
+`, structName)
+}
+
+func generateUnionGetterSetter(w io.Writer, structName string, getterField, getterStruct string) {
+ fmt.Fprintf(w, `
+func (u *%[1]s) Set%[2]s(a %[3]s) {
+ var b = new(bytes.Buffer)
+ if err := struc.Pack(b, &a); err != nil {
+ return
+ }
+ copy(u.Union_data[:], b.Bytes())
+}
+func (u *%[1]s) Get%[2]s() (a %[3]s) {
+ var b = bytes.NewReader(u.Union_data[:])
+ struc.Unpack(b, &a)
+ return
+}
+`, structName, getterField, getterStruct)
+}
+
+// generateMessage writes generated code for the message into w
+func generateMessage(ctx *context, w io.Writer, msg *Message) {
+ name := camelCaseName(msg.Name)
+
+ logf(" writing message %q (%s) with %d fields", msg.Name, name, len(msg.Fields))
+
+ // generate struct comment
+ generateComment(ctx, w, name, msg.Name, "message")
+
+ // generate struct definition
+ fmt.Fprintf(w, "type %s struct {", name)
+
+ msgType := otherMessage
+ wasClientIndex := false
+
+ // generate struct fields
+ n := 0
+ for i, field := range msg.Fields {
+ if i == 1 {
+ if field.Name == "client_index" {
+ // "client_index" as the second member, this might be an event message or a request
+ msgType = eventMessage
+ wasClientIndex = true
+ } else if field.Name == "context" {
+ // reply needs "context" as the second member
+ msgType = replyMessage
+ }
+ } else if i == 2 {
+ if wasClientIndex && field.Name == "context" {
+ // request needs "client_index" as the second member and "context" as the third member
+ msgType = requestMessage
+ }
+ }
+
+ // skip internal fields
+ switch strings.ToLower(field.Name) {
+ case "crc", "_vl_msg_id":
+ continue
+ case "client_index", "context":
+ if n == 0 {
+ continue
+ }
+ }
+ n++
+ if n == 1 {
+ fmt.Fprintln(w)
+ }
+
+ generateField(ctx, w, msg.Fields, i)
+ }
+
+ // generate end of the struct
+ fmt.Fprintln(w, "}")
+
+ // generate name getter
+ generateMessageNameGetter(w, name, msg.Name)
+
+ // generate CRC getter
+ generateCrcGetter(w, name, msg.CRC)
+
+ // generate message type getter method
+ generateMessageTypeGetter(w, name, msgType)
+
+ // generate message factory
+ generateMessageFactory(w, name)
+}
+
+// generateField writes generated code for the field into w
+func generateField(ctx *context, w io.Writer, fields []Field, i int) {
+ field := fields[i]
+
+ fieldName := strings.TrimPrefix(field.Name, "_")
+ fieldName = camelCaseName(fieldName)
+
+ dataType := convertToGoType(ctx, field.Type)
+
+ fieldType := dataType
+ if field.IsArray() {
+ if dataType == "uint8" {
+ dataType = "byte"
+ }
+ fieldType = "[]" + dataType
+ }
+ fmt.Fprintf(w, "\t%s %s", fieldName, fieldType)
+
+ if field.Length > 0 {
+ // fixed size array
+ fmt.Fprintf(w, "\t`struc:\"[%d]%s\"`", field.Length, dataType)
+ } else {
+ for _, f := range fields {
+ if f.SizeFrom == field.Name {
+ // variable sized array
+ sizeOfName := camelCaseName(f.Name)
+ fmt.Fprintf(w, "\t`struc:\"sizeof=%s\"`", sizeOfName)
+ }
+ }
+ }
+
+ fmt.Fprintln(w)
+}
+
+// generateService writes generated code for the service into w
+func generateService(ctx *context, w io.Writer, svc *Service) {
+ reqTyp := camelCaseName(svc.RequestType)
+
+ // method name is same as parameter type name by default
+ method := reqTyp
+ if svc.Stream {
+ // use Dump as prefix instead of suffix for stream services
+ if m := strings.TrimSuffix(method, "Dump"); method != m {
+ method = "Dump" + m
+ }
+ }
+ params := fmt.Sprintf("*%s", reqTyp)
+ returns := "error"
+ if replyTyp := camelCaseName(svc.ReplyType); replyTyp != "" {
+ returns = fmt.Sprintf("(*%s, error)", replyTyp)
+ }
+
+ fmt.Fprintf(w, "\t%s(%s) %s\n", method, params, returns)
+}
+
+// generateMessageNameGetter generates getter for original VPP message name into the provider writer
+func generateMessageNameGetter(w io.Writer, structName string, msgName string) {
+ fmt.Fprintln(w, "func (*"+structName+") GetMessageName() string {")
+ fmt.Fprintln(w, "\treturn \""+msgName+"\"")
+ fmt.Fprintln(w, "}")
+}
+
+// generateTypeNameGetter generates getter for original VPP type name into the provider writer
+func generateTypeNameGetter(w io.Writer, structName string, msgName string) {
+ fmt.Fprintln(w, "func (*"+structName+") GetTypeName() string {")
+ fmt.Fprintln(w, "\treturn \""+msgName+"\"")
+ fmt.Fprintln(w, "}")
+}
+
+// generateCrcGetter generates getter for CRC checksum of the message definition into the provider writer
+func generateCrcGetter(w io.Writer, structName string, crc string) {
+ crc = strings.TrimPrefix(crc, "0x")
+ fmt.Fprintln(w, "func (*"+structName+") GetCrcString() string {")
+ fmt.Fprintln(w, "\treturn \""+crc+"\"")
+ fmt.Fprintln(w, "}")
+}
+
+// generateMessageTypeGetter generates message factory for the generated message into the provider writer
+func generateMessageTypeGetter(w io.Writer, structName string, msgType MessageType) {
+ fmt.Fprintln(w, "func (*"+structName+") GetMessageType() api.MessageType {")
+ if msgType == requestMessage {
+ fmt.Fprintln(w, "\treturn api.RequestMessage")
+ } else if msgType == replyMessage {
+ fmt.Fprintln(w, "\treturn api.ReplyMessage")
+ } else if msgType == eventMessage {
+ fmt.Fprintln(w, "\treturn api.EventMessage")
+ } else {
+ fmt.Fprintln(w, "\treturn api.OtherMessage")
+ }
+ fmt.Fprintln(w, "}")
+}
+
+// generateMessageFactory generates message factory for the generated message into the provider writer
+func generateMessageFactory(w io.Writer, structName string) {
+ fmt.Fprintln(w, "func New"+structName+"() api.Message {")
+ fmt.Fprintln(w, "\treturn &"+structName+"{}")
+ fmt.Fprintln(w, "}")
+}
package main
import (
- "bufio"
- "bytes"
"os"
"testing"
- "github.com/bennyscetbun/jsongo"
. "github.com/onsi/gomega"
)
Expect(err).ShouldNot(HaveOccurred())
result, err := parseJSON(inputData)
Expect(err).Should(HaveOccurred())
- Expect(err.Error()).To(ContainSubstring("JSON unmarshall failed"))
Expect(result).To(BeNil())
}
+/*
func TestGeneratePackage(t *testing.T) {
RegisterTestingT(t)
// prepare context
// prepare writer
writer := bufio.NewWriter(outFile)
Expect(writer.Buffered()).To(BeZero())
- err = generatePackage(testCtx, writer, inFile)
+ err = generatePackage(testCtx, writer)
Expect(err).ShouldNot(HaveOccurred())
}
+
func TestGenerateMessageType(t *testing.T) {
RegisterTestingT(t)
// prepare context
func TestGenerateMessageFieldTypes(t *testing.T) {
// expected results according to acl.api.json in testdata
- expectedTypes := []string{"\tIsPermit uint8", "\tIsIpv6 uint8", "\tSrcIPAddr []byte `struc:\"[16]byte\"`",
- "\tSrcIPPrefixLen uint8", "\tDstIPAddr []byte `struc:\"[16]byte\"`", "\tDstIPPrefixLen uint8", "\tProto uint8",
- "\tSrcportOrIcmptypeFirst uint16", "\tSrcportOrIcmptypeLast uint16", "\tDstportOrIcmpcodeFirst uint16",
- "\tDstportOrIcmpcodeLast uint16", "\tTCPFlagsMask uint8", "\tTCPFlagsValue uint8"}
+ expectedTypes := []string{
+ "\tIsPermit uint8",
+ "\tIsIpv6 uint8",
+ "\tSrcIPAddr []byte `struc:\"[16]byte\"`",
+ "\tSrcIPPrefixLen uint8",
+ "\tDstIPAddr []byte `struc:\"[16]byte\"`",
+ "\tDstIPPrefixLen uint8",
+ "\tProto uint8",
+ "\tSrcportOrIcmptypeFirst uint16",
+ "\tSrcportOrIcmptypeLast uint16",
+ "\tDstportOrIcmpcodeFirst uint16",
+ "\tDstportOrIcmpcodeLast uint16",
+ "\tTCPFlagsMask uint8",
+ "\tTCPFlagsValue uint8"}
RegisterTestingT(t)
// prepare context
testCtx := new(context)
// prepare input/output output files
inputData, err := readFile("testdata/acl.api.json")
Expect(err).ShouldNot(HaveOccurred())
- inFile, _ := parseJSON(inputData)
+ inFile, err := parseJSON(inputData)
Expect(err).ShouldNot(HaveOccurred())
Expect(inFile).ToNot(BeNil())
for i := 0; i < types.Len(); i++ {
for j := 0; j < types.At(i).Len(); j++ {
field := types.At(i).At(j)
- if jsongo.TypeArray == field.GetType() {
+ if field.GetType() == jsongo.TypeArray {
err := processMessageField(testCtx, &fields, field, false)
Expect(err).ShouldNot(HaveOccurred())
Expect(fields[j-1]).To(BeEquivalentTo(expectedTypes[j-1]))
for i := 0; i < messages.Len(); i++ {
for j := 0; j < messages.At(i).Len(); j++ {
field := messages.At(i).At(j)
- if jsongo.TypeArray == field.GetType() {
+ if field.GetType() == jsongo.TypeArray {
specificFieldName := field.At(1).Get().(string)
if specificFieldName == "crc" || specificFieldName == "_vl_msg_id" ||
specificFieldName == "client_index" || specificFieldName == "context" {
Expect(fields[customIndex]).To(BeEquivalentTo(expectedFields[customIndex]))
customIndex++
if customIndex >= len(expectedFields) {
- /* there is too much fields now for one UT... */
+ // there is too much fields now for one UT...
return
}
}
// prepare writer
writer := bufio.NewWriter(outFile)
Expect(writer.Buffered()).To(BeZero())
- generatePackageHeader(testCtx, writer, inFile)
+ generateHeader(testCtx, writer, inFile)
Expect(writer.Buffered()).ToNot(BeZero())
}
context := new(context)
typesToTranslate := []string{"u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "f64"}
expected := []string{"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "float64"}
- translated := []string{}
+ var translated []string
for _, value := range typesToTranslate {
- translated = append(translated, translateVppType(context, value, false))
+ translated = append(translated, convertToGoType(context, value, false))
}
for index, value := range expected {
Expect(value).To(BeEquivalentTo(translated[index]))
func TestTranslateVppTypeArray(t *testing.T) {
RegisterTestingT(t)
context := new(context)
- translated := translateVppType(context, "u8", true)
+ translated := convertToGoType(context, "u8", true)
Expect(translated).To(BeEquivalentTo("byte"))
}
}
}()
context := new(context)
- translateVppType(context, "?", false)
+ convertToGoType(context, "?", false)
}
func TestCamelCase(t *testing.T) {
Expect(key).ShouldNot(BeEmpty())
}
}
+*/
+++ /dev/null
-// Copyright (c) 2017 Cisco and/or its affiliates.
-//
-// 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 (
- "bufio"
- "bytes"
- "encoding/json"
- "errors"
- "flag"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "os/exec"
- "path/filepath"
- "strings"
- "unicode"
-
- "github.com/bennyscetbun/jsongo"
-)
-
-var (
- inputFile = flag.String("input-file", "", "Input JSON file.")
- inputDir = flag.String("input-dir", ".", "Input directory with JSON files.")
- outputDir = flag.String("output-dir", ".", "Output directory where package folders will be generated.")
- includeAPIVer = flag.Bool("include-apiver", false, "Wether to include VlAPIVersion in generated file.")
-)
-
-// MessageType represents the type of a VPP message.
-type messageType int
-
-const (
- requestMessage messageType = iota // VPP request message
- replyMessage // VPP reply message
- eventMessage // VPP event message
- otherMessage // other VPP message
-)
-
-const (
- apiImportPath = "git.fd.io/govpp.git/api" // import path of the govpp API
- inputFileExt = ".json" // filename extension of files that should be processed as the input
-)
-
-// context is a structure storing details of a particular code generation task
-type context struct {
- inputFile string // file with input JSON data
- inputData []byte // contents of the input file
- inputBuff *bytes.Buffer // contents of the input file currently being read
- inputLine int // currently processed line in the input file
- outputFile string // file with output data
- packageName string // name of the Go package being generated
- packageDir string // directory where the package source files are located
- types map[string]string // map of the VPP typedef names to generated Go typedef names
-}
-
-func main() {
- flag.Parse()
-
- if *inputFile == "" && *inputDir == "" {
- fmt.Fprintln(os.Stderr, "ERROR: input-file or input-dir must be specified")
- os.Exit(1)
- }
-
- var err, tmpErr error
- if *inputFile != "" {
- // process one input file
- err = generateFromFile(*inputFile, *outputDir)
- if err != nil {
- fmt.Fprintf(os.Stderr, "ERROR: code generation from %s failed: %v\n", *inputFile, err)
- }
- } else {
- // process all files in specified directory
- files, err := getInputFiles(*inputDir)
- if err != nil {
- fmt.Fprintf(os.Stderr, "ERROR: code generation failed: %v\n", err)
- }
- for _, file := range files {
- tmpErr = generateFromFile(file, *outputDir)
- if tmpErr != nil {
- fmt.Fprintf(os.Stderr, "ERROR: code generation from %s failed: %v\n", file, err)
- err = tmpErr // remember that the error occurred
- }
- }
- }
- if err != nil {
- os.Exit(1)
- }
-}
-
-// getInputFiles returns all input files located in specified directory
-func getInputFiles(inputDir string) ([]string, error) {
- files, err := ioutil.ReadDir(inputDir)
- if err != nil {
- return nil, fmt.Errorf("reading directory %s failed: %v", inputDir, err)
- }
- res := make([]string, 0)
- for _, f := range files {
- if strings.HasSuffix(f.Name(), inputFileExt) {
- res = append(res, inputDir+"/"+f.Name())
- }
- }
- return res, nil
-}
-
-// generateFromFile generates Go bindings from one input JSON file
-func generateFromFile(inputFile, outputDir string) error {
- ctx, err := getContext(inputFile, outputDir)
- if err != nil {
- return err
- }
- // read the file
- ctx.inputData, err = readFile(inputFile)
- if err != nil {
- return err
- }
-
- // parse JSON
- jsonRoot, err := parseJSON(ctx.inputData)
- if err != nil {
- return err
- }
-
- // create output directory
- err = os.MkdirAll(ctx.packageDir, 0777)
- if err != nil {
- return fmt.Errorf("creating output directory %s failed: %v", ctx.packageDir, err)
- }
-
- // open output file
- f, err := os.Create(ctx.outputFile)
- defer f.Close()
- if err != nil {
- return fmt.Errorf("creating output file %s failed: %v", ctx.outputFile, err)
- }
- w := bufio.NewWriter(f)
-
- // generate Go package code
- err = generatePackage(ctx, w, jsonRoot)
- if err != nil {
- return err
- }
-
- // go format the output file (non-fatal if fails)
- exec.Command("gofmt", "-w", ctx.outputFile).Run()
-
- return nil
-}
-
-// getContext returns context details of the code generation task
-func getContext(inputFile, outputDir string) (*context, error) {
- if !strings.HasSuffix(inputFile, inputFileExt) {
- return nil, fmt.Errorf("invalid input file name %s", inputFile)
- }
-
- ctx := &context{inputFile: inputFile}
- inputFileName := filepath.Base(inputFile)
-
- ctx.packageName = inputFileName[0:strings.Index(inputFileName, ".")]
- if ctx.packageName == "interface" {
- // 'interface' cannot be a package name, it is a go keyword
- ctx.packageName = "interfaces"
- }
-
- ctx.packageDir = outputDir + "/" + ctx.packageName + "/"
- ctx.outputFile = ctx.packageDir + ctx.packageName + ".go"
-
- return ctx, nil
-}
-
-// readFile reads content of a file into memory
-func readFile(inputFile string) ([]byte, error) {
-
- inputData, err := ioutil.ReadFile(inputFile)
-
- if err != nil {
- return nil, fmt.Errorf("reading data from file failed: %v", err)
- }
-
- return inputData, nil
-}
-
-// parseJSON parses a JSON data into an in-memory tree
-func parseJSON(inputData []byte) (*jsongo.JSONNode, error) {
- root := jsongo.JSONNode{}
-
- err := json.Unmarshal(inputData, &root)
- if err != nil {
- return nil, fmt.Errorf("JSON unmarshall failed: %v", err)
- }
-
- return &root, nil
-
-}
-
-// generatePackage generates Go code of a package from provided JSON
-func generatePackage(ctx *context, w *bufio.Writer, jsonRoot *jsongo.JSONNode) error {
- // generate file header
- generatePackageHeader(ctx, w, jsonRoot)
-
- // generate data types
- ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
- ctx.inputLine = 0
- ctx.types = make(map[string]string)
- types := jsonRoot.Map("types")
- for i := 0; i < types.Len(); i++ {
- typ := types.At(i)
- err := generateMessage(ctx, w, typ, true)
- if err != nil {
- return err
- }
- }
-
- // generate messages
- ctx.inputBuff = bytes.NewBuffer(ctx.inputData)
- ctx.inputLine = 0
- messages := jsonRoot.Map("messages")
- for i := 0; i < messages.Len(); i++ {
- msg := messages.At(i)
- err := generateMessage(ctx, w, msg, false)
- if err != nil {
- return err
- }
- }
-
- // flush the data:
- err := w.Flush()
- if err != nil {
- return fmt.Errorf("flushing data to %s failed: %v", ctx.outputFile, err)
- }
-
- return nil
-}
-
-// generateMessage generates Go code of one VPP message encoded in JSON into provided writer
-func generateMessage(ctx *context, w io.Writer, msg *jsongo.JSONNode, isType bool) error {
- if msg.Len() == 0 || msg.At(0).GetType() != jsongo.TypeValue {
- return errors.New("invalid JSON for message specified")
- }
-
- msgName, ok := msg.At(0).Get().(string)
- if !ok {
- return fmt.Errorf("invalid JSON for message specified, message name is %T, not a string", msg.At(0).Get())
- }
- structName := camelCaseName(strings.Title(msgName))
-
- // generate struct fields into the slice & determine message type
- fields := make([]string, 0)
- msgType := otherMessage
- wasClientIndex := false
- for j := 0; j < msg.Len(); j++ {
- if jsongo.TypeArray == msg.At(j).GetType() {
- fld := msg.At(j)
- if !isType {
- // determine whether ths is a request / reply / other message
- fieldName, ok := fld.At(1).Get().(string)
- if ok {
- if j == 2 {
- if fieldName == "client_index" {
- // "client_index" as the second member, this might be an event message or a request
- msgType = eventMessage
- wasClientIndex = true
- } else if fieldName == "context" {
- // reply needs "context" as the second member
- msgType = replyMessage
- }
- } else if j == 3 {
- if wasClientIndex && fieldName == "context" {
- // request needs "client_index" as the second member and "context" as the third member
- msgType = requestMessage
- }
- }
- }
- }
- err := processMessageField(ctx, &fields, fld, isType)
- if err != nil {
- return err
- }
- }
- }
-
- // generate struct comment
- generateMessageComment(ctx, w, structName, msgName, isType)
-
- // generate struct header
- fmt.Fprintln(w, "type", structName, "struct {")
-
- // print out the fields
- for _, field := range fields {
- fmt.Fprintln(w, field)
- }
-
- // generate end of the struct
- fmt.Fprintln(w, "}")
-
- // generate name getter
- if isType {
- generateTypeNameGetter(w, structName, msgName)
- } else {
- generateMessageNameGetter(w, structName, msgName)
- }
-
- // generate message type getter method
- if !isType {
- generateMessageTypeGetter(w, structName, msgType)
- }
-
- // generate CRC getter
- crcIf := msg.At(msg.Len() - 1).At("crc").Get()
- if crc, ok := crcIf.(string); ok {
- generateCrcGetter(w, structName, crc)
- }
-
- // generate message factory
- if !isType {
- generateMessageFactory(w, structName)
- }
-
- // if this is a type, save it in the map for later use
- if isType {
- ctx.types[fmt.Sprintf("vl_api_%s_t", msgName)] = structName
- }
-
- return nil
-}
-
-// processMessageField process JSON describing one message field into Go code emitted into provided slice of message fields
-func processMessageField(ctx *context, fields *[]string, fld *jsongo.JSONNode, isType bool) error {
- if fld.Len() < 2 || fld.At(0).GetType() != jsongo.TypeValue || fld.At(1).GetType() != jsongo.TypeValue {
- return errors.New("invalid JSON for message field specified")
- }
- fieldVppType, ok := fld.At(0).Get().(string)
- if !ok {
- return fmt.Errorf("invalid JSON for message specified, field type is %T, not a string", fld.At(0).Get())
- }
- fieldName, ok := fld.At(1).Get().(string)
- if !ok {
- return fmt.Errorf("invalid JSON for message specified, field name is %T, not a string", fld.At(1).Get())
- }
-
- // skip internal fields
- fieldNameLower := strings.ToLower(fieldName)
- if fieldNameLower == "crc" || fieldNameLower == "_vl_msg_id" {
- return nil
- }
- if !isType && len(*fields) == 0 && (fieldNameLower == "client_index" || fieldNameLower == "context") {
- return nil
- }
-
- fieldName = strings.TrimPrefix(fieldName, "_")
- fieldName = camelCaseName(strings.Title(fieldName))
-
- fieldStr := ""
- isArray := false
- arraySize := 0
-
- fieldStr += "\t" + fieldName + " "
- if fld.Len() > 2 {
- isArray = true
- arraySize = int(fld.At(2).Get().(float64))
- fieldStr += "[]"
- }
-
- dataType := translateVppType(ctx, fieldVppType, isArray)
- fieldStr += dataType
-
- if isArray {
- if arraySize == 0 {
- // variable sized array
- if fld.Len() > 3 {
- // array size is specified by another field
- arraySizeField := string(fld.At(3).Get().(string))
- arraySizeField = camelCaseName(strings.Title(arraySizeField))
- // find & update the field that specifies the array size
- for i, f := range *fields {
- if strings.Contains(f, fmt.Sprintf("\t%s ", arraySizeField)) {
- (*fields)[i] += fmt.Sprintf("\t`struc:\"sizeof=%s\"`", fieldName)
- }
- }
- }
- } else {
- // fixed size array
- fieldStr += fmt.Sprintf("\t`struc:\"[%d]%s\"`", arraySize, dataType)
- }
- }
-
- *fields = append(*fields, fieldStr)
- return nil
-}
-
-// generatePackageHeader generates package header into provider writer
-func generatePackageHeader(ctx *context, w io.Writer, rootNode *jsongo.JSONNode) {
- fmt.Fprintln(w, "// Code generated by govpp binapi-generator DO NOT EDIT.")
- fmt.Fprintln(w, "// Package "+ctx.packageName+" represents the VPP binary API of the '"+ctx.packageName+"' VPP module.")
- fmt.Fprintln(w, "// Generated from '"+ctx.inputFile+"'")
-
- fmt.Fprintln(w, "package "+ctx.packageName)
-
- fmt.Fprintln(w, "import \""+apiImportPath+"\"")
- fmt.Fprintln(w)
-
- vlAPIVersion := rootNode.Map("vl_api_version").Get()
- if *includeAPIVer {
- fmt.Fprintln(w, "// VlApiVersion contains version of the API.")
- fmt.Fprintln(w, "const VlAPIVersion = ", vlAPIVersion)
- fmt.Fprintln(w)
- }
-}
-
-// generateMessageComment generates comment for a message into provider writer
-func generateMessageComment(ctx *context, w io.Writer, structName string, msgName string, isType bool) {
- fmt.Fprintln(w)
- if isType {
- fmt.Fprintln(w, "// "+structName+" represents the VPP binary API data type '"+msgName+"'.")
- } else {
- fmt.Fprintln(w, "// "+structName+" represents the VPP binary API message '"+msgName+"'.")
- }
-
- // print out the source of the generated message - the JSON
- msgFound := false
- msgTitle := "\"" + msgName + "\","
- var msgIndent int
- for {
- lineBuff, err := ctx.inputBuff.ReadBytes('\n')
- if err != nil {
- break
- }
- ctx.inputLine++
- line := string(lineBuff)
-
- if !msgFound {
- msgIndent = strings.Index(line, msgTitle)
- if msgIndent > -1 {
- prefix := line[:msgIndent]
- suffix := line[msgIndent+len(msgTitle):]
- // If no other non-whitespace character then we are at the message header.
- if strings.IndexFunc(prefix, isNotSpace) == -1 && strings.IndexFunc(suffix, isNotSpace) == -1 {
- fmt.Fprintf(w, "// Generated from '%s', line %d:\n", ctx.inputFile, ctx.inputLine)
- fmt.Fprintln(w, "//")
- fmt.Fprint(w, "//", line)
- msgFound = true
- }
- }
- } else {
- if strings.IndexFunc(line, isNotSpace) < msgIndent {
- break // end of the message in JSON
- }
- fmt.Fprint(w, "//", line)
- }
- }
- fmt.Fprintln(w, "//")
-}
-
-// generateMessageNameGetter generates getter for original VPP message name into the provider writer
-func generateMessageNameGetter(w io.Writer, structName string, msgName string) {
- fmt.Fprintln(w, "func (*"+structName+") GetMessageName() string {")
- fmt.Fprintln(w, "\treturn \""+msgName+"\"")
- fmt.Fprintln(w, "}")
-}
-
-// generateTypeNameGetter generates getter for original VPP type name into the provider writer
-func generateTypeNameGetter(w io.Writer, structName string, msgName string) {
- fmt.Fprintln(w, "func (*"+structName+") GetTypeName() string {")
- fmt.Fprintln(w, "\treturn \""+msgName+"\"")
- fmt.Fprintln(w, "}")
-}
-
-// generateMessageTypeGetter generates message factory for the generated message into the provider writer
-func generateMessageTypeGetter(w io.Writer, structName string, msgType messageType) {
- fmt.Fprintln(w, "func (*"+structName+") GetMessageType() api.MessageType {")
- if msgType == requestMessage {
- fmt.Fprintln(w, "\treturn api.RequestMessage")
- } else if msgType == replyMessage {
- fmt.Fprintln(w, "\treturn api.ReplyMessage")
- } else if msgType == eventMessage {
- fmt.Fprintln(w, "\treturn api.EventMessage")
- } else {
- fmt.Fprintln(w, "\treturn api.OtherMessage")
- }
- fmt.Fprintln(w, "}")
-}
-
-// generateCrcGetter generates getter for CRC checksum of the message definition into the provider writer
-func generateCrcGetter(w io.Writer, structName string, crc string) {
- crc = strings.TrimPrefix(crc, "0x")
- fmt.Fprintln(w, "func (*"+structName+") GetCrcString() string {")
- fmt.Fprintln(w, "\treturn \""+crc+"\"")
- fmt.Fprintln(w, "}")
-}
-
-// generateMessageFactory generates message factory for the generated message into the provider writer
-func generateMessageFactory(w io.Writer, structName string) {
- fmt.Fprintln(w, "func New"+structName+"() api.Message {")
- fmt.Fprintln(w, "\treturn &"+structName+"{}")
- fmt.Fprintln(w, "}")
-}
-
-// translateVppType translates the VPP data type into Go data type
-func translateVppType(ctx *context, vppType string, isArray bool) string {
- // basic types
- switch vppType {
- case "u8":
- if isArray {
- return "byte"
- }
- return "uint8"
- case "i8":
- return "int8"
- case "u16":
- return "uint16"
- case "i16":
- return "int16"
- case "u32":
- return "uint32"
- case "i32":
- return "int32"
- case "u64":
- return "uint64"
- case "i64":
- return "int64"
- case "f64":
- return "float64"
- }
-
- // typedefs
- typ, ok := ctx.types[vppType]
- if ok {
- return typ
- }
-
- panic(fmt.Sprintf("Unknown VPP type %s", vppType))
-}
-
-// camelCaseName returns correct name identifier (camelCase).
-func camelCaseName(name string) (should string) {
- // Fast path for simple cases: "_" and all lowercase.
- if name == "_" {
- return name
- }
- allLower := true
- for _, r := range name {
- if !unicode.IsLower(r) {
- allLower = false
- break
- }
- }
- if allLower {
- return name
- }
-
- // Split camelCase at any lower->upper transition, and split on underscores.
- // Check each word for common initialisms.
- runes := []rune(name)
- w, i := 0, 0 // index of start of word, scan
- for i+1 <= len(runes) {
- eow := false // whether we hit the end of a word
- if i+1 == len(runes) {
- eow = true
- } else if runes[i+1] == '_' {
- // underscore; shift the remainder forward over any run of underscores
- eow = true
- n := 1
- for i+n+1 < len(runes) && runes[i+n+1] == '_' {
- n++
- }
-
- // Leave at most one underscore if the underscore is between two digits
- if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) {
- n--
- }
-
- copy(runes[i+1:], runes[i+n+1:])
- runes = runes[:len(runes)-n]
- } else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) {
- // lower->non-lower
- eow = true
- }
- i++
- if !eow {
- continue
- }
-
- // [w,i) is a word.
- word := string(runes[w:i])
- if u := strings.ToUpper(word); commonInitialisms[u] {
- // Keep consistent case, which is lowercase only at the start.
- if w == 0 && unicode.IsLower(runes[w]) {
- u = strings.ToLower(u)
- }
- // All the common initialisms are ASCII,
- // so we can replace the bytes exactly.
- copy(runes[w:], []rune(u))
- } else if w > 0 && strings.ToLower(word) == word {
- // already all lowercase, and not the first word, so uppercase the first character.
- runes[w] = unicode.ToUpper(runes[w])
- }
- w = i
- }
- return string(runes)
-}
-
-// isNotSpace returns true if the rune is NOT a whitespace character.
-func isNotSpace(r rune) bool {
- return !unicode.IsSpace(r)
-}
-
-// commonInitialisms is a set of common initialisms that need to stay in upper case.
-var commonInitialisms = map[string]bool{
- "ACL": true,
- "API": true,
- "ASCII": true,
- "CPU": true,
- "CSS": true,
- "DNS": true,
- "EOF": true,
- "GUID": true,
- "HTML": true,
- "HTTP": true,
- "HTTPS": true,
- "ID": true,
- "IP": true,
- "ICMP": true,
- "JSON": true,
- "LHS": true,
- "QPS": true,
- "RAM": true,
- "RHS": true,
- "RPC": true,
- "SLA": true,
- "SMTP": true,
- "SQL": true,
- "SSH": true,
- "TCP": true,
- "TLS": true,
- "TTL": true,
- "UDP": true,
- "UI": true,
- "UID": true,
- "UUID": true,
- "URI": true,
- "URL": true,
- "UTF8": true,
- "VM": true,
- "XML": true,
- "XMPP": true,
- "XSRF": true,
- "XSS": true,
-}
--- /dev/null
+// Copyright (c) 2018 Cisco and/or its affiliates.
+//
+// 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 (
+ "bufio"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+
+ "github.com/bennyscetbun/jsongo"
+)
+
+var (
+ inputFile = flag.String("input-file", "", "Input JSON file.")
+ inputDir = flag.String("input-dir", ".", "Input directory with JSON files.")
+ outputDir = flag.String("output-dir", ".", "Output directory where package folders will be generated.")
+ includeAPIVer = flag.Bool("include-apiver", false, "Whether to include VlAPIVersion in generated file.")
+ debug = flag.Bool("debug", false, "Turn on debug mode.")
+ continueOnError = flag.Bool("continue-onerror", false, "Wheter to continue with next file on error.")
+)
+
+func logf(f string, v ...interface{}) {
+ if *debug {
+ log.Printf(f, v...)
+ }
+}
+
+func main() {
+ flag.Parse()
+
+ if *inputFile == "" && *inputDir == "" {
+ fmt.Fprintln(os.Stderr, "ERROR: input-file or input-dir must be specified")
+ os.Exit(1)
+ }
+
+ if *inputFile != "" {
+ // process one input file
+ if err := generateFromFile(*inputFile, *outputDir); err != nil {
+ fmt.Fprintf(os.Stderr, "ERROR: code generation from %s failed: %v\n", *inputFile, err)
+ os.Exit(1)
+ }
+ } else {
+ // process all files in specified directory
+ files, err := getInputFiles(*inputDir)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "ERROR: code generation failed: %v\n", err)
+ os.Exit(1)
+ }
+ for _, file := range files {
+ if err := generateFromFile(file, *outputDir); err != nil {
+ fmt.Fprintf(os.Stderr, "ERROR: code generation from %s failed: %v\n", file, err)
+ if *continueOnError {
+ continue
+ }
+ os.Exit(1)
+ }
+ }
+ }
+}
+
+// getInputFiles returns all input files located in specified directory
+func getInputFiles(inputDir string) (res []string, err error) {
+ files, err := ioutil.ReadDir(inputDir)
+ if err != nil {
+ return nil, fmt.Errorf("reading directory %s failed: %v", inputDir, err)
+ }
+ for _, f := range files {
+ if strings.HasSuffix(f.Name(), inputFileExt) {
+ res = append(res, filepath.Join(inputDir, f.Name()))
+ }
+ }
+ return res, nil
+}
+
+// generateFromFile generates Go package from one input JSON file
+func generateFromFile(inputFile, outputDir string) error {
+ logf("generating from file: %q", inputFile)
+ defer logf("--------------------------------------")
+
+ ctx, err := getContext(inputFile, outputDir)
+ if err != nil {
+ return err
+ }
+
+ // read input file contents
+ ctx.inputData, err = readFile(inputFile)
+ if err != nil {
+ return err
+ }
+ // parse JSON data into objects
+ jsonRoot, err := parseJSON(ctx.inputData)
+ if err != nil {
+ return err
+ }
+ ctx.packageData, err = parsePackage(ctx, jsonRoot)
+ if err != nil {
+ return err
+ }
+
+ // create output directory
+ packageDir := filepath.Dir(ctx.outputFile)
+ if err := os.MkdirAll(packageDir, 0777); err != nil {
+ return fmt.Errorf("creating output directory %q failed: %v", packageDir, err)
+ }
+ // open output file
+ f, err := os.Create(ctx.outputFile)
+ if err != nil {
+ return fmt.Errorf("creating output file %q failed: %v", ctx.outputFile, err)
+ }
+ defer f.Close()
+
+ // generate Go package code
+ w := bufio.NewWriter(f)
+ if err := generatePackage(ctx, w); err != nil {
+ return err
+ }
+
+ // go format the output file (fail probably means the output is not compilable)
+ cmd := exec.Command("gofmt", "-w", ctx.outputFile)
+ if output, err := cmd.CombinedOutput(); err != nil {
+ return fmt.Errorf("gofmt failed: %v\n%s", err, string(output))
+ }
+
+ // count number of lines in generated output file
+ cmd = exec.Command("wc", "-l", ctx.outputFile)
+ if output, err := cmd.CombinedOutput(); err != nil {
+ log.Printf("wc command failed: %v\n%s", err, string(output))
+ } else {
+ logf("generated lines: %s", output)
+ }
+
+ return nil
+}
+
+// readFile reads content of a file into memory
+func readFile(inputFile string) ([]byte, error) {
+ inputData, err := ioutil.ReadFile(inputFile)
+ if err != nil {
+ return nil, fmt.Errorf("reading data from file failed: %v", err)
+ }
+
+ return inputData, nil
+}
+
+// parseJSON parses a JSON data into an in-memory tree
+func parseJSON(inputData []byte) (*jsongo.JSONNode, error) {
+ root := jsongo.JSONNode{}
+
+ if err := json.Unmarshal(inputData, &root); err != nil {
+ return nil, fmt.Errorf("unmarshalling JSON failed: %v", err)
+ }
+
+ return &root, nil
+}
--- /dev/null
+// Copyright (c) 2018 Cisco and/or its affiliates.
+//
+// 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 (
+ "errors"
+ "fmt"
+ "log"
+ "sort"
+ "strings"
+
+ "github.com/bennyscetbun/jsongo"
+)
+
+// Package represents collection of objects parsed from VPP binary API JSON data
+type Package struct {
+ APIVersion string
+ Enums []Enum
+ Unions []Union
+ Types []Type
+ Messages []Message
+ Services []Service
+ RefMap map[string]string
+}
+
+// MessageType represents the type of a VPP message
+type MessageType int
+
+const (
+ requestMessage MessageType = iota // VPP request message
+ replyMessage // VPP reply message
+ eventMessage // VPP event message
+ otherMessage // other VPP message
+)
+
+// Message represents VPP binary API message
+type Message struct {
+ Name string
+ CRC string
+ Fields []Field
+}
+
+// Type represents VPP binary API type
+type Type struct {
+ Name string
+ CRC string
+ Fields []Field
+}
+
+// Union represents VPP binary API union
+type Union struct {
+ Name string
+ CRC string
+ Fields []Field
+}
+
+// Field represents VPP binary API object field
+type Field struct {
+ Name string
+ Type string
+ Length int
+ SizeFrom string
+}
+
+func (f *Field) IsArray() bool {
+ return f.Length > 0 || f.SizeFrom != ""
+}
+
+// Enum represents VPP binary API enum
+type Enum struct {
+ Name string
+ Type string
+ Entries []EnumEntry
+}
+
+// EnumEntry represents VPP binary API enum entry
+type EnumEntry struct {
+ Name string
+ Value interface{}
+}
+
+// Service represents VPP binary API service
+type Service struct {
+ RequestType string
+ ReplyType string
+ Stream bool
+ Events []string
+}
+
+func getSizeOfType(typ *Type) (size int) {
+ for _, field := range typ.Fields {
+ if n := getBinapiTypeSize(field.Type); n > 0 {
+ if field.Length > 0 {
+ size += n * field.Length
+ } else {
+ size += n
+ }
+ }
+ }
+ return size
+}
+
+func getTypeByRef(ctx *context, ref string) *Type {
+ for _, typ := range ctx.packageData.Types {
+ if ref == toApiType(typ.Name) {
+ return &typ
+ }
+ }
+ return nil
+}
+
+func getUnionSize(ctx *context, union *Union) (maxSize int) {
+ for _, field := range union.Fields {
+ if typ := getTypeByRef(ctx, field.Type); typ != nil {
+ if size := getSizeOfType(typ); size > maxSize {
+ maxSize = size
+ }
+ }
+ }
+ return
+}
+
+// toApiType returns name that is used as type reference in VPP binary API
+func toApiType(name string) string {
+ return fmt.Sprintf("vl_api_%s_t", name)
+}
+
+// parsePackage parses provided JSON data into objects prepared for code generation
+func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
+ logf(" %s contains: %d services, %d messages, %d types, %d enums, %d unions (version: %s)",
+ ctx.packageName,
+ jsonRoot.Map("services").Len(),
+ jsonRoot.Map("messages").Len(),
+ jsonRoot.Map("types").Len(),
+ jsonRoot.Map("enums").Len(),
+ jsonRoot.Map("unions").Len(),
+ jsonRoot.Map("vl_api_version").Get(),
+ )
+
+ pkg := Package{
+ APIVersion: jsonRoot.Map("vl_api_version").Get().(string),
+ RefMap: make(map[string]string),
+ }
+
+ // parse enums
+ enums := jsonRoot.Map("enums")
+ pkg.Enums = make([]Enum, enums.Len())
+ for i := 0; i < enums.Len(); i++ {
+ enumNode := enums.At(i)
+
+ enum, err := parseEnum(ctx, enumNode)
+ if err != nil {
+ return nil, err
+ }
+ pkg.Enums[i] = *enum
+ pkg.RefMap[toApiType(enum.Name)] = enum.Name
+ }
+
+ // parse types
+ types := jsonRoot.Map("types")
+ pkg.Types = make([]Type, types.Len())
+ for i := 0; i < types.Len(); i++ {
+ typNode := types.At(i)
+
+ typ, err := parseType(ctx, typNode)
+ if err != nil {
+ return nil, err
+ }
+ pkg.Types[i] = *typ
+ pkg.RefMap[toApiType(typ.Name)] = typ.Name
+ }
+
+ // parse unions
+ unions := jsonRoot.Map("unions")
+ pkg.Unions = make([]Union, unions.Len())
+ for i := 0; i < unions.Len(); i++ {
+ unionNode := unions.At(i)
+
+ union, err := parseUnion(ctx, unionNode)
+ if err != nil {
+ return nil, err
+ }
+ pkg.Unions[i] = *union
+ pkg.RefMap[toApiType(union.Name)] = union.Name
+ }
+
+ // parse messages
+ messages := jsonRoot.Map("messages")
+ pkg.Messages = make([]Message, messages.Len())
+ for i := 0; i < messages.Len(); i++ {
+ msgNode := messages.At(i)
+
+ msg, err := parseMessage(ctx, msgNode)
+ if err != nil {
+ return nil, err
+ }
+ pkg.Messages[i] = *msg
+ }
+
+ // parse services
+ services := jsonRoot.Map("services")
+ if services.GetType() == jsongo.TypeMap {
+ pkg.Services = make([]Service, services.Len())
+ for i, key := range services.GetKeys() {
+ svcNode := services.At(key)
+
+ svc, err := parseService(ctx, key.(string), svcNode)
+ if err != nil {
+ return nil, err
+ }
+ pkg.Services[i] = *svc
+ }
+
+ // sort services
+ sort.Slice(pkg.Services, func(i, j int) bool {
+ // dumps first
+ if pkg.Services[i].Stream != pkg.Services[j].Stream {
+ return pkg.Services[i].Stream
+ }
+ return pkg.Services[i].RequestType < pkg.Services[j].RequestType
+ })
+ }
+
+ printPackage(&pkg)
+
+ return &pkg, nil
+}
+
+// printPackage prints all loaded objects for package
+func printPackage(pkg *Package) {
+ if len(pkg.Enums) > 0 {
+ logf("loaded %d enums:", len(pkg.Enums))
+ for k, enum := range pkg.Enums {
+ logf(" - enum #%d\t%+v", k, enum)
+ }
+ }
+ if len(pkg.Unions) > 0 {
+ logf("loaded %d unions:", len(pkg.Unions))
+ for k, union := range pkg.Unions {
+ logf(" - union #%d\t%+v", k, union)
+ }
+ }
+ if len(pkg.Types) > 0 {
+ logf("loaded %d types:", len(pkg.Types))
+ for _, typ := range pkg.Types {
+ logf(" - type: %q (%d fields)", typ.Name, len(typ.Fields))
+ }
+ }
+ if len(pkg.Messages) > 0 {
+ logf("loaded %d messages:", len(pkg.Messages))
+ for _, msg := range pkg.Messages {
+ logf(" - message: %q (%d fields)", msg.Name, len(msg.Fields))
+ }
+ }
+ if len(pkg.Services) > 0 {
+ logf("loaded %d services:", len(pkg.Services))
+ for _, svc := range pkg.Services {
+ var info string
+ if svc.Stream {
+ info = "(STREAM)"
+ } else if len(svc.Events) > 0 {
+ info = fmt.Sprintf("(EVENTS: %v)", svc.Events)
+ }
+ logf(" - service: %q -> %q %s", svc.RequestType, svc.ReplyType, info)
+ }
+ }
+}
+
+// parseEnum parses VPP binary API enum object from JSON node
+func parseEnum(ctx *context, enumNode *jsongo.JSONNode) (*Enum, error) {
+ if enumNode.Len() == 0 || enumNode.At(0).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for enum specified")
+ }
+
+ enumName, ok := enumNode.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("enum name is %T, not a string", enumNode.At(0).Get())
+ }
+ enumType, ok := enumNode.At(enumNode.Len() - 1).At("enumtype").Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("enum type invalid or missing")
+ }
+
+ enum := Enum{
+ Name: enumName,
+ Type: enumType,
+ }
+
+ // loop through enum entries, skip first (name) and last (enumtype)
+ for j := 1; j < enumNode.Len()-1; j++ {
+ if enumNode.At(j).GetType() == jsongo.TypeArray {
+ entry := enumNode.At(j)
+
+ if entry.Len() < 2 || entry.At(0).GetType() != jsongo.TypeValue || entry.At(1).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for enum entry specified")
+ }
+
+ entryName, ok := entry.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("enum entry name is %T, not a string", entry.At(0).Get())
+ }
+ entryVal := entry.At(1).Get()
+
+ enum.Entries = append(enum.Entries, EnumEntry{
+ Name: entryName,
+ Value: entryVal,
+ })
+ }
+ }
+
+ return &enum, nil
+}
+
+// parseUnion parses VPP binary API union object from JSON node
+func parseUnion(ctx *context, unionNode *jsongo.JSONNode) (*Union, error) {
+ if unionNode.Len() == 0 || unionNode.At(0).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for union specified")
+ }
+
+ unionName, ok := unionNode.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("union name is %T, not a string", unionNode.At(0).Get())
+ }
+ unionCRC, ok := unionNode.At(unionNode.Len() - 1).At("crc").Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("union crc invalid or missing")
+ }
+
+ union := Union{
+ Name: unionName,
+ CRC: unionCRC,
+ }
+
+ // loop through union fields, skip first (name) and last (crc)
+ for j := 1; j < unionNode.Len()-1; j++ {
+ if unionNode.At(j).GetType() == jsongo.TypeArray {
+ fieldNode := unionNode.At(j)
+
+ field, err := parseField(ctx, fieldNode)
+ if err != nil {
+ return nil, err
+ }
+
+ union.Fields = append(union.Fields, *field)
+ }
+ }
+
+ return &union, nil
+}
+
+// parseType parses VPP binary API type object from JSON node
+func parseType(ctx *context, typeNode *jsongo.JSONNode) (*Type, error) {
+ if typeNode.Len() == 0 || typeNode.At(0).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for type specified")
+ }
+
+ typeName, ok := typeNode.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("type name is %T, not a string", typeNode.At(0).Get())
+ }
+ typeCRC, ok := typeNode.At(typeNode.Len() - 1).At("crc").Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("type crc invalid or missing")
+ }
+
+ typ := Type{
+ Name: typeName,
+ CRC: typeCRC,
+ }
+
+ // loop through type fields, skip first (name) and last (crc)
+ for j := 1; j < typeNode.Len()-1; j++ {
+ if typeNode.At(j).GetType() == jsongo.TypeArray {
+ fieldNode := typeNode.At(j)
+
+ field, err := parseField(ctx, fieldNode)
+ if err != nil {
+ return nil, err
+ }
+
+ typ.Fields = append(typ.Fields, *field)
+ }
+ }
+
+ return &typ, nil
+}
+
+// parseMessage parses VPP binary API message object from JSON node
+func parseMessage(ctx *context, msgNode *jsongo.JSONNode) (*Message, error) {
+ if msgNode.Len() == 0 || msgNode.At(0).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for message specified")
+ }
+
+ msgName, ok := msgNode.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("message name is %T, not a string", msgNode.At(0).Get())
+ }
+ msgCRC, ok := msgNode.At(msgNode.Len() - 1).At("crc").Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("message crc invalid or missing")
+ }
+
+ msg := Message{
+ Name: msgName,
+ CRC: msgCRC,
+ }
+
+ // loop through message fields, skip first (name) and last (crc)
+ for j := 1; j < msgNode.Len()-1; j++ {
+ if msgNode.At(j).GetType() == jsongo.TypeArray {
+ fieldNode := msgNode.At(j)
+
+ field, err := parseField(ctx, fieldNode)
+ if err != nil {
+ return nil, err
+ }
+
+ msg.Fields = append(msg.Fields, *field)
+ }
+ }
+
+ return &msg, nil
+}
+
+// parseField parses VPP binary API object field from JSON node
+func parseField(ctx *context, field *jsongo.JSONNode) (*Field, error) {
+ if field.Len() < 2 || field.At(0).GetType() != jsongo.TypeValue || field.At(1).GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for field specified")
+ }
+
+ fieldType, ok := field.At(0).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("field type is %T, not a string", field.At(0).Get())
+ }
+ fieldName, ok := field.At(1).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("field name is %T, not a string", field.At(1).Get())
+ }
+ var fieldLength float64
+ if field.Len() >= 3 {
+ fieldLength, ok = field.At(2).Get().(float64)
+ if !ok {
+ return nil, fmt.Errorf("field length is %T, not an int", field.At(2).Get())
+ }
+ }
+ var fieldLengthFrom string
+ if field.Len() >= 4 {
+ fieldLengthFrom, ok = field.At(3).Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("field length from is %T, not a string", field.At(3).Get())
+ }
+ }
+
+ return &Field{
+ Name: fieldName,
+ Type: fieldType,
+ Length: int(fieldLength),
+ SizeFrom: fieldLengthFrom,
+ }, nil
+}
+
+// parseService parses VPP binary API service object from JSON node
+func parseService(ctx *context, svcName string, svcNode *jsongo.JSONNode) (*Service, error) {
+ if svcNode.Len() == 0 || svcNode.At("reply").GetType() != jsongo.TypeValue {
+ return nil, errors.New("invalid JSON for service specified")
+ }
+
+ svc := Service{
+ RequestType: svcName,
+ }
+
+ if replyNode := svcNode.At("reply"); replyNode.GetType() == jsongo.TypeValue {
+ reply, ok := replyNode.Get().(string)
+ if !ok {
+ return nil, fmt.Errorf("service reply is %T, not a string", replyNode.Get())
+ }
+ // some binapi messages might have `null` reply (for example: memclnt)
+ if reply != "null" {
+ svc.ReplyType = reply
+ }
+ }
+
+ // stream service (dumps)
+ if streamNode := svcNode.At("stream"); streamNode.GetType() == jsongo.TypeValue {
+ var ok bool
+ svc.Stream, ok = streamNode.Get().(bool)
+ if !ok {
+ return nil, fmt.Errorf("service stream is %T, not a string", streamNode.Get())
+ }
+ }
+
+ // events service (event subscription)
+ if eventsNode := svcNode.At("events"); eventsNode.GetType() == jsongo.TypeArray {
+ for j := 0; j < eventsNode.Len(); j++ {
+ event := eventsNode.At(j).Get().(string)
+ svc.Events = append(svc.Events, event)
+ }
+ }
+
+ // validate service
+ if svc.Stream {
+ if !strings.HasSuffix(svc.RequestType, "_dump") ||
+ !strings.HasSuffix(svc.ReplyType, "_details") {
+ fmt.Printf("Invalid STREAM SERVICE: %+v\n", svc)
+ }
+ } else if len(svc.Events) > 0 {
+ if (!strings.HasSuffix(svc.RequestType, "_events") &&
+ !strings.HasSuffix(svc.RequestType, "_stats")) ||
+ !strings.HasSuffix(svc.ReplyType, "_reply") {
+ fmt.Printf("Invalid EVENTS SERVICE: %+v\n", svc)
+ }
+ } else if svc.ReplyType != "" {
+ if !strings.HasSuffix(svc.ReplyType, "_reply") {
+ fmt.Printf("Invalid SERVICE: %+v\n", svc)
+ }
+ }
+
+ return &svc, nil
+}
+
+// convertToGoType translates the VPP binary API type into Go type
+func convertToGoType(ctx *context, binapiType string) (typ string) {
+ if t, ok := binapiTypes[binapiType]; ok {
+ // basic types
+ typ = t
+ } else if r, ok := ctx.packageData.RefMap[binapiType]; ok {
+ // specific types (enums/types/unions)
+ typ = camelCaseName(r)
+ } else {
+ // fallback type
+ log.Printf("found unknown VPP binary API type %q, using byte", binapiType)
+ typ = "byte"
+ }
+ return typ
+}
--- /dev/null
+package main
+
+import (
+ "testing"
+)
+
+func TestBinapiTypeSizes(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ expsize int
+ }{
+ {name: "basic1", input: "u8", expsize: 1},
+ {name: "basic2", input: "i8", expsize: 1},
+ {name: "basic3", input: "u16", expsize: 2},
+ {name: "basic4", input: "i32", expsize: 4},
+ {name: "invalid1", input: "x", expsize: -1},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ size := getBinapiTypeSize(test.input)
+ if size != test.expsize {
+ t.Errorf("expected %d, got %d", test.expsize, size)
+ }
+ })
+ }
+}
+
+func TestSizeOfType(t *testing.T) {
+ tests := []struct {
+ name string
+ input Type
+ expsize int
+ }{
+ {name: "basic1",
+ input: Type{Fields: []Field{
+ {Type: "u8"},
+ }},
+ expsize: 1,
+ },
+ {name: "basic2",
+ input: Type{Fields: []Field{
+ {Type: "u8", Length: 4},
+ }},
+ expsize: 4,
+ },
+ {name: "basic3",
+ input: Type{Fields: []Field{
+ {Type: "u8", Length: 16},
+ }},
+ expsize: 16,
+ },
+ {name: "invalid1",
+ input: Type{Fields: []Field{
+ {Type: "x", Length: 16},
+ }},
+ expsize: 0,
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ size := getSizeOfType(&test.input)
+ if size != test.expsize {
+ t.Errorf("expected %d, got %d", test.expsize, size)
+ }
+ })
+ }
+}
// VppEventHeader struct contains header fields implemented by all VPP events.
type VppEventHeader struct {
- VlMsgID uint16
- Context uint32
+ VlMsgID uint16
+ ClientIndex uint32
}
// VppOtherHeader struct contains header fields implemented by other VPP messages (not requests nor replies).
VlMsgID uint16
}
-const (
- vppRequestHeaderSize = 10 // size of a VPP request header
- vppReplyHeaderSize = 6 // size of a VPP reply header
- vppEventHeaderSize = 6 // size of a VPP event header
- vppOtherHeaderSize = 2 // size of the header of other VPP messages
-)
-
// EncodeMsg encodes provided `Message` structure into its binary-encoded data representation.
func (*MsgCodec) EncodeMsg(msg api.Message, msgID uint16) ([]byte, error) {
if msg == nil {
return nil, errors.New("nil message passed in")
}
- buf := new(bytes.Buffer)
-
// encode message header
var header interface{}
- if msg.GetMessageType() == api.RequestMessage {
+ switch msg.GetMessageType() {
+ case api.RequestMessage:
header = &VppRequestHeader{VlMsgID: msgID}
- } else if msg.GetMessageType() == api.ReplyMessage {
+ case api.ReplyMessage:
header = &VppReplyHeader{VlMsgID: msgID}
- } else if msg.GetMessageType() == api.EventMessage {
+ case api.EventMessage:
header = &VppEventHeader{VlMsgID: msgID}
- } else {
+ default:
header = &VppOtherHeader{VlMsgID: msgID}
}
- err := struc.Pack(buf, header)
- if err != nil {
- return nil, fmt.Errorf("unable to encode message: header: %v, error %v", header, err)
+
+ buf := new(bytes.Buffer)
+
+ // encode message header
+ if err := struc.Pack(buf, header); err != nil {
+ return nil, fmt.Errorf("unable to encode message header: %v, error %v", header, err)
}
// encode message content
- if reflect.Indirect(reflect.ValueOf(msg)).NumField() > 0 {
- err := struc.Pack(buf, msg)
- if err != nil {
- return nil, fmt.Errorf("unable to encode message: header %v, error %v", header, err)
+ if reflect.TypeOf(msg).Elem().NumField() > 0 {
+ if err := struc.Pack(buf, msg); err != nil {
+ return nil, fmt.Errorf("unable to encode message data: %v, error %v", header, err)
}
}
return errors.New("nil message passed in")
}
- buf := bytes.NewReader(data)
-
// check which header is expected
var header interface{}
- if msg.GetMessageType() == api.RequestMessage {
- header = &VppRequestHeader{}
- } else if msg.GetMessageType() == api.ReplyMessage {
- header = &VppReplyHeader{}
- } else if msg.GetMessageType() == api.EventMessage {
- header = &VppEventHeader{}
- } else {
- header = &VppOtherHeader{}
+ switch msg.GetMessageType() {
+ case api.RequestMessage:
+ header = new(VppRequestHeader)
+ case api.ReplyMessage:
+ header = new(VppReplyHeader)
+ case api.EventMessage:
+ header = new(VppEventHeader)
+ default:
+ header = new(VppOtherHeader)
}
- // decode message header
- err := struc.Unpack(buf, header)
- if err != nil {
- return fmt.Errorf("unable to decode message: data %v, error %v", data, err)
- }
+ buf := bytes.NewReader(data)
- // get rid of the message header
- if msg.GetMessageType() == api.RequestMessage {
- buf = bytes.NewReader(data[vppRequestHeaderSize:])
- } else if msg.GetMessageType() == api.ReplyMessage {
- buf = bytes.NewReader(data[vppReplyHeaderSize:])
- } else if msg.GetMessageType() == api.EventMessage {
- buf = bytes.NewReader(data[vppEventHeaderSize:])
- } else {
- buf = bytes.NewReader(data[vppOtherHeaderSize:])
+ // decode message header
+ if err := struc.Unpack(buf, header); err != nil {
+ return fmt.Errorf("unable to decode message header: %+v, error %v", data, err)
}
// decode message content
- err = struc.Unpack(buf, msg)
- if err != nil {
- return fmt.Errorf("unable to decode message: data %v, error %v", data, err)
+ if err := struc.Unpack(buf, msg); err != nil {
+ return fmt.Errorf("unable to decode message data: %+v, error %v", data, err)
}
return nil
}
+
+func (*MsgCodec) DecodeMsgContext(data []byte, msg api.Message) (uint32, error) {
+ if msg == nil {
+ return 0, errors.New("nil message passed in")
+ }
+
+ var getContext func() uint32
+
+ // check which header is expected
+ var header interface{}
+ switch msg.GetMessageType() {
+ case api.RequestMessage:
+ header = new(VppRequestHeader)
+ getContext = func() uint32 { return header.(*VppRequestHeader).Context }
+ case api.ReplyMessage:
+ header = new(VppReplyHeader)
+ getContext = func() uint32 { return header.(*VppReplyHeader).Context }
+ default:
+ return 0, nil
+ }
+
+ buf := bytes.NewReader(data)
+
+ // decode message header
+ if err := struc.Unpack(buf, header); err != nil {
+ return 0, fmt.Errorf("decoding message header failed: %v", err)
+ }
+
+ return getContext(), nil
+}
+++ /dev/null
-{
- "services": [
- {
- "cli_inband": {
- "reply": "cli_inband_reply"
- }
- },
- {
- "get_node_index": {
- "reply": "get_node_index_reply"
- }
- },
- {
- "cli": {
- "reply": "cli_reply"
- }
- },
- {
- "show_version": {
- "reply": "show_version_reply"
- }
- },
- {
- "get_next_index": {
- "reply": "get_next_index_reply"
- }
- },
- {
- "add_node_next": {
- "reply": "add_node_next_reply"
- }
- },
- {
- "get_node_graph": {
- "reply": "get_node_graph_reply"
- }
- },
- {
- "control_ping": {
- "reply": "control_ping_reply"
- }
- }
- ],
- "vl_api_version": "0xe02a02b0",
- "enums": [],
- "messages": [
- [
- "control_ping",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- {
- "crc": "0x51077d14"
- }
- ],
- [
- "control_ping_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "vpe_pid"
- ],
- {
- "crc": "0xf6b0b8ca"
- }
- ],
- [
- "cli",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- [
- "u64",
- "cmd_in_shmem"
- ],
- {
- "crc": "0x23bfbfff"
- }
- ],
- [
- "cli_inband",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- [
- "u32",
- "length"
- ],
- [
- "u8",
- "cmd",
- 0,
- "length"
- ],
- {
- "crc": "0x74e00a49"
- }
- ],
- [
- "cli_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u64",
- "reply_in_shmem"
- ],
- {
- "crc": "0x06d68297"
- }
- ],
- [
- "cli_inband_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u32",
- "length"
- ],
- [
- "u8",
- "reply",
- 0,
- "length"
- ],
- {
- "crc": "0x1f22bbb8"
- }
- ],
- [
- "get_node_index",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- [
- "u8",
- "node_name",
- 64
- ],
- {
- "crc": "0x6c9a495d"
- }
- ],
- [
- "get_node_index_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u32",
- "node_index"
- ],
- {
- "crc": "0xa8600b89"
- }
- ],
- [
- "add_node_next",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- [
- "u8",
- "node_name",
- 64
- ],
- [
- "u8",
- "next_name",
- 64
- ],
- {
- "crc": "0x9ab92f7a"
- }
- ],
- [
- "add_node_next_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u32",
- "next_index"
- ],
- {
- "crc": "0x2ed75f32"
- }
- ],
- [
- "show_version",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- {
- "crc": "0x51077d14"
- }
- ],
- [
- "show_version_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u8",
- "program",
- 32
- ],
- [
- "u8",
- "version",
- 32
- ],
- [
- "u8",
- "build_date",
- 32
- ],
- [
- "u8",
- "build_directory",
- 256
- ],
- {
- "crc": "0x8b5a13b4"
- }
- ],
- [
- "get_node_graph",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- {
- "crc": "0x51077d14"
- }
- ],
- [
- "get_node_graph_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u64",
- "reply_in_shmem"
- ],
- {
- "crc": "0x06d68297"
- }
- ],
- [
- "get_next_index",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "client_index"
- ],
- [
- "u32",
- "context"
- ],
- [
- "u8",
- "node_name",
- 64
- ],
- [
- "u8",
- "next_name",
- 64
- ],
- {
- "crc": "0x9ab92f7a"
- }
- ],
- [
- "get_next_index_reply",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u32",
- "context"
- ],
- [
- "i32",
- "retval"
- ],
- [
- "u32",
- "next_index"
- ],
- {
- "crc": "0x2ed75f32"
- }
- ]
- ],
- "types": []
-}
+++ /dev/null
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package vpe represents the VPP binary API of the 'vpe' VPP module.
-// Generated from 'bin_api/vpe.api.json'
-package vpe
-
-import "git.fd.io/govpp.git/api"
-
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0xe02a02b0
-
-// ControlPing represents the VPP binary API message 'control_ping'.
-// Generated from 'bin_api/vpe.api.json', line 48:
-//
-// "control_ping",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// {
-// "crc": "0x51077d14"
-// }
-//
-type ControlPing struct {
-}
-
-func (*ControlPing) GetMessageName() string {
- return "control_ping"
-}
-func (*ControlPing) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*ControlPing) GetCrcString() string {
- return "51077d14"
-}
-func NewControlPing() api.Message {
- return &ControlPing{}
-}
-
-// ControlPingReply represents the VPP binary API message 'control_ping_reply'.
-// Generated from 'bin_api/vpe.api.json', line 66:
-//
-// "control_ping_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "vpe_pid"
-// ],
-// {
-// "crc": "0xf6b0b8ca"
-// }
-//
-type ControlPingReply struct {
- Retval int32
- ClientIndex uint32
- VpePid uint32
-}
-
-func (*ControlPingReply) GetMessageName() string {
- return "control_ping_reply"
-}
-func (*ControlPingReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*ControlPingReply) GetCrcString() string {
- return "f6b0b8ca"
-}
-func NewControlPingReply() api.Message {
- return &ControlPingReply{}
-}
-
-// Cli represents the VPP binary API message 'cli'.
-// Generated from 'bin_api/vpe.api.json', line 92:
-//
-// "cli",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u64",
-// "cmd_in_shmem"
-// ],
-// {
-// "crc": "0x23bfbfff"
-// }
-//
-type Cli struct {
- CmdInShmem uint64
-}
-
-func (*Cli) GetMessageName() string {
- return "cli"
-}
-func (*Cli) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*Cli) GetCrcString() string {
- return "23bfbfff"
-}
-func NewCli() api.Message {
- return &Cli{}
-}
-
-// CliInband represents the VPP binary API message 'cli_inband'.
-// Generated from 'bin_api/vpe.api.json', line 114:
-//
-// "cli_inband",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u32",
-// "length"
-// ],
-// [
-// "u8",
-// "cmd",
-// 0,
-// "length"
-// ],
-// {
-// "crc": "0x74e00a49"
-// }
-//
-type CliInband struct {
- Length uint32 `struc:"sizeof=Cmd"`
- Cmd []byte
-}
-
-func (*CliInband) GetMessageName() string {
- return "cli_inband"
-}
-func (*CliInband) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*CliInband) GetCrcString() string {
- return "74e00a49"
-}
-func NewCliInband() api.Message {
- return &CliInband{}
-}
-
-// CliReply represents the VPP binary API message 'cli_reply'.
-// Generated from 'bin_api/vpe.api.json', line 142:
-//
-// "cli_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u64",
-// "reply_in_shmem"
-// ],
-// {
-// "crc": "0x06d68297"
-// }
-//
-type CliReply struct {
- Retval int32
- ReplyInShmem uint64
-}
-
-func (*CliReply) GetMessageName() string {
- return "cli_reply"
-}
-func (*CliReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*CliReply) GetCrcString() string {
- return "06d68297"
-}
-func NewCliReply() api.Message {
- return &CliReply{}
-}
-
-// CliInbandReply represents the VPP binary API message 'cli_inband_reply'.
-// Generated from 'bin_api/vpe.api.json', line 164:
-//
-// "cli_inband_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "length"
-// ],
-// [
-// "u8",
-// "reply",
-// 0,
-// "length"
-// ],
-// {
-// "crc": "0x1f22bbb8"
-// }
-//
-type CliInbandReply struct {
- Retval int32
- Length uint32 `struc:"sizeof=Reply"`
- Reply []byte
-}
-
-func (*CliInbandReply) GetMessageName() string {
- return "cli_inband_reply"
-}
-func (*CliInbandReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*CliInbandReply) GetCrcString() string {
- return "1f22bbb8"
-}
-func NewCliInbandReply() api.Message {
- return &CliInbandReply{}
-}
-
-// GetNodeIndex represents the VPP binary API message 'get_node_index'.
-// Generated from 'bin_api/vpe.api.json', line 192:
-//
-// "get_node_index",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u8",
-// "node_name",
-// 64
-// ],
-// {
-// "crc": "0x6c9a495d"
-// }
-//
-type GetNodeIndex struct {
- NodeName []byte `struc:"[64]byte"`
-}
-
-func (*GetNodeIndex) GetMessageName() string {
- return "get_node_index"
-}
-func (*GetNodeIndex) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*GetNodeIndex) GetCrcString() string {
- return "6c9a495d"
-}
-func NewGetNodeIndex() api.Message {
- return &GetNodeIndex{}
-}
-
-// GetNodeIndexReply represents the VPP binary API message 'get_node_index_reply'.
-// Generated from 'bin_api/vpe.api.json', line 215:
-//
-// "get_node_index_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "node_index"
-// ],
-// {
-// "crc": "0xa8600b89"
-// }
-//
-type GetNodeIndexReply struct {
- Retval int32
- NodeIndex uint32
-}
-
-func (*GetNodeIndexReply) GetMessageName() string {
- return "get_node_index_reply"
-}
-func (*GetNodeIndexReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*GetNodeIndexReply) GetCrcString() string {
- return "a8600b89"
-}
-func NewGetNodeIndexReply() api.Message {
- return &GetNodeIndexReply{}
-}
-
-// AddNodeNext represents the VPP binary API message 'add_node_next'.
-// Generated from 'bin_api/vpe.api.json', line 237:
-//
-// "add_node_next",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u8",
-// "node_name",
-// 64
-// ],
-// [
-// "u8",
-// "next_name",
-// 64
-// ],
-// {
-// "crc": "0x9ab92f7a"
-// }
-//
-type AddNodeNext struct {
- NodeName []byte `struc:"[64]byte"`
- NextName []byte `struc:"[64]byte"`
-}
-
-func (*AddNodeNext) GetMessageName() string {
- return "add_node_next"
-}
-func (*AddNodeNext) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*AddNodeNext) GetCrcString() string {
- return "9ab92f7a"
-}
-func NewAddNodeNext() api.Message {
- return &AddNodeNext{}
-}
-
-// AddNodeNextReply represents the VPP binary API message 'add_node_next_reply'.
-// Generated from 'bin_api/vpe.api.json', line 265:
-//
-// "add_node_next_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "next_index"
-// ],
-// {
-// "crc": "0x2ed75f32"
-// }
-//
-type AddNodeNextReply struct {
- Retval int32
- NextIndex uint32
-}
-
-func (*AddNodeNextReply) GetMessageName() string {
- return "add_node_next_reply"
-}
-func (*AddNodeNextReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*AddNodeNextReply) GetCrcString() string {
- return "2ed75f32"
-}
-func NewAddNodeNextReply() api.Message {
- return &AddNodeNextReply{}
-}
-
-// ShowVersion represents the VPP binary API message 'show_version'.
-// Generated from 'bin_api/vpe.api.json', line 287:
-//
-// "show_version",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// {
-// "crc": "0x51077d14"
-// }
-//
-type ShowVersion struct {
-}
-
-func (*ShowVersion) GetMessageName() string {
- return "show_version"
-}
-func (*ShowVersion) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*ShowVersion) GetCrcString() string {
- return "51077d14"
-}
-func NewShowVersion() api.Message {
- return &ShowVersion{}
-}
-
-// ShowVersionReply represents the VPP binary API message 'show_version_reply'.
-// Generated from 'bin_api/vpe.api.json', line 305:
-//
-// "show_version_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u8",
-// "program",
-// 32
-// ],
-// [
-// "u8",
-// "version",
-// 32
-// ],
-// [
-// "u8",
-// "build_date",
-// 32
-// ],
-// [
-// "u8",
-// "build_directory",
-// 256
-// ],
-// {
-// "crc": "0x8b5a13b4"
-// }
-//
-type ShowVersionReply struct {
- Retval int32
- Program []byte `struc:"[32]byte"`
- Version []byte `struc:"[32]byte"`
- BuildDate []byte `struc:"[32]byte"`
- BuildDirectory []byte `struc:"[256]byte"`
-}
-
-func (*ShowVersionReply) GetMessageName() string {
- return "show_version_reply"
-}
-func (*ShowVersionReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*ShowVersionReply) GetCrcString() string {
- return "8b5a13b4"
-}
-func NewShowVersionReply() api.Message {
- return &ShowVersionReply{}
-}
-
-// GetNodeGraph represents the VPP binary API message 'get_node_graph'.
-// Generated from 'bin_api/vpe.api.json', line 343:
-//
-// "get_node_graph",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// {
-// "crc": "0x51077d14"
-// }
-//
-type GetNodeGraph struct {
-}
-
-func (*GetNodeGraph) GetMessageName() string {
- return "get_node_graph"
-}
-func (*GetNodeGraph) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*GetNodeGraph) GetCrcString() string {
- return "51077d14"
-}
-func NewGetNodeGraph() api.Message {
- return &GetNodeGraph{}
-}
-
-// GetNodeGraphReply represents the VPP binary API message 'get_node_graph_reply'.
-// Generated from 'bin_api/vpe.api.json', line 361:
-//
-// "get_node_graph_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u64",
-// "reply_in_shmem"
-// ],
-// {
-// "crc": "0x06d68297"
-// }
-//
-type GetNodeGraphReply struct {
- Retval int32
- ReplyInShmem uint64
-}
-
-func (*GetNodeGraphReply) GetMessageName() string {
- return "get_node_graph_reply"
-}
-func (*GetNodeGraphReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*GetNodeGraphReply) GetCrcString() string {
- return "06d68297"
-}
-func NewGetNodeGraphReply() api.Message {
- return &GetNodeGraphReply{}
-}
-
-// GetNextIndex represents the VPP binary API message 'get_next_index'.
-// Generated from 'bin_api/vpe.api.json', line 383:
-//
-// "get_next_index",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u8",
-// "node_name",
-// 64
-// ],
-// [
-// "u8",
-// "next_name",
-// 64
-// ],
-// {
-// "crc": "0x9ab92f7a"
-// }
-//
-type GetNextIndex struct {
- NodeName []byte `struc:"[64]byte"`
- NextName []byte `struc:"[64]byte"`
-}
-
-func (*GetNextIndex) GetMessageName() string {
- return "get_next_index"
-}
-func (*GetNextIndex) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*GetNextIndex) GetCrcString() string {
- return "9ab92f7a"
-}
-func NewGetNextIndex() api.Message {
- return &GetNextIndex{}
-}
-
-// GetNextIndexReply represents the VPP binary API message 'get_next_index_reply'.
-// Generated from 'bin_api/vpe.api.json', line 411:
-//
-// "get_next_index_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "next_index"
-// ],
-// {
-// "crc": "0x2ed75f32"
-// }
-//
-type GetNextIndexReply struct {
- Retval int32
- NextIndex uint32
-}
-
-func (*GetNextIndexReply) GetMessageName() string {
- return "get_next_index_reply"
-}
-func (*GetNextIndexReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*GetNextIndexReply) GetCrcString() string {
- return "2ed75f32"
-}
-func NewGetNextIndexReply() api.Message {
- return &GetNextIndexReply{}
-}
package core
import (
+ "errors"
"fmt"
+ "reflect"
+ "strings"
"time"
- "errors"
-
"git.fd.io/govpp.git/api"
"github.com/sirupsen/logrus"
)
-const defaultReplyTimeout = time.Second * 1 // default timeout for replies from VPP, can be changed with SetReplyTimeout
+var (
+ ErrInvalidRequestCtx = errors.New("invalid request context")
+)
-// requestCtxData is a context of a ongoing request (simple one - only one response is expected).
-type requestCtxData struct {
+// requestCtx is a context for request with single reply
+type requestCtx struct {
ch *channel
seqNum uint16
}
-// multiRequestCtxData is a context of a ongoing multipart request (multiple responses are expected).
-type multiRequestCtxData struct {
+// multiRequestCtx is a context for request with multiple responses
+type multiRequestCtx struct {
ch *channel
seqNum uint16
}
-func (req *requestCtxData) ReceiveReply(msg api.Message) error {
+func (req *requestCtx) ReceiveReply(msg api.Message) error {
if req == nil || req.ch == nil {
- return errors.New("invalid request context")
+ return ErrInvalidRequestCtx
}
lastReplyReceived, err := req.ch.receiveReplyInternal(msg, req.seqNum)
-
+ if err != nil {
+ return err
+ }
if lastReplyReceived {
- err = errors.New("multipart reply recieved while a simple reply expected")
+ return errors.New("multipart reply recieved while a single reply expected")
}
- return err
+
+ return nil
}
-func (req *multiRequestCtxData) ReceiveReply(msg api.Message) (lastReplyReceived bool, err error) {
+func (req *multiRequestCtx) ReceiveReply(msg api.Message) (lastReplyReceived bool, err error) {
if req == nil || req.ch == nil {
- return false, errors.New("invalid request context")
+ return false, ErrInvalidRequestCtx
}
return req.ch.receiveReplyInternal(msg, req.seqNum)
}
+// vppRequest is a request that will be sent to VPP.
+type vppRequest struct {
+ seqNum uint16 // sequence number
+ msg api.Message // binary API message to be send to VPP
+ multi bool // true if multipart response is expected
+}
+
+// vppReply is a reply received from VPP.
+type vppReply struct {
+ seqNum uint16 // sequence number
+ msgID uint16 // ID of the message
+ data []byte // encoded data with the message
+ lastReceived bool // for multi request, true if the last reply has been already received
+ err error // in case of error, data is nil and this member contains error
+}
+
+// NotifSubscribeRequest is a request to subscribe for delivery of specific notification messages.
+type subscriptionRequest struct {
+ sub *api.NotifSubscription // subscription details
+ subscribe bool // true if this is a request to subscribe
+}
+
// channel is the main communication interface with govpp core. It contains four Go channels, one for sending the requests
// to VPP, one for receiving the replies from it and the same set for notifications. The user can access the Go channels
// via methods provided by Channel interface in this package. Do not use the same channel from multiple goroutines
type channel struct {
id uint16 // channel ID
- reqChan chan *api.VppRequest // channel for sending the requests to VPP, closing this channel releases all resources in the ChannelProvider
- replyChan chan *api.VppReply // channel where VPP replies are delivered to
+ reqChan chan *vppRequest // channel for sending the requests to VPP
+ replyChan chan *vppReply // channel where VPP replies are delivered to
- notifSubsChan chan *api.NotifSubscribeRequest // channel for sending notification subscribe requests
- notifSubsReplyChan chan error // channel where replies to notification subscribe requests are delivered to
+ notifSubsChan chan *subscriptionRequest // channel for sending notification subscribe requests
+ notifSubsReplyChan chan error // channel where replies to notification subscribe requests are delivered to
msgDecoder api.MessageDecoder // used to decode binary data to generated API messages
msgIdentifier api.MessageIdentifier // used to retrieve message ID of a message
lastSeqNum uint16 // sequence number of the last sent request
- delayedReply *api.VppReply // reply already taken from ReplyChan, buffered for later delivery
+ delayedReply *vppReply // reply already taken from ReplyChan, buffered for later delivery
replyTimeout time.Duration // maximum time that the API waits for a reply from VPP before returning an error, can be set with SetReplyTimeout
}
-func (ch *channel) SendRequest(msg api.Message) api.RequestCtx {
+func (ch *channel) GetID() uint16 {
+ return ch.id
+}
+
+func (ch *channel) nextSeqNum() uint16 {
ch.lastSeqNum++
- ch.reqChan <- &api.VppRequest{
- Message: msg,
- SeqNum: ch.lastSeqNum,
+ return ch.lastSeqNum
+}
+
+func (ch *channel) SendRequest(msg api.Message) api.RequestCtx {
+ req := &vppRequest{
+ msg: msg,
+ seqNum: ch.nextSeqNum(),
}
- return &requestCtxData{ch: ch, seqNum: ch.lastSeqNum}
+ ch.reqChan <- req
+ return &requestCtx{ch: ch, seqNum: req.seqNum}
}
func (ch *channel) SendMultiRequest(msg api.Message) api.MultiRequestCtx {
- ch.lastSeqNum++
- ch.reqChan <- &api.VppRequest{
- Message: msg,
- Multipart: true,
- SeqNum: ch.lastSeqNum,
+ req := &vppRequest{
+ msg: msg,
+ seqNum: ch.nextSeqNum(),
+ multi: true,
}
- return &multiRequestCtxData{ch: ch, seqNum: ch.lastSeqNum}
+ ch.reqChan <- req
+ return &multiRequestCtx{ch: ch, seqNum: req.seqNum}
}
func (ch *channel) SubscribeNotification(notifChan chan api.Message, msgFactory func() api.Message) (*api.NotifSubscription, error) {
- subscription := &api.NotifSubscription{
+ sub := &api.NotifSubscription{
NotifChan: notifChan,
MsgFactory: msgFactory,
}
- ch.notifSubsChan <- &api.NotifSubscribeRequest{
- Subscription: subscription,
- Subscribe: true,
+ // TODO: get rid of notifSubsChan and notfSubsReplyChan,
+ // it's no longer need because we know all message IDs and can store subscription right here
+ ch.notifSubsChan <- &subscriptionRequest{
+ sub: sub,
+ subscribe: true,
}
- return subscription, <-ch.notifSubsReplyChan
+ return sub, <-ch.notifSubsReplyChan
}
func (ch *channel) UnsubscribeNotification(subscription *api.NotifSubscription) error {
- ch.notifSubsChan <- &api.NotifSubscribeRequest{
- Subscription: subscription,
- Subscribe: false,
+ ch.notifSubsChan <- &subscriptionRequest{
+ sub: subscription,
+ subscribe: false,
}
return <-ch.notifSubsReplyChan
}
-func (ch *channel) CheckMessageCompatibility(messages ...api.Message) error {
- for _, msg := range messages {
- _, err := ch.msgIdentifier.GetMessageID(msg)
- if err != nil {
- return fmt.Errorf("message %s with CRC %s is not compatible with the VPP we are connected to",
- msg.GetMessageName(), msg.GetCrcString())
- }
- }
- return nil
-}
-
func (ch *channel) SetReplyTimeout(timeout time.Duration) {
ch.replyTimeout = timeout
}
-func (ch *channel) GetRequestChannel() chan<- *api.VppRequest {
- return ch.reqChan
-}
-
-func (ch *channel) GetReplyChannel() <-chan *api.VppReply {
- return ch.replyChan
-}
-
-func (ch *channel) GetNotificationChannel() chan<- *api.NotifSubscribeRequest {
- return ch.notifSubsChan
-}
-
-func (ch *channel) GetNotificationReplyChannel() <-chan error {
- return ch.notifSubsReplyChan
-}
-
-func (ch *channel) GetMessageDecoder() api.MessageDecoder {
- return ch.msgDecoder
-}
-
-func (ch *channel) GetID() uint16 {
- return ch.id
-}
-
func (ch *channel) Close() {
if ch.reqChan != nil {
close(ch.reqChan)
return false, errors.New("nil message passed in")
}
- if ch.delayedReply != nil {
+ if vppReply := ch.delayedReply; vppReply != nil {
// try the delayed reply
- vppReply := ch.delayedReply
ch.delayedReply = nil
ignore, lastReplyReceived, err = ch.processReply(vppReply, expSeqNum, msg)
if !ignore {
return
}
-func (ch *channel) processReply(reply *api.VppReply, expSeqNum uint16, msg api.Message) (ignore bool, lastReplyReceived bool, err error) {
+func (ch *channel) processReply(reply *vppReply, expSeqNum uint16, msg api.Message) (ignore bool, lastReplyReceived bool, err error) {
// check the sequence number
- cmpSeqNums := compareSeqNumbers(reply.SeqNum, expSeqNum)
+ cmpSeqNums := compareSeqNumbers(reply.seqNum, expSeqNum)
if cmpSeqNums == -1 {
// reply received too late, ignore the message
- logrus.WithField("sequence-number", reply.SeqNum).Warn(
+ logrus.WithField("sequence-number", reply.seqNum).Warn(
"Received reply to an already closed binary API request")
ignore = true
return
return
}
- if reply.Error != nil {
- err = reply.Error
+ if reply.err != nil {
+ err = reply.err
return
}
- if reply.LastReplyReceived {
+ if reply.lastReceived {
lastReplyReceived = true
return
}
return
}
- if reply.MessageID != expMsgID {
+ if reply.msgID != expMsgID {
var msgNameCrc string
- if nameCrc, err := ch.msgIdentifier.LookupByID(reply.MessageID); err != nil {
+ if replyMsg, err := ch.msgIdentifier.LookupByID(reply.msgID); err != nil {
msgNameCrc = err.Error()
} else {
- msgNameCrc = nameCrc
+ msgNameCrc = getMsgNameWithCrc(replyMsg)
}
- err = fmt.Errorf("received invalid message ID (seq-num=%d), expected %d (%s), but got %d (%s) "+
+ err = fmt.Errorf("received invalid message ID (seqNum=%d), expected %d (%s), but got %d (%s) "+
"(check if multiple goroutines are not sharing single GoVPP channel)",
- reply.SeqNum, expMsgID, msg.GetMessageName(), reply.MessageID, msgNameCrc)
+ reply.seqNum, expMsgID, msg.GetMessageName(), reply.msgID, msgNameCrc)
return
}
// decode the message
- err = ch.msgDecoder.DecodeMsg(reply.Data, msg)
- return
-}
-
-// compareSeqNumbers returns -1, 0, 1 if sequence number <seqNum1> precedes, equals to,
-// or succeeds seq. number <seqNum2>.
-// Since sequence numbers cycle in the finite set of size 2^16, the function
-// must assume that the distance between compared sequence numbers is less than
-// (2^16)/2 to determine the order.
-func compareSeqNumbers(seqNum1, seqNum2 uint16) int {
- // calculate distance from seqNum1 to seqNum2
- var dist uint16
- if seqNum1 <= seqNum2 {
- dist = seqNum2 - seqNum1
- } else {
- dist = 0xffff - (seqNum1 - seqNum2 - 1)
+ if err = ch.msgDecoder.DecodeMsg(reply.data, msg); err != nil {
+ return
}
- if dist == 0 {
- return 0
- } else if dist <= 0x8000 {
- return -1
+
+ // check Retval and convert it into VnetAPIError error
+ if strings.HasSuffix(msg.GetMessageName(), "_reply") {
+ // TODO: use categories for messages to avoid checking message name
+ if f := reflect.Indirect(reflect.ValueOf(msg)).FieldByName("Retval"); f.IsValid() {
+ if retval := f.Int(); retval != 0 {
+ err = api.VPPApiError(retval)
+ }
+ }
}
- return 1
+
+ return
}
"time"
"git.fd.io/govpp.git/adapter/mock"
- "git.fd.io/govpp.git/core/bin_api/vpe"
"git.fd.io/govpp.git/examples/bin_api/interfaces"
"git.fd.io/govpp.git/examples/bin_api/memif"
"git.fd.io/govpp.git/examples/bin_api/tap"
defer ctx.teardownTest()
ctx.mockVpp.MockReply(&tap.TapConnectReply{
- Retval: 10,
+ Retval: 0,
SwIfIndex: 1,
})
request := &tap.TapConnect{
err := ctx.ch.SendRequest(request).ReceiveReply(reply)
Expect(err).ShouldNot(HaveOccurred())
- Expect(reply.Retval).To(BeEquivalentTo(10), "Incorrect retval value for TapConnectReply")
+ Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapConnectReply")
Expect(reply.SwIfIndex).To(BeEquivalentTo(1), "Incorrect SwIfIndex value for TapConnectReply")
}
defer ctx.teardownTest()
ctx.mockVpp.MockReply(&tap.TapModifyReply{
- Retval: 15,
SwIfIndex: 2,
})
request := &tap.TapModify{
err := ctx.ch.SendRequest(request).ReceiveReply(reply)
Expect(err).ShouldNot(HaveOccurred())
- Expect(reply.Retval).To(BeEquivalentTo(15), "Incorrect retval value for TapModifyReply")
+ Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapModifyReply")
Expect(reply.SwIfIndex).To(BeEquivalentTo(2), "Incorrect SwIfIndex value for TapModifyReply")
}
ctx := setupTest(t)
defer ctx.teardownTest()
- ctx.mockVpp.MockReply(&tap.TapDeleteReply{
- Retval: 20,
- })
+ ctx.mockVpp.MockReply(&tap.TapDeleteReply{})
request := &tap.TapDelete{
SwIfIndex: 3,
}
err := ctx.ch.SendRequest(request).ReceiveReply(reply)
Expect(err).ShouldNot(HaveOccurred())
- Expect(reply.Retval).To(BeEquivalentTo(20), "Incorrect retval value for TapDeleteReply")
+ Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapDeleteReply")
}
func TestRequestReplySwInterfaceTapDump(t *testing.T) {
defer ctx.teardownTest()
ctx.mockVpp.MockReply(&memif.MemifCreateReply{
- Retval: 22,
SwIfIndex: 4,
})
request := &memif.MemifCreate{
err := ctx.ch.SendRequest(request).ReceiveReply(reply)
Expect(err).ShouldNot(HaveOccurred())
- Expect(reply.Retval).To(BeEquivalentTo(22), "Incorrect Retval value for MemifCreate")
+ Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect Retval value for MemifCreate")
Expect(reply.SwIfIndex).To(BeEquivalentTo(4), "Incorrect SwIfIndex value for MemifCreate")
}
ctx := setupTest(t)
defer ctx.teardownTest()
- ctx.mockVpp.MockReply(&memif.MemifDeleteReply{
- Retval: 24,
- })
+ ctx.mockVpp.MockReply(&memif.MemifDeleteReply{})
request := &memif.MemifDelete{
SwIfIndex: 15,
}
err := ctx.ch.SendRequest(request).ReceiveReply(reply)
Expect(err).ShouldNot(HaveOccurred())
- Expect(reply.Retval).To(BeEquivalentTo(24), "Incorrect Retval value for MemifDelete")
+ Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect Retval value for MemifDelete")
}
func TestRequestReplyMemifDetails(t *testing.T) {
})
}
ctx.mockVpp.MockReply(msgs...)
- ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReply(&ControlPingReply{})
reqCtx := ctx.ch.SendMultiRequest(&tap.SwInterfaceTapDump{})
cnt := 0
})
}
ctx.mockVpp.MockReply(msgs...)
- ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReply(&ControlPingReply{})
reqCtx := ctx.ch.SendMultiRequest(&memif.MemifDump{})
cnt := 0
ctx.ch.UnsubscribeNotification(subs)
}
-func TestCheckMessageCompatibility(t *testing.T) {
+/*func TestCheckMessageCompatibility(t *testing.T) {
ctx := setupTest(t)
defer ctx.teardownTest()
err := ctx.ch.CheckMessageCompatibility(&interfaces.SwInterfaceSetFlags{})
Expect(err).ShouldNot(HaveOccurred())
-}
+}*/
+
func TestSetReplyTimeout(t *testing.T) {
ctx := setupTest(t)
defer ctx.teardownTest()
ctx.ch.SetReplyTimeout(time.Millisecond)
// first one request should work
- ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
- err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReply(&ControlPingReply{})
+ err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).ShouldNot(HaveOccurred())
// no other reply ready - expect timeout
- err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ err = ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("timeout"))
}
})
}
ctx.mockVpp.MockReply(msgs...)
- ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReply(&ControlPingReply{})
cnt := 0
sendMultiRequest := func() error {
defer ctx.teardownTest()
// invalid context 1
- reqCtx1 := &requestCtxData{}
- err := reqCtx1.ReceiveReply(&vpe.ControlPingReply{})
+ reqCtx1 := &requestCtx{}
+ err := reqCtx1.ReceiveReply(&ControlPingReply{})
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("invalid request context"))
// invalid context 2
- reqCtx2 := &multiRequestCtxData{}
- _, err = reqCtx2.ReceiveReply(&vpe.ControlPingReply{})
+ reqCtx2 := &multiRequestCtx{}
+ _, err = reqCtx2.ReceiveReply(&ControlPingReply{})
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("invalid request context"))
// NU
- reqCtx3 := &requestCtxData{}
+ reqCtx3 := &requestCtx{}
err = reqCtx3.ReceiveReply(nil)
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("invalid request context"))
SeqNum: 1,
})
}
- msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 1})
+ msgs = append(msgs, mock.MsgWithContext{Msg: &ControlPingReply{}, Multipart: true, SeqNum: 1})
for i := 1; i <= 3; i++ {
msgs = append(msgs,
SeqNum: 2,
})
}
- msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 2})
+ msgs = append(msgs, mock.MsgWithContext{Msg: &ControlPingReply{}, Multipart: true, SeqNum: 2})
ctx.mockVpp.MockReplyWithContext(msgs...)
ctx.ch.SetReplyTimeout(time.Millisecond)
// first one request should work
- ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 1})
- err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 1})
+ err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).ShouldNot(HaveOccurred())
- err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ err = ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("timeout"))
ctx.mockVpp.MockReplyWithContext(
// simulating late reply
- mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 2},
+ mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 2},
// normal reply for next request
mock.MsgWithContext{Msg: &tap.TapConnectReply{}, SeqNum: 3})
ctx.ch.SetReplyTimeout(time.Millisecond * 100)
// first one request should work
- ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, SeqNum: 1})
- err := ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 1})
+ err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).ShouldNot(HaveOccurred())
cnt := 0
SeqNum: 2,
})
}
- msgs = append(msgs, mock.MsgWithContext{Msg: &vpe.ControlPingReply{}, Multipart: true, SeqNum: 2})
+ msgs = append(msgs, mock.MsgWithContext{Msg: &ControlPingReply{}, Multipart: true, SeqNum: 2})
ctx.mockVpp.MockReplyWithContext(msgs...)
// normal reply for next request
Expect(err).ShouldNot(HaveOccurred())
}
-func TestInvalidMessageID(t *testing.T) {
+/*func TestInvalidMessageID(t *testing.T) {
ctx := setupTest(t)
defer ctx.teardownTest()
// second should fail with error invalid message ID
ctx.mockVpp.MockReply(&vpe.ShowVersionReply{})
- err = ctx.ch.SendRequest(&vpe.ControlPing{}).ReceiveReply(&vpe.ControlPingReply{})
+ err = ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
Expect(err).Should(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("invalid message ID"))
-}
+}*/
// See the License for the specific language governing permissions and
// limitations under the License.
-//go:generate binapi-generator --input-dir=bin_api --output-dir=bin_api
-
package core
import (
"errors"
- "os"
+ "fmt"
+ "reflect"
"sync"
"sync/atomic"
"time"
"git.fd.io/govpp.git/adapter"
"git.fd.io/govpp.git/api"
"git.fd.io/govpp.git/codec"
- "git.fd.io/govpp.git/core/bin_api/vpe"
-)
-
-var (
- msgControlPing api.Message = &vpe.ControlPing{}
- msgControlPingReply api.Message = &vpe.ControlPingReply{}
)
const (
- requestChannelBufSize = 100 // default size of the request channel buffers
- replyChannelBufSize = 100 // default size of the reply channel buffers
- notificationChannelBufSize = 100 // default size of the notification channel buffers
+ requestChannelBufSize = 100 // default size of the request channel buffer
+ replyChannelBufSize = 100 // default size of the reply channel buffer
+ notificationChannelBufSize = 100 // default size of the notification channel buffer
+
+ defaultReplyTimeout = time.Second * 1 // default timeout for replies from VPP, can be changed with SetReplyTimeout
)
var (
- healthCheckProbeInterval = time.Second * 1 // default health check probe interval
- healthCheckReplyTimeout = time.Millisecond * 100 // timeout for reply to a health check probe
- healthCheckThreshold = 1 // number of failed healthProbe until the error is reported
+ healthCheckInterval = time.Second * 1 // default health check interval
+ healthCheckReplyTimeout = time.Millisecond * 100 // timeout for reply to a health check
+ healthCheckThreshold = 1 // number of failed health checks until the error is reported
)
-// ConnectionState holds the current state of the connection to VPP.
+// SetHealthCheckProbeInterval sets health check probe interval.
+// Beware: Function is not thread-safe. It is recommended to setup this parameter
+// before connecting to vpp.
+func SetHealthCheckProbeInterval(interval time.Duration) {
+ healthCheckInterval = interval
+}
+
+// SetHealthCheckReplyTimeout sets timeout for reply to a health check probe.
+// If reply arrives after the timeout, check is considered as failed.
+// Beware: Function is not thread-safe. It is recommended to setup this parameter
+// before connecting to vpp.
+func SetHealthCheckReplyTimeout(timeout time.Duration) {
+ healthCheckReplyTimeout = timeout
+}
+
+// SetHealthCheckThreshold sets the number of failed healthProbe checks until the error is reported.
+// Beware: Function is not thread-safe. It is recommended to setup this parameter
+// before connecting to vpp.
+func SetHealthCheckThreshold(threshold int) {
+ healthCheckThreshold = threshold
+}
+
+// ConnectionState represents the current state of the connection to VPP.
type ConnectionState int
const (
- // Connected connection state means that the connection to VPP has been successfully established.
+ // Connected represents state in which the connection has been successfully established.
Connected ConnectionState = iota
- // Disconnected connection state means that the connection to VPP has been lost.
+ // Disconnected represents state in which the connection has been dropped.
Disconnected
)
// ConnectionEvent is a notification about change in the VPP connection state.
type ConnectionEvent struct {
- // Timestamp holds the time when the event has been generated.
+ // Timestamp holds the time when the event has been created.
Timestamp time.Time
- // State holds the new state of the connection to VPP at the time when the event has been generated.
+ // State holds the new state of the connection at the time when the event has been created.
State ConnectionState
+
+ // Error holds error if any encountered.
+ Error error
}
+var (
+ connLock sync.RWMutex // lock for the global connection
+ conn *Connection // global handle to the Connection (used in the message receive callback)
+)
+
// Connection represents a shared memory connection to VPP via vppAdapter.
type Connection struct {
vpp adapter.VppAdapter // VPP adapter
connected uint32 // non-zero if the adapter is connected to VPP
- codec *codec.MsgCodec // message codec
- msgIDsLock sync.RWMutex // lock for the message IDs map
- msgIDs map[string]uint16 // map of message IDs indexed by message name + CRC
+ codec *codec.MsgCodec // message codec
+ msgIDs map[string]uint16 // map of message IDs indexed by message name + CRC
+ msgMap map[uint16]api.Message // map of messages indexed by message ID
+ maxChannelID uint32 // maximum used channel ID (the real limit is 2^15, 32-bit is used for atomic operations)
channelsLock sync.RWMutex // lock for the channels map
channels map[uint16]*channel // map of all API channels indexed by the channel ID
notifSubscriptionsLock sync.RWMutex // lock for the subscriptions map
notifSubscriptions map[uint16][]*api.NotifSubscription // map od all notification subscriptions indexed by message ID
- maxChannelID uint32 // maximum used channel ID (the real limit is 2^15, 32-bit is used for atomic operations)
- pingReqID uint16 // ID if the ControlPing message
- pingReplyID uint16 // ID of the ControlPingReply message
+ pingReqID uint16 // ID if the ControlPing message
+ pingReplyID uint16 // ID of the ControlPingReply message
lastReplyLock sync.Mutex // lock for the last reply
lastReply time.Time // time of the last received reply from VPP
}
-var (
- log *logger.Logger // global logger
- conn *Connection // global handle to the Connection (used in the message receive callback)
- connLock sync.RWMutex // lock for the global connection
-)
-
-// init initializes global logger, which logs debug level messages to stdout.
-func init() {
- log = logger.New()
- log.Out = os.Stdout
- log.Level = logger.DebugLevel
-}
-
-// SetLogger sets global logger to provided one.
-func SetLogger(l *logger.Logger) {
- log = l
-}
-
-// SetHealthCheckProbeInterval sets health check probe interval.
-// Beware: Function is not thread-safe. It is recommended to setup this parameter
-// before connecting to vpp.
-func SetHealthCheckProbeInterval(interval time.Duration) {
- healthCheckProbeInterval = interval
-}
-
-// SetHealthCheckReplyTimeout sets timeout for reply to a health check probe.
-// If reply arrives after the timeout, check is considered as failed.
-// Beware: Function is not thread-safe. It is recommended to setup this parameter
-// before connecting to vpp.
-func SetHealthCheckReplyTimeout(timeout time.Duration) {
- healthCheckReplyTimeout = timeout
-}
-
-// SetHealthCheckThreshold sets the number of failed healthProbe checks until the error is reported.
-// Beware: Function is not thread-safe. It is recommended to setup this parameter
-// before connecting to vpp.
-func SetHealthCheckThreshold(threshold int) {
- healthCheckThreshold = threshold
-}
-
-// SetControlPingMessages sets the messages for ControlPing and ControlPingReply
-func SetControlPingMessages(controPing, controlPingReply api.Message) {
- msgControlPing = controPing
- msgControlPingReply = controlPingReply
-}
-
// Connect connects to VPP using specified VPP adapter and returns the connection handle.
// This call blocks until VPP is connected, or an error occurs. Only one connection attempt will be performed.
func Connect(vppAdapter adapter.VppAdapter) (*Connection, error) {
return nil, err
}
- return conn, nil
+ return c, nil
}
// AsyncConnect asynchronously connects to VPP using specified VPP adapter and returns the connection handle
connChan := make(chan ConnectionEvent, notificationChannelBufSize)
go c.connectLoop(connChan)
- return conn, connChan, nil
+ return c, connChan, nil
}
// Disconnect disconnects from VPP and releases all connection-related resources.
if c == nil {
return
}
+
connLock.Lock()
defer connLock.Unlock()
- if c != nil && c.vpp != nil {
+ if c.vpp != nil {
c.disconnectVPP()
}
conn = nil
codec: &codec.MsgCodec{},
channels: make(map[uint16]*channel),
msgIDs: make(map[string]uint16),
+ msgMap: make(map[uint16]api.Message),
notifSubscriptions: make(map[uint16][]*api.NotifSubscription),
}
+ conn.vpp.SetMsgCallback(conn.msgCallback)
- conn.vpp.SetMsgCallback(msgCallback)
return conn, nil
}
-// connectVPP performs one blocking attempt to connect to VPP.
+// connectVPP performs blocking attempt to connect to VPP.
func (c *Connection) connectVPP() error {
- log.Debug("Connecting to VPP...")
+ log.Debug("Connecting to VPP..")
// blocking connect
- err := c.vpp.Connect()
- if err != nil {
- log.Warn(err)
+ if err := c.vpp.Connect(); err != nil {
return err
}
- // store control ping IDs
- if c.pingReqID, err = c.GetMessageID(msgControlPing); err != nil {
- c.vpp.Disconnect()
- return err
- }
- if c.pingReplyID, err = c.GetMessageID(msgControlPingReply); err != nil {
+ log.Debugf("Connected to VPP.")
+
+ if err := c.retrieveMessageIDs(); err != nil {
c.vpp.Disconnect()
- return err
+ return fmt.Errorf("VPP is incompatible: %v", err)
}
// store connected state
atomic.StoreUint32(&c.connected, 1)
- log.Info("Connected to VPP.")
return nil
}
+func getMsgNameWithCrc(x api.Message) string {
+ return x.GetMessageName() + "_" + x.GetCrcString()
+}
+
+// retrieveMessageIDs retrieves IDs for all registered messages and stores them in map
+func (c *Connection) retrieveMessageIDs() (err error) {
+ t := time.Now()
+
+ var addMsg = func(msgID uint16, msg api.Message) {
+ c.msgIDs[getMsgNameWithCrc(msg)] = msgID
+ c.msgMap[msgID] = msg
+ }
+
+ msgs := api.GetAllMessages()
+
+ for name, msg := range msgs {
+ msgID, err := c.vpp.GetMsgID(msg.GetMessageName(), msg.GetCrcString())
+ if err != nil {
+ return err
+ }
+
+ addMsg(msgID, msg)
+
+ if msg.GetMessageName() == msgControlPing.GetMessageName() {
+ c.pingReqID = msgID
+ msgControlPing = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+ } else if msg.GetMessageName() == msgControlPingReply.GetMessageName() {
+ c.pingReplyID = msgID
+ msgControlPingReply = reflect.New(reflect.TypeOf(msg).Elem()).Interface().(api.Message)
+ }
+
+ if debugMsgIDs {
+ log.Debugf("message %q (%s) has ID: %d", name, getMsgNameWithCrc(msg), msgID)
+ }
+ }
+
+ log.Debugf("retrieving %d message IDs took %s", len(msgs), time.Since(t))
+
+ // fallback for control ping when vpe package is not imported
+ if c.pingReqID == 0 {
+ c.pingReqID, err = c.vpp.GetMsgID(msgControlPing.GetMessageName(), msgControlPing.GetCrcString())
+ if err != nil {
+ return err
+ }
+ addMsg(c.pingReqID, msgControlPing)
+ }
+ if c.pingReplyID == 0 {
+ c.pingReplyID, err = c.vpp.GetMsgID(msgControlPingReply.GetMessageName(), msgControlPingReply.GetCrcString())
+ if err != nil {
+ return err
+ }
+ addMsg(c.pingReplyID, msgControlPingReply)
+ }
+
+ return nil
+}
+
+// GetMessageID returns message identifier of given API message.
+func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
+ if c == nil {
+ return 0, errors.New("nil connection passed in")
+ }
+
+ if msgID, ok := c.msgIDs[getMsgNameWithCrc(msg)]; ok {
+ return msgID, nil
+ }
+
+ return 0, fmt.Errorf("unknown message: %s (%s)", msg.GetMessageName(), msg.GetCrcString())
+}
+
+// LookupByID looks up message name and crc by ID.
+func (c *Connection) LookupByID(msgID uint16) (api.Message, error) {
+ if c == nil {
+ return nil, errors.New("nil connection passed in")
+ }
+
+ if msg, ok := c.msgMap[msgID]; ok {
+ return msg, nil
+ }
+
+ return nil, fmt.Errorf("unknown message ID: %d", msgID)
+}
+
// disconnectVPP disconnects from VPP in case it is connected.
func (c *Connection) disconnectVPP() {
if atomic.CompareAndSwapUint32(&c.connected, 1, 0) {
// it continues with connectLoop and tries to reconnect.
func (c *Connection) healthCheckLoop(connChan chan ConnectionEvent) {
// create a separate API channel for health check probes
- ch, err := conn.newAPIChannelBuffered(1, 1)
+ ch, err := c.newAPIChannel(1, 1)
if err != nil {
log.Error("Failed to create health check API channel, health check will be disabled:", err)
return
}
- var sinceLastReply time.Duration
- var failedChecks int
+ var (
+ sinceLastReply time.Duration
+ failedChecks int
+ )
// send health check probes until an error or timeout occurs
for {
// sleep until next health check probe period
- time.Sleep(healthCheckProbeInterval)
+ time.Sleep(healthCheckInterval)
if atomic.LoadUint32(&c.connected) == 0 {
// Disconnect has been called in the meantime, return the healthcheck - reconnect loop
}
// send the control ping request
- ch.reqChan <- &api.VppRequest{Message: msgControlPing}
+ ch.reqChan <- &vppRequest{msg: msgControlPing}
for {
// expect response within timeout period
select {
case vppReply := <-ch.replyChan:
- err = vppReply.Error
+ err = vppReply.err
case <-time.After(healthCheckReplyTimeout):
err = ErrProbeTimeout
// check if time since last reply from any other
// channel is less than health check reply timeout
- conn.lastReplyLock.Lock()
+ c.lastReplyLock.Lock()
sinceLastReply = time.Since(c.lastReply)
- conn.lastReplyLock.Unlock()
+ c.lastReplyLock.Unlock()
if sinceLastReply < healthCheckReplyTimeout {
log.Warnf("VPP health check probe timing out, but some request on other channel was received %v ago, continue waiting!", sinceLastReply)
failedChecks++
log.Warnf("VPP health check probe timed out after %v (%d. timeout)", healthCheckReplyTimeout, failedChecks)
if failedChecks > healthCheckThreshold {
- // in case of exceeded treshold disconnect
+ // in case of exceeded failed check treshold, assume VPP disconnected
log.Errorf("VPP health check exceeded treshold for timeouts (>%d), assuming disconnect", healthCheckThreshold)
connChan <- ConnectionEvent{Timestamp: time.Now(), State: Disconnected}
break
}
} else if err != nil {
- // in case of error disconnect
+ // in case of error, assume VPP disconnected
log.Errorf("VPP health check probe failed: %v", err)
- connChan <- ConnectionEvent{Timestamp: time.Now(), State: Disconnected}
+ connChan <- ConnectionEvent{Timestamp: time.Now(), State: Disconnected, Error: err}
break
} else if failedChecks > 0 {
+ // in case of success after failed checks, clear failed check counter
failedChecks = 0
log.Infof("VPP health check probe OK")
}
}
func (c *Connection) NewAPIChannel() (api.Channel, error) {
- return c.newAPIChannelBuffered(requestChannelBufSize, replyChannelBufSize)
+ return c.newAPIChannel(requestChannelBufSize, replyChannelBufSize)
}
func (c *Connection) NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (api.Channel, error) {
- return c.newAPIChannelBuffered(reqChanBufSize, replyChanBufSize)
+ return c.newAPIChannel(reqChanBufSize, replyChanBufSize)
}
// NewAPIChannelBuffered returns a new API channel for communication with VPP via govpp core.
// It allows to specify custom buffer sizes for the request and reply Go channels.
-func (c *Connection) newAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (*channel, error) {
+func (c *Connection) newAPIChannel(reqChanBufSize, replyChanBufSize int) (*channel, error) {
if c == nil {
return nil, errors.New("nil connection passed in")
}
chID := uint16(atomic.AddUint32(&c.maxChannelID, 1) & 0x7fff)
ch := &channel{
- id: chID,
- replyTimeout: defaultReplyTimeout,
+ id: chID,
+ replyTimeout: defaultReplyTimeout,
+ msgDecoder: c.codec,
+ msgIdentifier: c,
+ reqChan: make(chan *vppRequest, reqChanBufSize),
+ replyChan: make(chan *vppReply, replyChanBufSize),
+ notifSubsChan: make(chan *subscriptionRequest, reqChanBufSize),
+ notifSubsReplyChan: make(chan error, replyChanBufSize),
}
- ch.msgDecoder = c.codec
- ch.msgIdentifier = c
-
- // create the communication channels
- ch.reqChan = make(chan *api.VppRequest, reqChanBufSize)
- ch.replyChan = make(chan *api.VppReply, replyChanBufSize)
- ch.notifSubsChan = make(chan *api.NotifSubscribeRequest, reqChanBufSize)
- ch.notifSubsReplyChan = make(chan error, replyChanBufSize)
// store API channel within the client
c.channelsLock.Lock()
// releaseAPIChannel releases API channel that needs to be closed.
func (c *Connection) releaseAPIChannel(ch *channel) {
log.WithFields(logger.Fields{
- "ID": ch.id,
- }).Debug("API channel closed.")
+ "channel": ch.id,
+ }).Debug("API channel released")
// delete the channel from channels map
c.channelsLock.Lock()
package core_test
+/*
import (
"testing"
numIters := 0xffff + 100
reqCtx := make(map[int]api.RequestCtx)
- for i := 0; i < numIters+30; /* receiver is 30 reqs behind */ i++ {
+ for i := 0; i < numIters+30; i++ {
if i < numIters {
ctx.mockVpp.MockReply(&vpe.ControlPingReply{Retval: int32(i)})
req := &vpe.ControlPing{}
}
}
}
+*/
--- /dev/null
+package core
+
+import "git.fd.io/govpp.git/api"
+
+var (
+ msgControlPing api.Message = new(ControlPing)
+ msgControlPingReply api.Message = new(ControlPingReply)
+)
+
+type ControlPing struct{}
+
+func (*ControlPing) GetMessageName() string {
+ return "control_ping"
+}
+func (*ControlPing) GetCrcString() string {
+ return "51077d14"
+}
+func (*ControlPing) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+
+type ControlPingReply struct {
+ Retval int32
+ ClientIndex uint32
+ VpePID uint32
+}
+
+func (*ControlPingReply) GetMessageName() string {
+ return "control_ping_reply"
+}
+func (*ControlPingReply) GetCrcString() string {
+ return "f6b0b8ca"
+}
+func (*ControlPingReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
--- /dev/null
+package core
+
+import (
+ "os"
+
+ logger "github.com/sirupsen/logrus"
+)
+
+var (
+ debug = os.Getenv("DEBUG_GOVPP") != ""
+ debugMsgIDs = os.Getenv("DEBUG_GOVPP_MSGIDS") != ""
+
+ log = logger.New() // global logger
+)
+
+// init initializes global logger, which logs debug level messages to stdout.
+func init() {
+ log.Out = os.Stdout
+ if debug {
+ log.Level = logger.DebugLevel
+ }
+}
+
+// SetLogger sets global logger to l.
+func SetLogger(l *logger.Logger) {
+ log = l
+}
+
+// SetLogLevel sets global logger level to lvl.
+func SetLogLevel(lvl logger.Level) {
+ log.Level = lvl
+}
import (
"fmt"
- "reflect"
"git.fd.io/govpp.git/api"
logger "github.com/sirupsen/logrus"
)
-// processNotifSubscribeRequest processes a notification subscribe request.
-func (c *Connection) processNotifSubscribeRequest(ch *channel, req *api.NotifSubscribeRequest) error {
+// processSubscriptionRequest processes a notification subscribe request.
+func (c *Connection) processSubscriptionRequest(ch *channel, req *subscriptionRequest) error {
var err error
// subscribe / unsubscribe
- if req.Subscribe {
- err = c.addNotifSubscription(req.Subscription)
+ if req.subscribe {
+ err = c.addNotifSubscription(req.sub)
} else {
- err = c.removeNotifSubscription(req.Subscription)
+ err = c.removeNotifSubscription(req.sub)
}
// send the reply into the go channel
default:
// unable to write into the channel without blocking
log.WithFields(logger.Fields{
- "channel": ch,
+ "channel": ch.id,
}).Warn("Unable to deliver the subscribe reply, reciever end not ready.")
}
// addNotifSubscription adds the notification subscription into the subscriptions map of the connection.
func (c *Connection) addNotifSubscription(subs *api.NotifSubscription) error {
// get message ID of the notification message
- msgID, err := c.getSubscriptionMessageID(subs)
+ msgID, msgName, err := c.getSubscriptionMessageID(subs)
if err != nil {
return err
}
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "subscription": subs,
+ "msg_name": msgName,
+ "msg_id": msgID,
}).Debug("Adding new notification subscription.")
// add the subscription into map
// removeNotifSubscription removes the notification subscription from the subscriptions map of the connection.
func (c *Connection) removeNotifSubscription(subs *api.NotifSubscription) error {
// get message ID of the notification message
- msgID, err := c.getSubscriptionMessageID(subs)
+ msgID, msgName, err := c.getSubscriptionMessageID(subs)
if err != nil {
return err
}
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "subscription": subs,
+ "msg_name": msgName,
+ "msg_id": msgID,
}).Debug("Removing notification subscription.")
// remove the subscription from the map
// send to notification to each subscriber
for _, subs := range c.notifSubscriptions[msgID] {
+ msg := subs.MsgFactory()
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "msg_size": len(data),
- "subscription": subs,
+ "msg_name": msg.GetMessageName(),
+ "msg_id": msgID,
+ "msg_size": len(data),
}).Debug("Sending a notification to the subscription channel.")
- msg := subs.MsgFactory()
- err := c.codec.DecodeMsg(data, msg)
- if err != nil {
+ if err := c.codec.DecodeMsg(data, msg); err != nil {
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "msg_size": len(data),
- "subscription": subs,
- }).Error("Unable to decode the notification message.")
+ "msg_name": msg.GetMessageName(),
+ "msg_id": msgID,
+ "msg_size": len(data),
+ }).Errorf("Unable to decode the notification message: %v", err)
continue
}
- // special case for the strange interface counters message
- if msg.GetMessageName() == "vnet_interface_counters" {
- v := reflect.ValueOf(msg).Elem().FieldByName("Data")
- if v.IsValid() {
- v.SetBytes(data[8:]) // include the Count and Data fields in the data
- }
- }
-
// send the message into the go channel of the subscription
select {
case subs.NotifChan <- msg:
default:
// unable to write into the channel without blocking
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "msg_size": len(data),
- "subscription": subs,
+ "msg_name": msg.GetMessageName(),
+ "msg_id": msgID,
+ "msg_size": len(data),
}).Warn("Unable to deliver the notification, reciever end not ready.")
}
log.WithFields(logger.Fields{
"msg_id": msgID,
"msg_size": len(data),
- }).Debug("No subscription found for the notification message.")
+ }).Info("No subscription found for the notification message.")
}
}
// getSubscriptionMessageID returns ID of the message the subscription is tied to.
-func (c *Connection) getSubscriptionMessageID(subs *api.NotifSubscription) (uint16, error) {
+func (c *Connection) getSubscriptionMessageID(subs *api.NotifSubscription) (uint16, string, error) {
msg := subs.MsgFactory()
msgID, err := c.GetMessageID(msg)
-
if err != nil {
log.WithFields(logger.Fields{
"msg_name": msg.GetMessageName(),
"msg_crc": msg.GetCrcString(),
}).Errorf("unable to retrieve message ID: %v", err)
- return 0, fmt.Errorf("unable to retrieve message ID: %v", err)
+ return 0, "", fmt.Errorf("unable to retrieve message ID: %v", err)
}
- return msgID, nil
+ return msgID, msg.GetMessageName(), nil
}
"time"
logger "github.com/sirupsen/logrus"
-
- "git.fd.io/govpp.git/api"
)
var (
case req := <-ch.notifSubsChan:
// new request on the notification subscribe channel
- c.processNotifSubscribeRequest(ch, req)
+ c.processSubscriptionRequest(ch, req)
}
}
}
// processRequest processes a single request received on the request channel.
-func (c *Connection) processRequest(ch *channel, req *api.VppRequest) error {
+func (c *Connection) processRequest(ch *channel, req *vppRequest) error {
// check whether we are connected to VPP
if atomic.LoadUint32(&c.connected) == 0 {
err := ErrNotConnected
- log.Error(err)
- sendReply(ch, &api.VppReply{SeqNum: req.SeqNum, Error: err})
+ log.Errorf("processing request failed: %v", err)
+ sendReplyError(ch, req, err)
return err
}
// retrieve message ID
- msgID, err := c.GetMessageID(req.Message)
+ msgID, err := c.GetMessageID(req.msg)
if err != nil {
err = fmt.Errorf("unable to retrieve message ID: %v", err)
log.WithFields(logger.Fields{
- "msg_name": req.Message.GetMessageName(),
- "msg_crc": req.Message.GetCrcString(),
- "seq_num": req.SeqNum,
+ "msg_name": req.msg.GetMessageName(),
+ "msg_crc": req.msg.GetCrcString(),
+ "seq_num": req.seqNum,
}).Error(err)
- sendReply(ch, &api.VppReply{SeqNum: req.SeqNum, Error: err})
+ sendReplyError(ch, req, err)
return err
}
// encode the message into binary
- data, err := c.codec.EncodeMsg(req.Message, msgID)
+ data, err := c.codec.EncodeMsg(req.msg, msgID)
if err != nil {
err = fmt.Errorf("unable to encode the messge: %v", err)
log.WithFields(logger.Fields{
- "channel": ch.id,
- "msg_id": msgID,
- "seq_num": req.SeqNum,
+ "channel": ch.id,
+ "msg_id": msgID,
+ "msg_name": req.msg.GetMessageName(),
+ "seq_num": req.seqNum,
}).Error(err)
- sendReply(ch, &api.VppReply{SeqNum: req.SeqNum, Error: err})
+ sendReplyError(ch, req, err)
return err
}
+ // get context
+ context := packRequestContext(ch.id, req.multi, req.seqNum)
if log.Level == logger.DebugLevel { // for performance reasons - logrus does some processing even if debugs are disabled
log.WithFields(logger.Fields{
"channel": ch.id,
+ "context": context,
+ "is_multi": req.multi,
"msg_id": msgID,
+ "msg_name": req.msg.GetMessageName(),
"msg_size": len(data),
- "msg_name": req.Message.GetMessageName(),
- "seq_num": req.SeqNum,
- }).Debug("Sending a message to VPP.")
+ "seq_num": req.seqNum,
+ }).Debug(" -> Sending a message to VPP.")
}
// send the request to VPP
- context := packRequestContext(ch.id, req.Multipart, req.SeqNum)
err = c.vpp.SendMsg(context, data)
if err != nil {
err = fmt.Errorf("unable to send the message: %v", err)
log.WithFields(logger.Fields{
"context": context,
"msg_id": msgID,
- "seq_num": req.SeqNum,
+ "seq_num": req.seqNum,
}).Error(err)
- sendReply(ch, &api.VppReply{SeqNum: req.SeqNum, Error: err})
+ sendReplyError(ch, req, err)
return err
}
- if req.Multipart {
+ if req.multi {
// send a control ping to determine end of the multipart response
pingData, _ := c.codec.EncodeMsg(msgControlPing, c.pingReqID)
log.WithFields(logger.Fields{
+ "channel": ch.id,
"context": context,
"msg_id": c.pingReqID,
"msg_size": len(pingData),
- "seq_num": req.SeqNum,
- }).Debug("Sending a control ping to VPP.")
-
- c.vpp.SendMsg(context, pingData)
+ "seq_num": req.seqNum,
+ }).Debug(" -> Sending a control ping to VPP.")
+
+ if err := c.vpp.SendMsg(context, pingData); err != nil {
+ log.WithFields(logger.Fields{
+ "context": context,
+ "msg_id": msgID,
+ "seq_num": req.seqNum,
+ }).Warnf("unable to send control ping: %v", err)
+ }
}
return nil
}
// msgCallback is called whenever any binary API message comes from VPP.
-func msgCallback(context uint32, msgID uint16, data []byte) {
+func (c *Connection) msgCallback(msgID uint16, context uint32, data []byte) {
connLock.RLock()
defer connLock.RUnlock()
- if conn == nil {
+ if c == nil {
log.Warn("Already disconnected, ignoring the message.")
return
}
- chanID, isMultipart, seqNum := unpackRequestContext(context)
+ msg, ok := c.msgMap[msgID]
+ if !ok {
+ log.Warnf("Unknown message received, ID: %d", msgID)
+ return
+ }
+
+ // decode message context to fix for special cases of messages,
+ // for example:
+ // - replies that don't have context as first field (comes as zero)
+ // - events that don't have context at all (comes as non zero)
+ //
+ msgContext, err := c.codec.DecodeMsgContext(data, msg)
+ if err == nil {
+ if context != msgContext {
+ log.Debugf("different context was decoded from message (%d -> %d)", context, msgContext)
+ context = msgContext
+ }
+ } else {
+ log.Errorf("decoding context failed: %v", err)
+ }
+
+ chanID, isMulti, seqNum := unpackRequestContext(context)
if log.Level == logger.DebugLevel { // for performance reasons - logrus does some processing even if debugs are disabled
log.WithFields(logger.Fields{
- "msg_id": msgID,
- "msg_size": len(data),
- "channel_id": chanID,
- "is_multipart": isMultipart,
- "seq_num": seqNum,
- }).Debug("Received a message from VPP.")
+ "context": context,
+ "msg_id": msgID,
+ "msg_name": msg.GetMessageName(),
+ "msg_size": len(data),
+ "channel": chanID,
+ "is_multi": isMulti,
+ "seq_num": seqNum,
+ }).Debug(" <- Received a message from VPP.")
}
- if context == 0 || conn.isNotificationMessage(msgID) {
+ if context == 0 || c.isNotificationMessage(msgID) {
// process the message as a notification
- conn.sendNotifications(msgID, data)
+ c.sendNotifications(msgID, data)
return
}
// match ch according to the context
- conn.channelsLock.RLock()
- ch, ok := conn.channels[chanID]
- conn.channelsLock.RUnlock()
-
+ c.channelsLock.RLock()
+ ch, ok := c.channels[chanID]
+ c.channelsLock.RUnlock()
if !ok {
log.WithFields(logger.Fields{
- "channel_id": chanID,
- "msg_id": msgID,
+ "channel": chanID,
+ "msg_id": msgID,
}).Error("Channel ID not known, ignoring the message.")
return
}
- lastReplyReceived := false
- // if this is a control ping reply to a multipart request, treat this as a last part of the reply
- if msgID == conn.pingReplyID && isMultipart {
- lastReplyReceived = true
- }
+ // if this is a control ping reply to a multipart request,
+ // treat this as a last part of the reply
+ lastReplyReceived := isMulti && msgID == c.pingReplyID
// send the data to the channel
- sendReply(ch, &api.VppReply{
- MessageID: msgID,
- SeqNum: seqNum,
- Data: data,
- LastReplyReceived: lastReplyReceived,
+ sendReply(ch, &vppReply{
+ msgID: msgID,
+ seqNum: seqNum,
+ data: data,
+ lastReceived: lastReplyReceived,
})
// store actual time of this reply
- conn.lastReplyLock.Lock()
- conn.lastReply = time.Now()
- conn.lastReplyLock.Unlock()
+ c.lastReplyLock.Lock()
+ c.lastReply = time.Now()
+ c.lastReplyLock.Unlock()
}
// sendReply sends the reply into the go channel, if it cannot be completed without blocking, otherwise
// it logs the error and do not send the message.
-func sendReply(ch *channel, reply *api.VppReply) {
+func sendReply(ch *channel, reply *vppReply) {
select {
case ch.replyChan <- reply:
// reply sent successfully
// receiver still not ready
log.WithFields(logger.Fields{
"channel": ch,
- "msg_id": reply.MessageID,
- "seq_num": reply.SeqNum,
+ "msg_id": reply.msgID,
+ "seq_num": reply.seqNum,
}).Warn("Unable to send the reply, reciever end not ready.")
}
}
-// GetMessageID returns message identifier of given API message.
-func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
- if c == nil {
- return 0, errors.New("nil connection passed in")
- }
- return c.messageNameToID(msg.GetMessageName(), msg.GetCrcString())
-}
-
-// messageNameToID returns message ID of a message identified by its name and CRC.
-func (c *Connection) messageNameToID(msgName string, msgCrc string) (uint16, error) {
- msgKey := msgName + "_" + msgCrc
-
- // try to get the ID from the map
- c.msgIDsLock.RLock()
- id, ok := c.msgIDs[msgKey]
- c.msgIDsLock.RUnlock()
- if ok {
- return id, nil
- }
-
- // get the ID using VPP API
- id, err := c.vpp.GetMsgID(msgName, msgCrc)
- if err != nil {
- err = fmt.Errorf("unable to retrieve message ID: %v", err)
- log.WithFields(logger.Fields{
- "msg_name": msgName,
- "msg_crc": msgCrc,
- }).Error(err)
- return id, err
- }
-
- c.msgIDsLock.Lock()
- c.msgIDs[msgKey] = id
- c.msgIDsLock.Unlock()
-
- return id, nil
-}
-
-// LookupByID looks up message name and crc by ID.
-func (c *Connection) LookupByID(ID uint16) (string, error) {
- if c == nil {
- return "", errors.New("nil connection passed in")
- }
-
- c.msgIDsLock.Lock()
- defer c.msgIDsLock.Unlock()
-
- for key, id := range c.msgIDs {
- if id == ID {
- return key, nil
- }
- }
-
- return "", fmt.Errorf("unknown message ID: %d", ID)
+func sendReplyError(ch *channel, req *vppRequest, err error) {
+ sendReply(ch, &vppReply{seqNum: req.seqNum, err: err})
}
// +------------------+-------------------+-----------------------+
seqNum = uint16(context & 0xffff)
return
}
+
+// compareSeqNumbers returns -1, 0, 1 if sequence number <seqNum1> precedes, equals to,
+// or succeeds seq. number <seqNum2>.
+// Since sequence numbers cycle in the finite set of size 2^16, the function
+// must assume that the distance between compared sequence numbers is less than
+// (2^16)/2 to determine the order.
+func compareSeqNumbers(seqNum1, seqNum2 uint16) int {
+ // calculate distance from seqNum1 to seqNum2
+ var dist uint16
+ if seqNum1 <= seqNum2 {
+ dist = seqNum2 - seqNum1
+ } else {
+ dist = 0xffff - (seqNum1 - seqNum2 - 1)
+ }
+ if dist == 0 {
+ return 0
+ } else if dist <= 0x8000 {
+ return -1
+ }
+ return 1
+}
{
- "services": [
- {
- "acl_interface_add_del": {
- "reply": "acl_interface_add_del_reply"
- }
- },
- {
- "acl_del": {
- "reply": "acl_del_reply"
- }
- },
- {
- "macip_acl_del": {
- "reply": "macip_acl_del_reply"
- }
- },
- {
- "acl_plugin_get_version": {
- "reply": "acl_plugin_get_version_reply"
- }
- },
- {
- "macip_acl_interface_add_del": {
- "reply": "macip_acl_interface_add_del_reply"
- }
- },
- {
- "acl_interface_set_acl_list": {
- "reply": "acl_interface_set_acl_list_reply"
- }
- },
- {
- "acl_dump": {
- "reply": "acl_details",
- "stream": true
- }
- },
- {
- "acl_interface_list_dump": {
- "reply": "acl_interface_list_details",
- "stream": true
- }
- },
- {
- "macip_acl_interface_list_dump": {
- "reply": "macip_acl_interface_list_details",
- "stream": true
- }
- },
- {
- "acl_add_replace": {
- "reply": "acl_add_replace_reply"
- }
- },
- {
- "acl_plugin_control_ping": {
- "reply": "acl_plugin_control_ping_reply"
- }
- },
- {
- "macip_acl_interface_get": {
- "reply": "macip_acl_interface_get_reply"
- }
- },
- {
- "macip_acl_add": {
- "reply": "macip_acl_add_reply"
- }
- },
- {
- "macip_acl_add_replace": {
- "reply": "macip_acl_add_replace_reply"
- }
- },
- {
- "macip_acl_dump": {
- "reply": "macip_acl_details",
- "stream": true
- }
- }
- ],
- "vl_api_version": "0x1db2ece9",
- "enums": [],
"messages": [
[
"acl_plugin_get_version",
{
"crc": "0x29783fa0"
}
+ ],
+ [
+ "acl_interface_set_etype_whitelist",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "count"
+ ],
+ [
+ "u8",
+ "n_input"
+ ],
+ [
+ "u16",
+ "whitelist",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0xf515efc5"
+ }
+ ],
+ [
+ "acl_interface_set_etype_whitelist_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "acl_interface_etype_whitelist_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ {
+ "crc": "0x529cb13f"
+ }
+ ],
+ [
+ "acl_interface_etype_whitelist_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "count"
+ ],
+ [
+ "u8",
+ "n_input"
+ ],
+ [
+ "u16",
+ "whitelist",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0x6a5d4e81"
+ }
]
],
+ "vl_api_version": "0x25a6e1e9",
+ "unions": [],
+ "services": {
+ "acl_plugin_get_version": {
+ "reply": "acl_plugin_get_version_reply"
+ },
+ "acl_dump": {
+ "reply": "acl_details",
+ "stream": true
+ },
+ "acl_interface_add_del": {
+ "reply": "acl_interface_add_del_reply"
+ },
+ "acl_del": {
+ "reply": "acl_del_reply"
+ },
+ "acl_plugin_control_ping": {
+ "reply": "acl_plugin_control_ping_reply"
+ },
+ "macip_acl_interface_get": {
+ "reply": "macip_acl_interface_get_reply"
+ },
+ "acl_interface_etype_whitelist_dump": {
+ "reply": "acl_interface_etype_whitelist_details",
+ "stream": true
+ },
+ "macip_acl_interface_add_del": {
+ "reply": "macip_acl_interface_add_del_reply"
+ },
+ "macip_acl_del": {
+ "reply": "macip_acl_del_reply"
+ },
+ "macip_acl_add": {
+ "reply": "macip_acl_add_reply"
+ },
+ "acl_interface_list_dump": {
+ "reply": "acl_interface_list_details",
+ "stream": true
+ },
+ "acl_interface_set_acl_list": {
+ "reply": "acl_interface_set_acl_list_reply"
+ },
+ "acl_add_replace": {
+ "reply": "acl_add_replace_reply"
+ },
+ "acl_interface_set_etype_whitelist": {
+ "reply": "acl_interface_set_etype_whitelist_reply"
+ },
+ "macip_acl_add_replace": {
+ "reply": "macip_acl_add_replace_reply"
+ },
+ "macip_acl_dump": {
+ "reply": "macip_acl_details",
+ "stream": true
+ },
+ "macip_acl_interface_list_dump": {
+ "reply": "macip_acl_interface_list_details",
+ "stream": true
+ }
+ },
+ "enums": [],
"types": [
[
"acl_rule",
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package acl represents the VPP binary API of the 'acl' VPP module.
-// Generated from '../../bin_api/acl.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: acl.api.json
+
+/*
+Package acl is a generated VPP binary API of the 'acl' VPP module.
+
+It is generated from this file:
+ acl.api.json
+
+It contains these VPP binary API objects:
+ 34 messages
+ 2 types
+ 17 services
+*/
package acl
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0x1db2ece9
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
-// ACLRule represents the VPP binary API data type 'acl_rule'.
-// Generated from '../../bin_api/acl.api.json', line 836:
+/* Types */
+
+// ACLRule represents the VPP binary API type 'acl_rule'.
+// Generated from 'acl.api.json', line 922:
//
// "acl_rule",
// [
//
type ACLRule struct {
IsPermit uint8
- IsIpv6 uint8
+ IsIPv6 uint8
SrcIPAddr []byte `struc:"[16]byte"`
SrcIPPrefixLen uint8
DstIPAddr []byte `struc:"[16]byte"`
return "6f99bf4d"
}
-// MacipACLRule represents the VPP binary API data type 'macip_acl_rule'.
-// Generated from '../../bin_api/acl.api.json', line 896:
+// MacipACLRule represents the VPP binary API type 'macip_acl_rule'.
+// Generated from 'acl.api.json', line 982:
//
// "macip_acl_rule",
// [
//
type MacipACLRule struct {
IsPermit uint8
- IsIpv6 uint8
+ IsIPv6 uint8
SrcMac []byte `struc:"[6]byte"`
SrcMacMask []byte `struc:"[6]byte"`
SrcIPAddr []byte `struc:"[16]byte"`
return "70589f1e"
}
+/* Messages */
+
// ACLPluginGetVersion represents the VPP binary API message 'acl_plugin_get_version'.
-// Generated from '../../bin_api/acl.api.json', line 87:
+// Generated from 'acl.api.json', line 4:
//
// "acl_plugin_get_version",
// [
// "crc": "0x51077d14"
// }
//
-type ACLPluginGetVersion struct {
-}
+type ACLPluginGetVersion struct{}
func (*ACLPluginGetVersion) GetMessageName() string {
return "acl_plugin_get_version"
}
-func (*ACLPluginGetVersion) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLPluginGetVersion) GetCrcString() string {
return "51077d14"
}
+func (*ACLPluginGetVersion) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLPluginGetVersion() api.Message {
return &ACLPluginGetVersion{}
}
// ACLPluginGetVersionReply represents the VPP binary API message 'acl_plugin_get_version_reply'.
-// Generated from '../../bin_api/acl.api.json', line 105:
+// Generated from 'acl.api.json', line 22:
//
// "acl_plugin_get_version_reply",
// [
func (*ACLPluginGetVersionReply) GetMessageName() string {
return "acl_plugin_get_version_reply"
}
-func (*ACLPluginGetVersionReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLPluginGetVersionReply) GetCrcString() string {
return "9b32cf86"
}
+func (*ACLPluginGetVersionReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLPluginGetVersionReply() api.Message {
return &ACLPluginGetVersionReply{}
}
// ACLPluginControlPing represents the VPP binary API message 'acl_plugin_control_ping'.
-// Generated from '../../bin_api/acl.api.json', line 127:
+// Generated from 'acl.api.json', line 44:
//
// "acl_plugin_control_ping",
// [
// "crc": "0x51077d14"
// }
//
-type ACLPluginControlPing struct {
-}
+type ACLPluginControlPing struct{}
func (*ACLPluginControlPing) GetMessageName() string {
return "acl_plugin_control_ping"
}
-func (*ACLPluginControlPing) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLPluginControlPing) GetCrcString() string {
return "51077d14"
}
+func (*ACLPluginControlPing) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLPluginControlPing() api.Message {
return &ACLPluginControlPing{}
}
// ACLPluginControlPingReply represents the VPP binary API message 'acl_plugin_control_ping_reply'.
-// Generated from '../../bin_api/acl.api.json', line 145:
+// Generated from 'acl.api.json', line 62:
//
// "acl_plugin_control_ping_reply",
// [
type ACLPluginControlPingReply struct {
Retval int32
ClientIndex uint32
- VpePid uint32
+ VpePID uint32
}
func (*ACLPluginControlPingReply) GetMessageName() string {
return "acl_plugin_control_ping_reply"
}
-func (*ACLPluginControlPingReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLPluginControlPingReply) GetCrcString() string {
return "f6b0b8ca"
}
+func (*ACLPluginControlPingReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLPluginControlPingReply() api.Message {
return &ACLPluginControlPingReply{}
}
// ACLAddReplace represents the VPP binary API message 'acl_add_replace'.
-// Generated from '../../bin_api/acl.api.json', line 171:
+// Generated from 'acl.api.json', line 88:
//
// "acl_add_replace",
// [
func (*ACLAddReplace) GetMessageName() string {
return "acl_add_replace"
}
-func (*ACLAddReplace) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLAddReplace) GetCrcString() string {
return "e839997e"
}
+func (*ACLAddReplace) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLAddReplace() api.Message {
return &ACLAddReplace{}
}
// ACLAddReplaceReply represents the VPP binary API message 'acl_add_replace_reply'.
-// Generated from '../../bin_api/acl.api.json', line 208:
+// Generated from 'acl.api.json', line 125:
//
// "acl_add_replace_reply",
// [
func (*ACLAddReplaceReply) GetMessageName() string {
return "acl_add_replace_reply"
}
-func (*ACLAddReplaceReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLAddReplaceReply) GetCrcString() string {
return "ac407b0c"
}
+func (*ACLAddReplaceReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLAddReplaceReply() api.Message {
return &ACLAddReplaceReply{}
}
// ACLDel represents the VPP binary API message 'acl_del'.
-// Generated from '../../bin_api/acl.api.json', line 230:
+// Generated from 'acl.api.json', line 147:
//
// "acl_del",
// [
func (*ACLDel) GetMessageName() string {
return "acl_del"
}
-func (*ACLDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLDel) GetCrcString() string {
return "ef34fea4"
}
+func (*ACLDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLDel() api.Message {
return &ACLDel{}
}
// ACLDelReply represents the VPP binary API message 'acl_del_reply'.
-// Generated from '../../bin_api/acl.api.json', line 252:
+// Generated from 'acl.api.json', line 169:
//
// "acl_del_reply",
// [
func (*ACLDelReply) GetMessageName() string {
return "acl_del_reply"
}
-func (*ACLDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*ACLDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLDelReply() api.Message {
return &ACLDelReply{}
}
// ACLInterfaceAddDel represents the VPP binary API message 'acl_interface_add_del'.
-// Generated from '../../bin_api/acl.api.json', line 270:
+// Generated from 'acl.api.json', line 187:
//
// "acl_interface_add_del",
// [
func (*ACLInterfaceAddDel) GetMessageName() string {
return "acl_interface_add_del"
}
-func (*ACLInterfaceAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLInterfaceAddDel) GetCrcString() string {
return "0b2aedd1"
}
+func (*ACLInterfaceAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLInterfaceAddDel() api.Message {
return &ACLInterfaceAddDel{}
}
// ACLInterfaceAddDelReply represents the VPP binary API message 'acl_interface_add_del_reply'.
-// Generated from '../../bin_api/acl.api.json', line 304:
+// Generated from 'acl.api.json', line 221:
//
// "acl_interface_add_del_reply",
// [
func (*ACLInterfaceAddDelReply) GetMessageName() string {
return "acl_interface_add_del_reply"
}
-func (*ACLInterfaceAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLInterfaceAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*ACLInterfaceAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLInterfaceAddDelReply() api.Message {
return &ACLInterfaceAddDelReply{}
}
// ACLInterfaceSetACLList represents the VPP binary API message 'acl_interface_set_acl_list'.
-// Generated from '../../bin_api/acl.api.json', line 322:
+// Generated from 'acl.api.json', line 239:
//
// "acl_interface_set_acl_list",
// [
func (*ACLInterfaceSetACLList) GetMessageName() string {
return "acl_interface_set_acl_list"
}
-func (*ACLInterfaceSetACLList) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLInterfaceSetACLList) GetCrcString() string {
return "8baece38"
}
+func (*ACLInterfaceSetACLList) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLInterfaceSetACLList() api.Message {
return &ACLInterfaceSetACLList{}
}
// ACLInterfaceSetACLListReply represents the VPP binary API message 'acl_interface_set_acl_list_reply'.
-// Generated from '../../bin_api/acl.api.json', line 358:
+// Generated from 'acl.api.json', line 275:
//
// "acl_interface_set_acl_list_reply",
// [
func (*ACLInterfaceSetACLListReply) GetMessageName() string {
return "acl_interface_set_acl_list_reply"
}
-func (*ACLInterfaceSetACLListReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLInterfaceSetACLListReply) GetCrcString() string {
return "e8d4e804"
}
+func (*ACLInterfaceSetACLListReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLInterfaceSetACLListReply() api.Message {
return &ACLInterfaceSetACLListReply{}
}
// ACLDump represents the VPP binary API message 'acl_dump'.
-// Generated from '../../bin_api/acl.api.json', line 376:
+// Generated from 'acl.api.json', line 293:
//
// "acl_dump",
// [
func (*ACLDump) GetMessageName() string {
return "acl_dump"
}
-func (*ACLDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLDump) GetCrcString() string {
return "ef34fea4"
}
+func (*ACLDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLDump() api.Message {
return &ACLDump{}
}
// ACLDetails represents the VPP binary API message 'acl_details'.
-// Generated from '../../bin_api/acl.api.json', line 398:
+// Generated from 'acl.api.json', line 315:
//
// "acl_details",
// [
func (*ACLDetails) GetMessageName() string {
return "acl_details"
}
-func (*ACLDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLDetails) GetCrcString() string {
return "5bd895be"
}
+func (*ACLDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLDetails() api.Message {
return &ACLDetails{}
}
// ACLInterfaceListDump represents the VPP binary API message 'acl_interface_list_dump'.
-// Generated from '../../bin_api/acl.api.json', line 431:
+// Generated from 'acl.api.json', line 348:
//
// "acl_interface_list_dump",
// [
func (*ACLInterfaceListDump) GetMessageName() string {
return "acl_interface_list_dump"
}
-func (*ACLInterfaceListDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ACLInterfaceListDump) GetCrcString() string {
return "529cb13f"
}
+func (*ACLInterfaceListDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewACLInterfaceListDump() api.Message {
return &ACLInterfaceListDump{}
}
// ACLInterfaceListDetails represents the VPP binary API message 'acl_interface_list_details'.
-// Generated from '../../bin_api/acl.api.json', line 453:
+// Generated from 'acl.api.json', line 370:
//
// "acl_interface_list_details",
// [
func (*ACLInterfaceListDetails) GetMessageName() string {
return "acl_interface_list_details"
}
-func (*ACLInterfaceListDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ACLInterfaceListDetails) GetCrcString() string {
return "d5e80809"
}
+func (*ACLInterfaceListDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewACLInterfaceListDetails() api.Message {
return &ACLInterfaceListDetails{}
}
// MacipACLAdd represents the VPP binary API message 'macip_acl_add'.
-// Generated from '../../bin_api/acl.api.json', line 485:
+// Generated from 'acl.api.json', line 402:
//
// "macip_acl_add",
// [
func (*MacipACLAdd) GetMessageName() string {
return "macip_acl_add"
}
-func (*MacipACLAdd) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLAdd) GetCrcString() string {
return "b3d3d65a"
}
+func (*MacipACLAdd) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLAdd() api.Message {
return &MacipACLAdd{}
}
// MacipACLAddReply represents the VPP binary API message 'macip_acl_add_reply'.
-// Generated from '../../bin_api/acl.api.json', line 518:
+// Generated from 'acl.api.json', line 435:
//
// "macip_acl_add_reply",
// [
func (*MacipACLAddReply) GetMessageName() string {
return "macip_acl_add_reply"
}
-func (*MacipACLAddReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLAddReply) GetCrcString() string {
return "ac407b0c"
}
+func (*MacipACLAddReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLAddReply() api.Message {
return &MacipACLAddReply{}
}
// MacipACLAddReplace represents the VPP binary API message 'macip_acl_add_replace'.
-// Generated from '../../bin_api/acl.api.json', line 540:
+// Generated from 'acl.api.json', line 457:
//
// "macip_acl_add_replace",
// [
func (*MacipACLAddReplace) GetMessageName() string {
return "macip_acl_add_replace"
}
-func (*MacipACLAddReplace) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLAddReplace) GetCrcString() string {
return "a0e8c01b"
}
+func (*MacipACLAddReplace) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLAddReplace() api.Message {
return &MacipACLAddReplace{}
}
// MacipACLAddReplaceReply represents the VPP binary API message 'macip_acl_add_replace_reply'.
-// Generated from '../../bin_api/acl.api.json', line 577:
+// Generated from 'acl.api.json', line 494:
//
// "macip_acl_add_replace_reply",
// [
func (*MacipACLAddReplaceReply) GetMessageName() string {
return "macip_acl_add_replace_reply"
}
-func (*MacipACLAddReplaceReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLAddReplaceReply) GetCrcString() string {
return "ac407b0c"
}
+func (*MacipACLAddReplaceReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLAddReplaceReply() api.Message {
return &MacipACLAddReplaceReply{}
}
// MacipACLDel represents the VPP binary API message 'macip_acl_del'.
-// Generated from '../../bin_api/acl.api.json', line 599:
+// Generated from 'acl.api.json', line 516:
//
// "macip_acl_del",
// [
func (*MacipACLDel) GetMessageName() string {
return "macip_acl_del"
}
-func (*MacipACLDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLDel) GetCrcString() string {
return "ef34fea4"
}
+func (*MacipACLDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLDel() api.Message {
return &MacipACLDel{}
}
// MacipACLDelReply represents the VPP binary API message 'macip_acl_del_reply'.
-// Generated from '../../bin_api/acl.api.json', line 621:
+// Generated from 'acl.api.json', line 538:
//
// "macip_acl_del_reply",
// [
func (*MacipACLDelReply) GetMessageName() string {
return "macip_acl_del_reply"
}
-func (*MacipACLDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*MacipACLDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLDelReply() api.Message {
return &MacipACLDelReply{}
}
// MacipACLInterfaceAddDel represents the VPP binary API message 'macip_acl_interface_add_del'.
-// Generated from '../../bin_api/acl.api.json', line 639:
+// Generated from 'acl.api.json', line 556:
//
// "macip_acl_interface_add_del",
// [
func (*MacipACLInterfaceAddDel) GetMessageName() string {
return "macip_acl_interface_add_del"
}
-func (*MacipACLInterfaceAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLInterfaceAddDel) GetCrcString() string {
return "6a6be97c"
}
+func (*MacipACLInterfaceAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLInterfaceAddDel() api.Message {
return &MacipACLInterfaceAddDel{}
}
// MacipACLInterfaceAddDelReply represents the VPP binary API message 'macip_acl_interface_add_del_reply'.
-// Generated from '../../bin_api/acl.api.json', line 669:
+// Generated from 'acl.api.json', line 586:
//
// "macip_acl_interface_add_del_reply",
// [
func (*MacipACLInterfaceAddDelReply) GetMessageName() string {
return "macip_acl_interface_add_del_reply"
}
-func (*MacipACLInterfaceAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLInterfaceAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*MacipACLInterfaceAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLInterfaceAddDelReply() api.Message {
return &MacipACLInterfaceAddDelReply{}
}
// MacipACLDump represents the VPP binary API message 'macip_acl_dump'.
-// Generated from '../../bin_api/acl.api.json', line 687:
+// Generated from 'acl.api.json', line 604:
//
// "macip_acl_dump",
// [
func (*MacipACLDump) GetMessageName() string {
return "macip_acl_dump"
}
-func (*MacipACLDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLDump) GetCrcString() string {
return "ef34fea4"
}
+func (*MacipACLDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLDump() api.Message {
return &MacipACLDump{}
}
// MacipACLDetails represents the VPP binary API message 'macip_acl_details'.
-// Generated from '../../bin_api/acl.api.json', line 709:
+// Generated from 'acl.api.json', line 626:
//
// "macip_acl_details",
// [
func (*MacipACLDetails) GetMessageName() string {
return "macip_acl_details"
}
-func (*MacipACLDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLDetails) GetCrcString() string {
return "dd2b55ba"
}
+func (*MacipACLDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLDetails() api.Message {
return &MacipACLDetails{}
}
// MacipACLInterfaceGet represents the VPP binary API message 'macip_acl_interface_get'.
-// Generated from '../../bin_api/acl.api.json', line 742:
+// Generated from 'acl.api.json', line 659:
//
// "macip_acl_interface_get",
// [
// "crc": "0x51077d14"
// }
//
-type MacipACLInterfaceGet struct {
-}
+type MacipACLInterfaceGet struct{}
func (*MacipACLInterfaceGet) GetMessageName() string {
return "macip_acl_interface_get"
}
-func (*MacipACLInterfaceGet) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLInterfaceGet) GetCrcString() string {
return "51077d14"
}
+func (*MacipACLInterfaceGet) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLInterfaceGet() api.Message {
return &MacipACLInterfaceGet{}
}
// MacipACLInterfaceGetReply represents the VPP binary API message 'macip_acl_interface_get_reply'.
-// Generated from '../../bin_api/acl.api.json', line 760:
+// Generated from 'acl.api.json', line 677:
//
// "macip_acl_interface_get_reply",
// [
func (*MacipACLInterfaceGetReply) GetMessageName() string {
return "macip_acl_interface_get_reply"
}
-func (*MacipACLInterfaceGetReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLInterfaceGetReply) GetCrcString() string {
return "accf9b05"
}
+func (*MacipACLInterfaceGetReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLInterfaceGetReply() api.Message {
return &MacipACLInterfaceGetReply{}
}
// MacipACLInterfaceListDump represents the VPP binary API message 'macip_acl_interface_list_dump'.
-// Generated from '../../bin_api/acl.api.json', line 784:
+// Generated from 'acl.api.json', line 701:
//
// "macip_acl_interface_list_dump",
// [
func (*MacipACLInterfaceListDump) GetMessageName() string {
return "macip_acl_interface_list_dump"
}
-func (*MacipACLInterfaceListDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MacipACLInterfaceListDump) GetCrcString() string {
return "529cb13f"
}
+func (*MacipACLInterfaceListDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMacipACLInterfaceListDump() api.Message {
return &MacipACLInterfaceListDump{}
}
// MacipACLInterfaceListDetails represents the VPP binary API message 'macip_acl_interface_list_details'.
-// Generated from '../../bin_api/acl.api.json', line 806:
+// Generated from 'acl.api.json', line 723:
//
// "macip_acl_interface_list_details",
// [
func (*MacipACLInterfaceListDetails) GetMessageName() string {
return "macip_acl_interface_list_details"
}
-func (*MacipACLInterfaceListDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*MacipACLInterfaceListDetails) GetCrcString() string {
return "29783fa0"
}
+func (*MacipACLInterfaceListDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewMacipACLInterfaceListDetails() api.Message {
return &MacipACLInterfaceListDetails{}
}
+
+// ACLInterfaceSetEtypeWhitelist represents the VPP binary API message 'acl_interface_set_etype_whitelist'.
+// Generated from 'acl.api.json', line 751:
+//
+// "acl_interface_set_etype_whitelist",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "count"
+// ],
+// [
+// "u8",
+// "n_input"
+// ],
+// [
+// "u16",
+// "whitelist",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0xf515efc5"
+// }
+//
+type ACLInterfaceSetEtypeWhitelist struct {
+ SwIfIndex uint32
+ Count uint8 `struc:"sizeof=Whitelist"`
+ NInput uint8
+ Whitelist []uint16
+}
+
+func (*ACLInterfaceSetEtypeWhitelist) GetMessageName() string {
+ return "acl_interface_set_etype_whitelist"
+}
+func (*ACLInterfaceSetEtypeWhitelist) GetCrcString() string {
+ return "f515efc5"
+}
+func (*ACLInterfaceSetEtypeWhitelist) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewACLInterfaceSetEtypeWhitelist() api.Message {
+ return &ACLInterfaceSetEtypeWhitelist{}
+}
+
+// ACLInterfaceSetEtypeWhitelistReply represents the VPP binary API message 'acl_interface_set_etype_whitelist_reply'.
+// Generated from 'acl.api.json', line 787:
+//
+// "acl_interface_set_etype_whitelist_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type ACLInterfaceSetEtypeWhitelistReply struct {
+ Retval int32
+}
+
+func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageName() string {
+ return "acl_interface_set_etype_whitelist_reply"
+}
+func (*ACLInterfaceSetEtypeWhitelistReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewACLInterfaceSetEtypeWhitelistReply() api.Message {
+ return &ACLInterfaceSetEtypeWhitelistReply{}
+}
+
+// ACLInterfaceEtypeWhitelistDump represents the VPP binary API message 'acl_interface_etype_whitelist_dump'.
+// Generated from 'acl.api.json', line 805:
+//
+// "acl_interface_etype_whitelist_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0x529cb13f"
+// }
+//
+type ACLInterfaceEtypeWhitelistDump struct {
+ SwIfIndex uint32
+}
+
+func (*ACLInterfaceEtypeWhitelistDump) GetMessageName() string {
+ return "acl_interface_etype_whitelist_dump"
+}
+func (*ACLInterfaceEtypeWhitelistDump) GetCrcString() string {
+ return "529cb13f"
+}
+func (*ACLInterfaceEtypeWhitelistDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewACLInterfaceEtypeWhitelistDump() api.Message {
+ return &ACLInterfaceEtypeWhitelistDump{}
+}
+
+// ACLInterfaceEtypeWhitelistDetails represents the VPP binary API message 'acl_interface_etype_whitelist_details'.
+// Generated from 'acl.api.json', line 827:
+//
+// "acl_interface_etype_whitelist_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "count"
+// ],
+// [
+// "u8",
+// "n_input"
+// ],
+// [
+// "u16",
+// "whitelist",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0x6a5d4e81"
+// }
+//
+type ACLInterfaceEtypeWhitelistDetails struct {
+ SwIfIndex uint32
+ Count uint8 `struc:"sizeof=Whitelist"`
+ NInput uint8
+ Whitelist []uint16
+}
+
+func (*ACLInterfaceEtypeWhitelistDetails) GetMessageName() string {
+ return "acl_interface_etype_whitelist_details"
+}
+func (*ACLInterfaceEtypeWhitelistDetails) GetCrcString() string {
+ return "6a5d4e81"
+}
+func (*ACLInterfaceEtypeWhitelistDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewACLInterfaceEtypeWhitelistDetails() api.Message {
+ return &ACLInterfaceEtypeWhitelistDetails{}
+}
+
+/* Services */
+
+type Services interface {
+ DumpACL(*ACLDump) (*ACLDetails, error)
+ DumpACLInterfaceEtypeWhitelist(*ACLInterfaceEtypeWhitelistDump) (*ACLInterfaceEtypeWhitelistDetails, error)
+ DumpACLInterfaceList(*ACLInterfaceListDump) (*ACLInterfaceListDetails, error)
+ DumpMacipACL(*MacipACLDump) (*MacipACLDetails, error)
+ DumpMacipACLInterfaceList(*MacipACLInterfaceListDump) (*MacipACLInterfaceListDetails, error)
+ ACLAddReplace(*ACLAddReplace) (*ACLAddReplaceReply, error)
+ ACLDel(*ACLDel) (*ACLDelReply, error)
+ ACLInterfaceAddDel(*ACLInterfaceAddDel) (*ACLInterfaceAddDelReply, error)
+ ACLInterfaceSetACLList(*ACLInterfaceSetACLList) (*ACLInterfaceSetACLListReply, error)
+ ACLInterfaceSetEtypeWhitelist(*ACLInterfaceSetEtypeWhitelist) (*ACLInterfaceSetEtypeWhitelistReply, error)
+ ACLPluginControlPing(*ACLPluginControlPing) (*ACLPluginControlPingReply, error)
+ ACLPluginGetVersion(*ACLPluginGetVersion) (*ACLPluginGetVersionReply, error)
+ MacipACLAdd(*MacipACLAdd) (*MacipACLAddReply, error)
+ MacipACLAddReplace(*MacipACLAddReplace) (*MacipACLAddReplaceReply, error)
+ MacipACLDel(*MacipACLDel) (*MacipACLDelReply, error)
+ MacipACLInterfaceAddDel(*MacipACLInterfaceAddDel) (*MacipACLInterfaceAddDelReply, error)
+ MacipACLInterfaceGet(*MacipACLInterfaceGet) (*MacipACLInterfaceGetReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*ACLPluginGetVersion)(nil), "acl.ACLPluginGetVersion")
+ api.RegisterMessage((*ACLPluginGetVersionReply)(nil), "acl.ACLPluginGetVersionReply")
+ api.RegisterMessage((*ACLPluginControlPing)(nil), "acl.ACLPluginControlPing")
+ api.RegisterMessage((*ACLPluginControlPingReply)(nil), "acl.ACLPluginControlPingReply")
+ api.RegisterMessage((*ACLAddReplace)(nil), "acl.ACLAddReplace")
+ api.RegisterMessage((*ACLAddReplaceReply)(nil), "acl.ACLAddReplaceReply")
+ api.RegisterMessage((*ACLDel)(nil), "acl.ACLDel")
+ api.RegisterMessage((*ACLDelReply)(nil), "acl.ACLDelReply")
+ api.RegisterMessage((*ACLInterfaceAddDel)(nil), "acl.ACLInterfaceAddDel")
+ api.RegisterMessage((*ACLInterfaceAddDelReply)(nil), "acl.ACLInterfaceAddDelReply")
+ api.RegisterMessage((*ACLInterfaceSetACLList)(nil), "acl.ACLInterfaceSetACLList")
+ api.RegisterMessage((*ACLInterfaceSetACLListReply)(nil), "acl.ACLInterfaceSetACLListReply")
+ api.RegisterMessage((*ACLDump)(nil), "acl.ACLDump")
+ api.RegisterMessage((*ACLDetails)(nil), "acl.ACLDetails")
+ api.RegisterMessage((*ACLInterfaceListDump)(nil), "acl.ACLInterfaceListDump")
+ api.RegisterMessage((*ACLInterfaceListDetails)(nil), "acl.ACLInterfaceListDetails")
+ api.RegisterMessage((*MacipACLAdd)(nil), "acl.MacipACLAdd")
+ api.RegisterMessage((*MacipACLAddReply)(nil), "acl.MacipACLAddReply")
+ api.RegisterMessage((*MacipACLAddReplace)(nil), "acl.MacipACLAddReplace")
+ api.RegisterMessage((*MacipACLAddReplaceReply)(nil), "acl.MacipACLAddReplaceReply")
+ api.RegisterMessage((*MacipACLDel)(nil), "acl.MacipACLDel")
+ api.RegisterMessage((*MacipACLDelReply)(nil), "acl.MacipACLDelReply")
+ api.RegisterMessage((*MacipACLInterfaceAddDel)(nil), "acl.MacipACLInterfaceAddDel")
+ api.RegisterMessage((*MacipACLInterfaceAddDelReply)(nil), "acl.MacipACLInterfaceAddDelReply")
+ api.RegisterMessage((*MacipACLDump)(nil), "acl.MacipACLDump")
+ api.RegisterMessage((*MacipACLDetails)(nil), "acl.MacipACLDetails")
+ api.RegisterMessage((*MacipACLInterfaceGet)(nil), "acl.MacipACLInterfaceGet")
+ api.RegisterMessage((*MacipACLInterfaceGetReply)(nil), "acl.MacipACLInterfaceGetReply")
+ api.RegisterMessage((*MacipACLInterfaceListDump)(nil), "acl.MacipACLInterfaceListDump")
+ api.RegisterMessage((*MacipACLInterfaceListDetails)(nil), "acl.MacipACLInterfaceListDetails")
+ api.RegisterMessage((*ACLInterfaceSetEtypeWhitelist)(nil), "acl.ACLInterfaceSetEtypeWhitelist")
+ api.RegisterMessage((*ACLInterfaceSetEtypeWhitelistReply)(nil), "acl.ACLInterfaceSetEtypeWhitelistReply")
+ api.RegisterMessage((*ACLInterfaceEtypeWhitelistDump)(nil), "acl.ACLInterfaceEtypeWhitelistDump")
+ api.RegisterMessage((*ACLInterfaceEtypeWhitelistDetails)(nil), "acl.ACLInterfaceEtypeWhitelistDetails")
+}
{
- "services": [
- {
- "af_packet_delete": {
- "reply": "af_packet_delete_reply"
- }
- },
- {
- "af_packet_create": {
- "reply": "af_packet_create_reply"
- }
- },
- {
- "af_packet_set_l4_cksum_offload": {
- "reply": "af_packet_set_l4_cksum_offload_reply"
- }
- }
- ],
- "vl_api_version": "0x8957ca8b",
- "enums": [],
"messages": [
[
"af_packet_create",
{
"crc": "0xe8d4e804"
}
+ ],
+ [
+ "af_packet_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ {
+ "crc": "0x51077d14"
+ }
+ ],
+ [
+ "af_packet_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "host_if_name",
+ 64
+ ],
+ {
+ "crc": "0x057205fa"
+ }
]
],
+ "vl_api_version": "0x206563c",
+ "unions": [],
+ "services": {
+ "af_packet_dump": {
+ "reply": "af_packet_details",
+ "stream": true
+ },
+ "af_packet_set_l4_cksum_offload": {
+ "reply": "af_packet_set_l4_cksum_offload_reply"
+ },
+ "af_packet_delete": {
+ "reply": "af_packet_delete_reply"
+ },
+ "af_packet_create": {
+ "reply": "af_packet_create_reply"
+ }
+ },
+ "enums": [],
"types": []
}
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package af_packet represents the VPP binary API of the 'af_packet' VPP module.
-// Generated from '../../bin_api/af_packet.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: af_packet.api.json
+
+/*
+Package af_packet is a generated VPP binary API of the 'af_packet' VPP module.
+
+It is generated from this file:
+ af_packet.api.json
+
+It contains these VPP binary API objects:
+ 8 messages
+ 4 services
+*/
package af_packet
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0x8957ca8b
+/* Messages */
// AfPacketCreate represents the VPP binary API message 'af_packet_create'.
-// Generated from '../../bin_api/af_packet.api.json', line 23:
+// Generated from 'af_packet.api.json', line 4:
//
// "af_packet_create",
// [
func (*AfPacketCreate) GetMessageName() string {
return "af_packet_create"
}
-func (*AfPacketCreate) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*AfPacketCreate) GetCrcString() string {
return "6d5d30d6"
}
+func (*AfPacketCreate) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewAfPacketCreate() api.Message {
return &AfPacketCreate{}
}
// AfPacketCreateReply represents the VPP binary API message 'af_packet_create_reply'.
-// Generated from '../../bin_api/af_packet.api.json', line 55:
+// Generated from 'af_packet.api.json', line 36:
//
// "af_packet_create_reply",
// [
func (*AfPacketCreateReply) GetMessageName() string {
return "af_packet_create_reply"
}
-func (*AfPacketCreateReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*AfPacketCreateReply) GetCrcString() string {
return "fda5941f"
}
+func (*AfPacketCreateReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewAfPacketCreateReply() api.Message {
return &AfPacketCreateReply{}
}
// AfPacketDelete represents the VPP binary API message 'af_packet_delete'.
-// Generated from '../../bin_api/af_packet.api.json', line 77:
+// Generated from 'af_packet.api.json', line 58:
//
// "af_packet_delete",
// [
func (*AfPacketDelete) GetMessageName() string {
return "af_packet_delete"
}
-func (*AfPacketDelete) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*AfPacketDelete) GetCrcString() string {
return "3efceda3"
}
+func (*AfPacketDelete) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewAfPacketDelete() api.Message {
return &AfPacketDelete{}
}
// AfPacketDeleteReply represents the VPP binary API message 'af_packet_delete_reply'.
-// Generated from '../../bin_api/af_packet.api.json', line 100:
+// Generated from 'af_packet.api.json', line 81:
//
// "af_packet_delete_reply",
// [
func (*AfPacketDeleteReply) GetMessageName() string {
return "af_packet_delete_reply"
}
-func (*AfPacketDeleteReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*AfPacketDeleteReply) GetCrcString() string {
return "e8d4e804"
}
+func (*AfPacketDeleteReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewAfPacketDeleteReply() api.Message {
return &AfPacketDeleteReply{}
}
// AfPacketSetL4CksumOffload represents the VPP binary API message 'af_packet_set_l4_cksum_offload'.
-// Generated from '../../bin_api/af_packet.api.json', line 118:
+// Generated from 'af_packet.api.json', line 99:
//
// "af_packet_set_l4_cksum_offload",
// [
func (*AfPacketSetL4CksumOffload) GetMessageName() string {
return "af_packet_set_l4_cksum_offload"
}
-func (*AfPacketSetL4CksumOffload) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*AfPacketSetL4CksumOffload) GetCrcString() string {
return "86538585"
}
+func (*AfPacketSetL4CksumOffload) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewAfPacketSetL4CksumOffload() api.Message {
return &AfPacketSetL4CksumOffload{}
}
// AfPacketSetL4CksumOffloadReply represents the VPP binary API message 'af_packet_set_l4_cksum_offload_reply'.
-// Generated from '../../bin_api/af_packet.api.json', line 144:
+// Generated from 'af_packet.api.json', line 125:
//
// "af_packet_set_l4_cksum_offload_reply",
// [
func (*AfPacketSetL4CksumOffloadReply) GetMessageName() string {
return "af_packet_set_l4_cksum_offload_reply"
}
-func (*AfPacketSetL4CksumOffloadReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*AfPacketSetL4CksumOffloadReply) GetCrcString() string {
return "e8d4e804"
}
+func (*AfPacketSetL4CksumOffloadReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewAfPacketSetL4CksumOffloadReply() api.Message {
return &AfPacketSetL4CksumOffloadReply{}
}
+
+// AfPacketDump represents the VPP binary API message 'af_packet_dump'.
+// Generated from 'af_packet.api.json', line 143:
+//
+// "af_packet_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type AfPacketDump struct{}
+
+func (*AfPacketDump) GetMessageName() string {
+ return "af_packet_dump"
+}
+func (*AfPacketDump) GetCrcString() string {
+ return "51077d14"
+}
+func (*AfPacketDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewAfPacketDump() api.Message {
+ return &AfPacketDump{}
+}
+
+// AfPacketDetails represents the VPP binary API message 'af_packet_details'.
+// Generated from 'af_packet.api.json', line 161:
+//
+// "af_packet_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "host_if_name",
+// 64
+// ],
+// {
+// "crc": "0x057205fa"
+// }
+//
+type AfPacketDetails struct {
+ SwIfIndex uint32
+ HostIfName []byte `struc:"[64]byte"`
+}
+
+func (*AfPacketDetails) GetMessageName() string {
+ return "af_packet_details"
+}
+func (*AfPacketDetails) GetCrcString() string {
+ return "057205fa"
+}
+func (*AfPacketDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewAfPacketDetails() api.Message {
+ return &AfPacketDetails{}
+}
+
+/* Services */
+
+type Services interface {
+ DumpAfPacket(*AfPacketDump) (*AfPacketDetails, error)
+ AfPacketCreate(*AfPacketCreate) (*AfPacketCreateReply, error)
+ AfPacketDelete(*AfPacketDelete) (*AfPacketDeleteReply, error)
+ AfPacketSetL4CksumOffload(*AfPacketSetL4CksumOffload) (*AfPacketSetL4CksumOffloadReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*AfPacketCreate)(nil), "af_packet.AfPacketCreate")
+ api.RegisterMessage((*AfPacketCreateReply)(nil), "af_packet.AfPacketCreateReply")
+ api.RegisterMessage((*AfPacketDelete)(nil), "af_packet.AfPacketDelete")
+ api.RegisterMessage((*AfPacketDeleteReply)(nil), "af_packet.AfPacketDeleteReply")
+ api.RegisterMessage((*AfPacketSetL4CksumOffload)(nil), "af_packet.AfPacketSetL4CksumOffload")
+ api.RegisterMessage((*AfPacketSetL4CksumOffloadReply)(nil), "af_packet.AfPacketSetL4CksumOffloadReply")
+ api.RegisterMessage((*AfPacketDump)(nil), "af_packet.AfPacketDump")
+ api.RegisterMessage((*AfPacketDetails)(nil), "af_packet.AfPacketDetails")
+}
--- /dev/null
+package bin_api
+
+// Generates Go bindings for all VPP APIs located in the json directory.
+//go:generate binapi-generator --input-dir=. --output-dir=.
{
- "services": [
- {
- "create_subif": {
- "reply": "create_subif_reply"
- }
- },
- {
- "delete_subif": {
- "reply": "delete_subif_reply"
- }
- },
- {
- "sw_interface_tag_add_del": {
- "reply": "sw_interface_tag_add_del_reply"
- }
- },
- {
- "sw_interface_event": {
- "reply": null
- }
- },
- {
- "sw_interface_set_rx_mode": {
- "reply": "sw_interface_set_rx_mode_reply"
- }
- },
- {
- "sw_interface_dump": {
- "reply": "sw_interface_details",
- "stream": true
- }
- },
- {
- "sw_interface_get_table": {
- "reply": "sw_interface_get_table_reply"
- }
- },
- {
- "sw_interface_add_del_address": {
- "reply": "sw_interface_add_del_address_reply"
- }
- },
- {
- "interface_name_renumber": {
- "reply": "interface_name_renumber_reply"
- }
- },
- {
- "create_loopback_instance": {
- "reply": "create_loopback_instance_reply"
- }
- },
- {
- "sw_interface_set_mtu": {
- "reply": "sw_interface_set_mtu_reply"
- }
- },
- {
- "create_loopback": {
- "reply": "create_loopback_reply"
- }
- },
- {
- "sw_interface_clear_stats": {
- "reply": "sw_interface_clear_stats_reply"
- }
- },
- {
- "create_vlan_subif": {
- "reply": "create_vlan_subif_reply"
- }
- },
- {
- "sw_interface_set_mac_address": {
- "reply": "sw_interface_set_mac_address_reply"
- }
- },
- {
- "sw_interface_set_table": {
- "reply": "sw_interface_set_table_reply"
- }
- },
- {
- "sw_interface_set_flags": {
- "reply": "sw_interface_set_flags_reply"
- }
- },
- {
- "delete_loopback": {
- "reply": "delete_loopback_reply"
- }
- },
- {
- "want_interface_events": {
- "reply": "want_interface_events_reply"
- }
- },
- {
- "sw_interface_set_unnumbered": {
- "reply": "sw_interface_set_unnumbered_reply"
- }
- }
- ],
- "vl_api_version": "0xa9b5d13",
- "enums": [],
"messages": [
[
"sw_interface_set_flags",
}
],
[
- "sw_interface_set_mtu",
+ "hw_interface_set_mtu",
[
"u16",
"_vl_msg_id"
"crc": "0x132da1e7"
}
],
+ [
+ "hw_interface_set_mtu_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "sw_interface_set_mtu",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u32",
+ "mtu",
+ 4
+ ],
+ {
+ "crc": "0xd0008db8"
+ }
+ ],
[
"sw_interface_set_mtu_reply",
[
"u16",
"link_mtu"
],
+ [
+ "u32",
+ "mtu",
+ 4
+ ],
[
"u32",
"sub_id"
"i_sid"
],
{
- "crc": "0x23dee0ff"
+ "crc": "0x09b4b510"
}
],
[
}
],
[
- "vnet_interface_simple_counters",
- [
- "u16",
- "_vl_msg_id"
- ],
- [
- "u8",
- "vnet_counter_type"
- ],
- [
- "u32",
- "first_sw_if_index"
- ],
- [
- "u32",
- "count"
- ],
- [
- "u64",
- "data",
- 0,
- "count"
- ],
- {
- "crc": "0x9bc4a808"
- }
- ],
- [
- "vnet_interface_combined_counters",
+ "sw_interface_set_unnumbered",
[
"u16",
"_vl_msg_id"
],
- [
- "u8",
- "vnet_counter_type"
- ],
[
"u32",
- "first_sw_if_index"
+ "client_index"
],
[
"u32",
- "count"
- ],
- [
- "vl_api_vlib_counter_t",
- "data",
- 0,
- "count"
- ],
- {
- "crc": "0x2c595002"
- }
- ],
- [
- "vnet_per_interface_simple_counters",
- [
- "u16",
- "_vl_msg_id"
+ "context"
],
[
"u32",
- "count"
+ "sw_if_index"
],
[
"u32",
- "timestamp"
+ "unnumbered_sw_if_index"
],
[
- "vl_api_vnet_simple_counter_t",
- "data",
- 0,
- "count"
+ "u8",
+ "is_add"
],
{
- "crc": "0xd1fba9ba"
+ "crc": "0xa2c1bbda"
}
],
[
- "vnet_per_interface_combined_counters",
+ "sw_interface_set_unnumbered_reply",
[
"u16",
"_vl_msg_id"
],
[
"u32",
- "count"
- ],
- [
- "u32",
- "timestamp"
+ "context"
],
[
- "vl_api_vnet_combined_counter_t",
- "data",
- 0,
- "count"
+ "i32",
+ "retval"
],
{
- "crc": "0xdc578375"
+ "crc": "0xe8d4e804"
}
],
[
- "sw_interface_set_unnumbered",
+ "sw_interface_clear_stats",
[
"u16",
"_vl_msg_id"
"u32",
"sw_if_index"
],
- [
- "u32",
- "unnumbered_sw_if_index"
- ],
- [
- "u8",
- "is_add"
- ],
{
- "crc": "0xa2c1bbda"
+ "crc": "0x529cb13f"
}
],
[
- "sw_interface_set_unnumbered_reply",
+ "sw_interface_clear_stats_reply",
[
"u16",
"_vl_msg_id"
}
],
[
- "sw_interface_clear_stats",
+ "sw_interface_tag_add_del",
[
"u16",
"_vl_msg_id"
"u32",
"context"
],
+ [
+ "u8",
+ "is_add"
+ ],
[
"u32",
"sw_if_index"
],
+ [
+ "u8",
+ "tag",
+ 64
+ ],
{
- "crc": "0x529cb13f"
+ "crc": "0x14cc636c"
}
],
[
- "sw_interface_clear_stats_reply",
+ "sw_interface_tag_add_del_reply",
[
"u16",
"_vl_msg_id"
}
],
[
- "sw_interface_tag_add_del",
+ "sw_interface_set_mac_address",
[
"u16",
"_vl_msg_id"
"u32",
"context"
],
- [
- "u8",
- "is_add"
- ],
[
"u32",
"sw_if_index"
],
[
"u8",
- "tag",
- 64
+ "mac_address",
+ 6
],
{
- "crc": "0x14cc636c"
+ "crc": "0xeed5dfca"
}
],
[
- "sw_interface_tag_add_del_reply",
+ "sw_interface_set_mac_address_reply",
[
"u16",
"_vl_msg_id"
}
],
[
- "sw_interface_set_mac_address",
+ "sw_interface_get_mac_address",
[
"u16",
"_vl_msg_id"
"u32",
"sw_if_index"
],
- [
- "u8",
- "mac_address",
- 6
- ],
{
- "crc": "0xeed5dfca"
+ "crc": "0x529cb13f"
}
],
[
- "sw_interface_set_mac_address_reply",
+ "sw_interface_get_mac_address_reply",
[
"u16",
"_vl_msg_id"
"i32",
"retval"
],
+ [
+ "u8",
+ "mac_address",
+ 6
+ ],
{
- "crc": "0xe8d4e804"
+ "crc": "0x8ea538d3"
}
],
[
{
"crc": "0xe8d4e804"
}
+ ],
+ [
+ "collect_detailed_interface_stats",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "enable_disable"
+ ],
+ {
+ "crc": "0x69d24598"
+ }
+ ],
+ [
+ "collect_detailed_interface_stats_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
]
],
+ "vl_api_version": "0x6a38a271",
+ "unions": [],
+ "services": {
+ "create_subif": {
+ "reply": "create_subif_reply"
+ },
+ "delete_subif": {
+ "reply": "delete_subif_reply"
+ },
+ "sw_interface_tag_add_del": {
+ "reply": "sw_interface_tag_add_del_reply"
+ },
+ "collect_detailed_interface_stats": {
+ "reply": "collect_detailed_interface_stats_reply"
+ },
+ "sw_interface_dump": {
+ "reply": "sw_interface_details",
+ "stream": true
+ },
+ "sw_interface_add_del_address": {
+ "reply": "sw_interface_add_del_address_reply"
+ },
+ "sw_interface_get_table": {
+ "reply": "sw_interface_get_table_reply"
+ },
+ "interface_name_renumber": {
+ "reply": "interface_name_renumber_reply"
+ },
+ "create_loopback_instance": {
+ "reply": "create_loopback_instance_reply"
+ },
+ "sw_interface_get_mac_address": {
+ "reply": "sw_interface_get_mac_address_reply"
+ },
+ "want_interface_events": {
+ "reply": "want_interface_events_reply",
+ "events": [
+ "sw_interface_event"
+ ]
+ },
+ "create_loopback": {
+ "reply": "create_loopback_reply"
+ },
+ "sw_interface_clear_stats": {
+ "reply": "sw_interface_clear_stats_reply"
+ },
+ "hw_interface_set_mtu": {
+ "reply": "hw_interface_set_mtu_reply"
+ },
+ "sw_interface_set_mac_address": {
+ "reply": "sw_interface_set_mac_address_reply"
+ },
+ "sw_interface_set_table": {
+ "reply": "sw_interface_set_table_reply"
+ },
+ "sw_interface_set_mtu": {
+ "reply": "sw_interface_set_mtu_reply"
+ },
+ "sw_interface_set_flags": {
+ "reply": "sw_interface_set_flags_reply"
+ },
+ "delete_loopback": {
+ "reply": "delete_loopback_reply"
+ },
+ "sw_interface_set_rx_mode": {
+ "reply": "sw_interface_set_rx_mode_reply"
+ },
+ "create_vlan_subif": {
+ "reply": "create_vlan_subif_reply"
+ },
+ "sw_interface_set_unnumbered": {
+ "reply": "sw_interface_set_unnumbered_reply"
+ }
+ },
+ "enums": [],
"types": [
[
"vlib_counter",
"u64",
"rx_bytes"
],
+ [
+ "u64",
+ "rx_unicast_packets"
+ ],
+ [
+ "u64",
+ "rx_unicast_bytes"
+ ],
+ [
+ "u64",
+ "rx_multicast_packets"
+ ],
+ [
+ "u64",
+ "rx_multicast_bytes"
+ ],
+ [
+ "u64",
+ "rx_broadcast_packets"
+ ],
+ [
+ "u64",
+ "rx_broadcast_bytes"
+ ],
[
"u64",
"tx_packets"
"u64",
"tx_bytes"
],
+ [
+ "u64",
+ "tx_unicast_packets"
+ ],
+ [
+ "u64",
+ "tx_unicast_bytes"
+ ],
+ [
+ "u64",
+ "tx_multicast_packets"
+ ],
+ [
+ "u64",
+ "tx_multicast_bytes"
+ ],
+ [
+ "u64",
+ "tx_broadcast_packets"
+ ],
+ [
+ "u64",
+ "tx_broadcast_bytes"
+ ],
{
- "crc": "0x3217ba8e"
+ "crc": "0x20905ca4"
}
],
[
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package interfaces represents the VPP binary API of the 'interfaces' VPP module.
-// Generated from '../../bin_api/interface.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: interface.api.json
+
+/*
+Package interfaces is a generated VPP binary API of the 'interface' VPP module.
+
+It is generated from this file:
+ interface.api.json
+
+It contains these VPP binary API objects:
+ 45 messages
+ 3 types
+ 22 services
+*/
package interfaces
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0xa9b5d13
+/* Types */
-// VlibCounter represents the VPP binary API data type 'vlib_counter'.
-// Generated from '../../bin_api/interface.api.json', line 1296:
+// VlibCounter represents the VPP binary API type 'vlib_counter'.
+// Generated from 'interface.api.json', line 1301:
//
// "vlib_counter",
// [
return "ce2325a2"
}
-// VnetCombinedCounter represents the VPP binary API data type 'vnet_combined_counter'.
-// Generated from '../../bin_api/interface.api.json', line 1310:
+// VnetCombinedCounter represents the VPP binary API type 'vnet_combined_counter'.
+// Generated from 'interface.api.json', line 1315:
//
// "vnet_combined_counter",
// [
// ],
// [
// "u64",
+// "rx_unicast_packets"
+// ],
+// [
+// "u64",
+// "rx_unicast_bytes"
+// ],
+// [
+// "u64",
+// "rx_multicast_packets"
+// ],
+// [
+// "u64",
+// "rx_multicast_bytes"
+// ],
+// [
+// "u64",
+// "rx_broadcast_packets"
+// ],
+// [
+// "u64",
+// "rx_broadcast_bytes"
+// ],
+// [
+// "u64",
// "tx_packets"
// ],
// [
// "u64",
// "tx_bytes"
// ],
+// [
+// "u64",
+// "tx_unicast_packets"
+// ],
+// [
+// "u64",
+// "tx_unicast_bytes"
+// ],
+// [
+// "u64",
+// "tx_multicast_packets"
+// ],
+// [
+// "u64",
+// "tx_multicast_bytes"
+// ],
+// [
+// "u64",
+// "tx_broadcast_packets"
+// ],
+// [
+// "u64",
+// "tx_broadcast_bytes"
+// ],
// {
-// "crc": "0x3217ba8e"
+// "crc": "0x20905ca4"
// }
//
type VnetCombinedCounter struct {
- SwIfIndex uint32
- RxPackets uint64
- RxBytes uint64
- TxPackets uint64
- TxBytes uint64
+ SwIfIndex uint32
+ RxPackets uint64
+ RxBytes uint64
+ RxUnicastPackets uint64
+ RxUnicastBytes uint64
+ RxMulticastPackets uint64
+ RxMulticastBytes uint64
+ RxBroadcastPackets uint64
+ RxBroadcastBytes uint64
+ TxPackets uint64
+ TxBytes uint64
+ TxUnicastPackets uint64
+ TxUnicastBytes uint64
+ TxMulticastPackets uint64
+ TxMulticastBytes uint64
+ TxBroadcastPackets uint64
+ TxBroadcastBytes uint64
}
func (*VnetCombinedCounter) GetTypeName() string {
return "vnet_combined_counter"
}
func (*VnetCombinedCounter) GetCrcString() string {
- return "3217ba8e"
+ return "20905ca4"
}
-// VnetSimpleCounter represents the VPP binary API data type 'vnet_simple_counter'.
-// Generated from '../../bin_api/interface.api.json', line 1336:
+// VnetSimpleCounter represents the VPP binary API type 'vnet_simple_counter'.
+// Generated from 'interface.api.json', line 1389:
//
// "vnet_simple_counter",
// [
return "8bd65e2d"
}
+/* Messages */
+
// SwInterfaceSetFlags represents the VPP binary API message 'sw_interface_set_flags'.
-// Generated from '../../bin_api/interface.api.json', line 109:
+// Generated from 'interface.api.json', line 4:
//
// "sw_interface_set_flags",
// [
func (*SwInterfaceSetFlags) GetMessageName() string {
return "sw_interface_set_flags"
}
-func (*SwInterfaceSetFlags) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceSetFlags) GetCrcString() string {
return "555485f5"
}
+func (*SwInterfaceSetFlags) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceSetFlags() api.Message {
return &SwInterfaceSetFlags{}
}
// SwInterfaceSetFlagsReply represents the VPP binary API message 'sw_interface_set_flags_reply'.
-// Generated from '../../bin_api/interface.api.json', line 135:
+// Generated from 'interface.api.json', line 30:
//
// "sw_interface_set_flags_reply",
// [
func (*SwInterfaceSetFlagsReply) GetMessageName() string {
return "sw_interface_set_flags_reply"
}
-func (*SwInterfaceSetFlagsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceSetFlagsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceSetFlagsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceSetFlagsReply() api.Message {
return &SwInterfaceSetFlagsReply{}
}
-// SwInterfaceSetMtu represents the VPP binary API message 'sw_interface_set_mtu'.
-// Generated from '../../bin_api/interface.api.json', line 153:
+// HwInterfaceSetMtu represents the VPP binary API message 'hw_interface_set_mtu'.
+// Generated from 'interface.api.json', line 48:
//
-// "sw_interface_set_mtu",
+// "hw_interface_set_mtu",
// [
// "u16",
// "_vl_msg_id"
// "crc": "0x132da1e7"
// }
//
-type SwInterfaceSetMtu struct {
+type HwInterfaceSetMtu struct {
SwIfIndex uint32
Mtu uint16
}
+func (*HwInterfaceSetMtu) GetMessageName() string {
+ return "hw_interface_set_mtu"
+}
+func (*HwInterfaceSetMtu) GetCrcString() string {
+ return "132da1e7"
+}
+func (*HwInterfaceSetMtu) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewHwInterfaceSetMtu() api.Message {
+ return &HwInterfaceSetMtu{}
+}
+
+// HwInterfaceSetMtuReply represents the VPP binary API message 'hw_interface_set_mtu_reply'.
+// Generated from 'interface.api.json', line 74:
+//
+// "hw_interface_set_mtu_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type HwInterfaceSetMtuReply struct {
+ Retval int32
+}
+
+func (*HwInterfaceSetMtuReply) GetMessageName() string {
+ return "hw_interface_set_mtu_reply"
+}
+func (*HwInterfaceSetMtuReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*HwInterfaceSetMtuReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewHwInterfaceSetMtuReply() api.Message {
+ return &HwInterfaceSetMtuReply{}
+}
+
+// SwInterfaceSetMtu represents the VPP binary API message 'sw_interface_set_mtu'.
+// Generated from 'interface.api.json', line 92:
+//
+// "sw_interface_set_mtu",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u32",
+// "mtu",
+// 4
+// ],
+// {
+// "crc": "0xd0008db8"
+// }
+//
+type SwInterfaceSetMtu struct {
+ SwIfIndex uint32
+ Mtu []uint32 `struc:"[4]uint32"`
+}
+
func (*SwInterfaceSetMtu) GetMessageName() string {
return "sw_interface_set_mtu"
}
+func (*SwInterfaceSetMtu) GetCrcString() string {
+ return "d0008db8"
+}
func (*SwInterfaceSetMtu) GetMessageType() api.MessageType {
return api.RequestMessage
}
-func (*SwInterfaceSetMtu) GetCrcString() string {
- return "132da1e7"
-}
func NewSwInterfaceSetMtu() api.Message {
return &SwInterfaceSetMtu{}
}
// SwInterfaceSetMtuReply represents the VPP binary API message 'sw_interface_set_mtu_reply'.
-// Generated from '../../bin_api/interface.api.json', line 179:
+// Generated from 'interface.api.json', line 119:
//
// "sw_interface_set_mtu_reply",
// [
func (*SwInterfaceSetMtuReply) GetMessageName() string {
return "sw_interface_set_mtu_reply"
}
-func (*SwInterfaceSetMtuReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceSetMtuReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceSetMtuReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceSetMtuReply() api.Message {
return &SwInterfaceSetMtuReply{}
}
// SwInterfaceEvent represents the VPP binary API message 'sw_interface_event'.
-// Generated from '../../bin_api/interface.api.json', line 197:
+// Generated from 'interface.api.json', line 137:
//
// "sw_interface_event",
// [
// }
//
type SwInterfaceEvent struct {
- Pid uint32
+ PID uint32
SwIfIndex uint32
AdminUpDown uint8
LinkUpDown uint8
func (*SwInterfaceEvent) GetMessageName() string {
return "sw_interface_event"
}
-func (*SwInterfaceEvent) GetMessageType() api.MessageType {
- return api.EventMessage
-}
func (*SwInterfaceEvent) GetCrcString() string {
return "bf9938e4"
}
+func (*SwInterfaceEvent) GetMessageType() api.MessageType {
+ return api.EventMessage
+}
func NewSwInterfaceEvent() api.Message {
return &SwInterfaceEvent{}
}
// WantInterfaceEvents represents the VPP binary API message 'want_interface_events'.
-// Generated from '../../bin_api/interface.api.json', line 231:
+// Generated from 'interface.api.json', line 171:
//
// "want_interface_events",
// [
//
type WantInterfaceEvents struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantInterfaceEvents) GetMessageName() string {
return "want_interface_events"
}
-func (*WantInterfaceEvents) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantInterfaceEvents) GetCrcString() string {
return "476f5a08"
}
+func (*WantInterfaceEvents) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantInterfaceEvents() api.Message {
return &WantInterfaceEvents{}
}
// WantInterfaceEventsReply represents the VPP binary API message 'want_interface_events_reply'.
-// Generated from '../../bin_api/interface.api.json', line 257:
+// Generated from 'interface.api.json', line 197:
//
// "want_interface_events_reply",
// [
func (*WantInterfaceEventsReply) GetMessageName() string {
return "want_interface_events_reply"
}
-func (*WantInterfaceEventsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantInterfaceEventsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantInterfaceEventsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantInterfaceEventsReply() api.Message {
return &WantInterfaceEventsReply{}
}
// SwInterfaceDetails represents the VPP binary API message 'sw_interface_details'.
-// Generated from '../../bin_api/interface.api.json', line 275:
+// Generated from 'interface.api.json', line 215:
//
// "sw_interface_details",
// [
// ],
// [
// "u32",
+// "mtu",
+// 4
+// ],
+// [
+// "u32",
// "sub_id"
// ],
// [
// "i_sid"
// ],
// {
-// "crc": "0x23dee0ff"
+// "crc": "0x09b4b510"
// }
//
type SwInterfaceDetails struct {
LinkDuplex uint8
LinkSpeed uint8
LinkMtu uint16
+ Mtu []uint32 `struc:"[4]uint32"`
SubID uint32
SubDot1ad uint8
SubDot1ah uint8
func (*SwInterfaceDetails) GetMessageName() string {
return "sw_interface_details"
}
+func (*SwInterfaceDetails) GetCrcString() string {
+ return "09b4b510"
+}
func (*SwInterfaceDetails) GetMessageType() api.MessageType {
return api.ReplyMessage
}
-func (*SwInterfaceDetails) GetCrcString() string {
- return "23dee0ff"
-}
func NewSwInterfaceDetails() api.Message {
return &SwInterfaceDetails{}
}
// SwInterfaceDump represents the VPP binary API message 'sw_interface_dump'.
-// Generated from '../../bin_api/interface.api.json', line 414:
+// Generated from 'interface.api.json', line 359:
//
// "sw_interface_dump",
// [
func (*SwInterfaceDump) GetMessageName() string {
return "sw_interface_dump"
}
-func (*SwInterfaceDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceDump) GetCrcString() string {
return "63f5e3b7"
}
+func (*SwInterfaceDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceDump() api.Message {
return &SwInterfaceDump{}
}
// SwInterfaceAddDelAddress represents the VPP binary API message 'sw_interface_add_del_address'.
-// Generated from '../../bin_api/interface.api.json', line 441:
+// Generated from 'interface.api.json', line 386:
//
// "sw_interface_add_del_address",
// [
type SwInterfaceAddDelAddress struct {
SwIfIndex uint32
IsAdd uint8
- IsIpv6 uint8
+ IsIPv6 uint8
DelAll uint8
AddressLength uint8
Address []byte `struc:"[16]byte"`
func (*SwInterfaceAddDelAddress) GetMessageName() string {
return "sw_interface_add_del_address"
}
-func (*SwInterfaceAddDelAddress) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceAddDelAddress) GetCrcString() string {
return "7b583179"
}
+func (*SwInterfaceAddDelAddress) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceAddDelAddress() api.Message {
return &SwInterfaceAddDelAddress{}
}
// SwInterfaceAddDelAddressReply represents the VPP binary API message 'sw_interface_add_del_address_reply'.
-// Generated from '../../bin_api/interface.api.json', line 484:
+// Generated from 'interface.api.json', line 429:
//
// "sw_interface_add_del_address_reply",
// [
func (*SwInterfaceAddDelAddressReply) GetMessageName() string {
return "sw_interface_add_del_address_reply"
}
-func (*SwInterfaceAddDelAddressReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceAddDelAddressReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceAddDelAddressReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceAddDelAddressReply() api.Message {
return &SwInterfaceAddDelAddressReply{}
}
// SwInterfaceSetTable represents the VPP binary API message 'sw_interface_set_table'.
-// Generated from '../../bin_api/interface.api.json', line 502:
+// Generated from 'interface.api.json', line 447:
//
// "sw_interface_set_table",
// [
//
type SwInterfaceSetTable struct {
SwIfIndex uint32
- IsIpv6 uint8
+ IsIPv6 uint8
VrfID uint32
}
func (*SwInterfaceSetTable) GetMessageName() string {
return "sw_interface_set_table"
}
-func (*SwInterfaceSetTable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceSetTable) GetCrcString() string {
return "acb25d89"
}
+func (*SwInterfaceSetTable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceSetTable() api.Message {
return &SwInterfaceSetTable{}
}
// SwInterfaceSetTableReply represents the VPP binary API message 'sw_interface_set_table_reply'.
-// Generated from '../../bin_api/interface.api.json', line 532:
+// Generated from 'interface.api.json', line 477:
//
// "sw_interface_set_table_reply",
// [
func (*SwInterfaceSetTableReply) GetMessageName() string {
return "sw_interface_set_table_reply"
}
-func (*SwInterfaceSetTableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceSetTableReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceSetTableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceSetTableReply() api.Message {
return &SwInterfaceSetTableReply{}
}
// SwInterfaceGetTable represents the VPP binary API message 'sw_interface_get_table'.
-// Generated from '../../bin_api/interface.api.json', line 550:
+// Generated from 'interface.api.json', line 495:
//
// "sw_interface_get_table",
// [
//
type SwInterfaceGetTable struct {
SwIfIndex uint32
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*SwInterfaceGetTable) GetMessageName() string {
return "sw_interface_get_table"
}
-func (*SwInterfaceGetTable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceGetTable) GetCrcString() string {
return "6b7bcd0a"
}
+func (*SwInterfaceGetTable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceGetTable() api.Message {
return &SwInterfaceGetTable{}
}
// SwInterfaceGetTableReply represents the VPP binary API message 'sw_interface_get_table_reply'.
-// Generated from '../../bin_api/interface.api.json', line 576:
+// Generated from 'interface.api.json', line 521:
//
// "sw_interface_get_table_reply",
// [
func (*SwInterfaceGetTableReply) GetMessageName() string {
return "sw_interface_get_table_reply"
}
-func (*SwInterfaceGetTableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceGetTableReply) GetCrcString() string {
return "a6eb0109"
}
+func (*SwInterfaceGetTableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceGetTableReply() api.Message {
return &SwInterfaceGetTableReply{}
}
-// VnetInterfaceSimpleCounters represents the VPP binary API message 'vnet_interface_simple_counters'.
-// Generated from '../../bin_api/interface.api.json', line 598:
+// SwInterfaceSetUnnumbered represents the VPP binary API message 'sw_interface_set_unnumbered'.
+// Generated from 'interface.api.json', line 543:
//
-// "vnet_interface_simple_counters",
+// "sw_interface_set_unnumbered",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
-// "u8",
-// "vnet_counter_type"
+// "u32",
+// "client_index"
// ],
// [
// "u32",
-// "first_sw_if_index"
+// "context"
// ],
// [
// "u32",
-// "count"
+// "sw_if_index"
// ],
// [
-// "u64",
-// "data",
-// 0,
-// "count"
+// "u32",
+// "unnumbered_sw_if_index"
+// ],
+// [
+// "u8",
+// "is_add"
// ],
// {
-// "crc": "0x9bc4a808"
+// "crc": "0xa2c1bbda"
// }
//
-type VnetInterfaceSimpleCounters struct {
- VnetCounterType uint8
- FirstSwIfIndex uint32
- Count uint32 `struc:"sizeof=Data"`
- Data []uint64
+type SwInterfaceSetUnnumbered struct {
+ SwIfIndex uint32
+ UnnumberedSwIfIndex uint32
+ IsAdd uint8
}
-func (*VnetInterfaceSimpleCounters) GetMessageName() string {
- return "vnet_interface_simple_counters"
+func (*SwInterfaceSetUnnumbered) GetMessageName() string {
+ return "sw_interface_set_unnumbered"
}
-func (*VnetInterfaceSimpleCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
+func (*SwInterfaceSetUnnumbered) GetCrcString() string {
+ return "a2c1bbda"
}
-func (*VnetInterfaceSimpleCounters) GetCrcString() string {
- return "9bc4a808"
+func (*SwInterfaceSetUnnumbered) GetMessageType() api.MessageType {
+ return api.RequestMessage
}
-func NewVnetInterfaceSimpleCounters() api.Message {
- return &VnetInterfaceSimpleCounters{}
+func NewSwInterfaceSetUnnumbered() api.Message {
+ return &SwInterfaceSetUnnumbered{}
}
-// VnetInterfaceCombinedCounters represents the VPP binary API message 'vnet_interface_combined_counters'.
-// Generated from '../../bin_api/interface.api.json', line 626:
+// SwInterfaceSetUnnumberedReply represents the VPP binary API message 'sw_interface_set_unnumbered_reply'.
+// Generated from 'interface.api.json', line 573:
//
-// "vnet_interface_combined_counters",
+// "sw_interface_set_unnumbered_reply",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
-// "u8",
-// "vnet_counter_type"
-// ],
-// [
-// "u32",
-// "first_sw_if_index"
-// ],
-// [
// "u32",
-// "count"
+// "context"
// ],
// [
-// "vl_api_vlib_counter_t",
-// "data",
-// 0,
-// "count"
+// "i32",
+// "retval"
// ],
// {
-// "crc": "0x2c595002"
+// "crc": "0xe8d4e804"
// }
//
-type VnetInterfaceCombinedCounters struct {
- VnetCounterType uint8
- FirstSwIfIndex uint32
- Count uint32 `struc:"sizeof=Data"`
- Data []VlibCounter
+type SwInterfaceSetUnnumberedReply struct {
+ Retval int32
}
-func (*VnetInterfaceCombinedCounters) GetMessageName() string {
- return "vnet_interface_combined_counters"
+func (*SwInterfaceSetUnnumberedReply) GetMessageName() string {
+ return "sw_interface_set_unnumbered_reply"
}
-func (*VnetInterfaceCombinedCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
+func (*SwInterfaceSetUnnumberedReply) GetCrcString() string {
+ return "e8d4e804"
}
-func (*VnetInterfaceCombinedCounters) GetCrcString() string {
- return "2c595002"
+func (*SwInterfaceSetUnnumberedReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
}
-func NewVnetInterfaceCombinedCounters() api.Message {
- return &VnetInterfaceCombinedCounters{}
+func NewSwInterfaceSetUnnumberedReply() api.Message {
+ return &SwInterfaceSetUnnumberedReply{}
}
-// VnetPerInterfaceSimpleCounters represents the VPP binary API message 'vnet_per_interface_simple_counters'.
-// Generated from '../../bin_api/interface.api.json', line 654:
+// SwInterfaceClearStats represents the VPP binary API message 'sw_interface_clear_stats'.
+// Generated from 'interface.api.json', line 591:
//
-// "vnet_per_interface_simple_counters",
+// "sw_interface_clear_stats",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
// "u32",
-// "count"
+// "client_index"
// ],
// [
// "u32",
-// "timestamp"
+// "context"
// ],
// [
-// "vl_api_vnet_simple_counter_t",
-// "data",
-// 0,
-// "count"
+// "u32",
+// "sw_if_index"
// ],
// {
-// "crc": "0xd1fba9ba"
-// }
-//
-type VnetPerInterfaceSimpleCounters struct {
- Count uint32 `struc:"sizeof=Data"`
- Timestamp uint32
- Data []VnetSimpleCounter
-}
-
-func (*VnetPerInterfaceSimpleCounters) GetMessageName() string {
- return "vnet_per_interface_simple_counters"
-}
-func (*VnetPerInterfaceSimpleCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
-func (*VnetPerInterfaceSimpleCounters) GetCrcString() string {
- return "d1fba9ba"
-}
-func NewVnetPerInterfaceSimpleCounters() api.Message {
- return &VnetPerInterfaceSimpleCounters{}
-}
-
-// VnetPerInterfaceCombinedCounters represents the VPP binary API message 'vnet_per_interface_combined_counters'.
-// Generated from '../../bin_api/interface.api.json', line 678:
-//
-// "vnet_per_interface_combined_counters",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "count"
-// ],
-// [
-// "u32",
-// "timestamp"
-// ],
-// [
-// "vl_api_vnet_combined_counter_t",
-// "data",
-// 0,
-// "count"
-// ],
-// {
-// "crc": "0xdc578375"
-// }
-//
-type VnetPerInterfaceCombinedCounters struct {
- Count uint32 `struc:"sizeof=Data"`
- Timestamp uint32
- Data []VnetCombinedCounter
-}
-
-func (*VnetPerInterfaceCombinedCounters) GetMessageName() string {
- return "vnet_per_interface_combined_counters"
-}
-func (*VnetPerInterfaceCombinedCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
-func (*VnetPerInterfaceCombinedCounters) GetCrcString() string {
- return "dc578375"
-}
-func NewVnetPerInterfaceCombinedCounters() api.Message {
- return &VnetPerInterfaceCombinedCounters{}
-}
-
-// SwInterfaceSetUnnumbered represents the VPP binary API message 'sw_interface_set_unnumbered'.
-// Generated from '../../bin_api/interface.api.json', line 702:
-//
-// "sw_interface_set_unnumbered",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u32",
-// "sw_if_index"
-// ],
-// [
-// "u32",
-// "unnumbered_sw_if_index"
-// ],
-// [
-// "u8",
-// "is_add"
-// ],
-// {
-// "crc": "0xa2c1bbda"
-// }
-//
-type SwInterfaceSetUnnumbered struct {
- SwIfIndex uint32
- UnnumberedSwIfIndex uint32
- IsAdd uint8
-}
-
-func (*SwInterfaceSetUnnumbered) GetMessageName() string {
- return "sw_interface_set_unnumbered"
-}
-func (*SwInterfaceSetUnnumbered) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*SwInterfaceSetUnnumbered) GetCrcString() string {
- return "a2c1bbda"
-}
-func NewSwInterfaceSetUnnumbered() api.Message {
- return &SwInterfaceSetUnnumbered{}
-}
-
-// SwInterfaceSetUnnumberedReply represents the VPP binary API message 'sw_interface_set_unnumbered_reply'.
-// Generated from '../../bin_api/interface.api.json', line 732:
-//
-// "sw_interface_set_unnumbered_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// {
-// "crc": "0xe8d4e804"
-// }
-//
-type SwInterfaceSetUnnumberedReply struct {
- Retval int32
-}
-
-func (*SwInterfaceSetUnnumberedReply) GetMessageName() string {
- return "sw_interface_set_unnumbered_reply"
-}
-func (*SwInterfaceSetUnnumberedReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*SwInterfaceSetUnnumberedReply) GetCrcString() string {
- return "e8d4e804"
-}
-func NewSwInterfaceSetUnnumberedReply() api.Message {
- return &SwInterfaceSetUnnumberedReply{}
-}
-
-// SwInterfaceClearStats represents the VPP binary API message 'sw_interface_clear_stats'.
-// Generated from '../../bin_api/interface.api.json', line 750:
-//
-// "sw_interface_clear_stats",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u32",
-// "sw_if_index"
-// ],
-// {
-// "crc": "0x529cb13f"
+// "crc": "0x529cb13f"
// }
//
type SwInterfaceClearStats struct {
func (*SwInterfaceClearStats) GetMessageName() string {
return "sw_interface_clear_stats"
}
-func (*SwInterfaceClearStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceClearStats) GetCrcString() string {
return "529cb13f"
}
+func (*SwInterfaceClearStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceClearStats() api.Message {
return &SwInterfaceClearStats{}
}
// SwInterfaceClearStatsReply represents the VPP binary API message 'sw_interface_clear_stats_reply'.
-// Generated from '../../bin_api/interface.api.json', line 772:
+// Generated from 'interface.api.json', line 613:
//
// "sw_interface_clear_stats_reply",
// [
func (*SwInterfaceClearStatsReply) GetMessageName() string {
return "sw_interface_clear_stats_reply"
}
-func (*SwInterfaceClearStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceClearStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceClearStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceClearStatsReply() api.Message {
return &SwInterfaceClearStatsReply{}
}
// SwInterfaceTagAddDel represents the VPP binary API message 'sw_interface_tag_add_del'.
-// Generated from '../../bin_api/interface.api.json', line 790:
+// Generated from 'interface.api.json', line 631:
//
// "sw_interface_tag_add_del",
// [
func (*SwInterfaceTagAddDel) GetMessageName() string {
return "sw_interface_tag_add_del"
}
-func (*SwInterfaceTagAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceTagAddDel) GetCrcString() string {
return "14cc636c"
}
+func (*SwInterfaceTagAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceTagAddDel() api.Message {
return &SwInterfaceTagAddDel{}
}
// SwInterfaceTagAddDelReply represents the VPP binary API message 'sw_interface_tag_add_del_reply'.
-// Generated from '../../bin_api/interface.api.json', line 821:
+// Generated from 'interface.api.json', line 662:
//
// "sw_interface_tag_add_del_reply",
// [
func (*SwInterfaceTagAddDelReply) GetMessageName() string {
return "sw_interface_tag_add_del_reply"
}
-func (*SwInterfaceTagAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceTagAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceTagAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceTagAddDelReply() api.Message {
return &SwInterfaceTagAddDelReply{}
}
// SwInterfaceSetMacAddress represents the VPP binary API message 'sw_interface_set_mac_address'.
-// Generated from '../../bin_api/interface.api.json', line 839:
+// Generated from 'interface.api.json', line 680:
//
// "sw_interface_set_mac_address",
// [
func (*SwInterfaceSetMacAddress) GetMessageName() string {
return "sw_interface_set_mac_address"
}
-func (*SwInterfaceSetMacAddress) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceSetMacAddress) GetCrcString() string {
return "eed5dfca"
}
+func (*SwInterfaceSetMacAddress) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceSetMacAddress() api.Message {
return &SwInterfaceSetMacAddress{}
}
// SwInterfaceSetMacAddressReply represents the VPP binary API message 'sw_interface_set_mac_address_reply'.
-// Generated from '../../bin_api/interface.api.json', line 866:
+// Generated from 'interface.api.json', line 707:
//
// "sw_interface_set_mac_address_reply",
// [
func (*SwInterfaceSetMacAddressReply) GetMessageName() string {
return "sw_interface_set_mac_address_reply"
}
-func (*SwInterfaceSetMacAddressReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceSetMacAddressReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceSetMacAddressReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceSetMacAddressReply() api.Message {
return &SwInterfaceSetMacAddressReply{}
}
+// SwInterfaceGetMacAddress represents the VPP binary API message 'sw_interface_get_mac_address'.
+// Generated from 'interface.api.json', line 725:
+//
+// "sw_interface_get_mac_address",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0x529cb13f"
+// }
+//
+type SwInterfaceGetMacAddress struct {
+ SwIfIndex uint32
+}
+
+func (*SwInterfaceGetMacAddress) GetMessageName() string {
+ return "sw_interface_get_mac_address"
+}
+func (*SwInterfaceGetMacAddress) GetCrcString() string {
+ return "529cb13f"
+}
+func (*SwInterfaceGetMacAddress) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewSwInterfaceGetMacAddress() api.Message {
+ return &SwInterfaceGetMacAddress{}
+}
+
+// SwInterfaceGetMacAddressReply represents the VPP binary API message 'sw_interface_get_mac_address_reply'.
+// Generated from 'interface.api.json', line 747:
+//
+// "sw_interface_get_mac_address_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// [
+// "u8",
+// "mac_address",
+// 6
+// ],
+// {
+// "crc": "0x8ea538d3"
+// }
+//
+type SwInterfaceGetMacAddressReply struct {
+ Retval int32
+ MacAddress []byte `struc:"[6]byte"`
+}
+
+func (*SwInterfaceGetMacAddressReply) GetMessageName() string {
+ return "sw_interface_get_mac_address_reply"
+}
+func (*SwInterfaceGetMacAddressReply) GetCrcString() string {
+ return "8ea538d3"
+}
+func (*SwInterfaceGetMacAddressReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewSwInterfaceGetMacAddressReply() api.Message {
+ return &SwInterfaceGetMacAddressReply{}
+}
+
// SwInterfaceSetRxMode represents the VPP binary API message 'sw_interface_set_rx_mode'.
-// Generated from '../../bin_api/interface.api.json', line 884:
+// Generated from 'interface.api.json', line 770:
//
// "sw_interface_set_rx_mode",
// [
func (*SwInterfaceSetRxMode) GetMessageName() string {
return "sw_interface_set_rx_mode"
}
-func (*SwInterfaceSetRxMode) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceSetRxMode) GetCrcString() string {
return "2a1cc58c"
}
+func (*SwInterfaceSetRxMode) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceSetRxMode() api.Message {
return &SwInterfaceSetRxMode{}
}
// SwInterfaceSetRxModeReply represents the VPP binary API message 'sw_interface_set_rx_mode_reply'.
-// Generated from '../../bin_api/interface.api.json', line 918:
+// Generated from 'interface.api.json', line 804:
//
// "sw_interface_set_rx_mode_reply",
// [
func (*SwInterfaceSetRxModeReply) GetMessageName() string {
return "sw_interface_set_rx_mode_reply"
}
-func (*SwInterfaceSetRxModeReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceSetRxModeReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceSetRxModeReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceSetRxModeReply() api.Message {
return &SwInterfaceSetRxModeReply{}
}
// InterfaceNameRenumber represents the VPP binary API message 'interface_name_renumber'.
-// Generated from '../../bin_api/interface.api.json', line 936:
+// Generated from 'interface.api.json', line 822:
//
// "interface_name_renumber",
// [
func (*InterfaceNameRenumber) GetMessageName() string {
return "interface_name_renumber"
}
-func (*InterfaceNameRenumber) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*InterfaceNameRenumber) GetCrcString() string {
return "39194269"
}
+func (*InterfaceNameRenumber) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewInterfaceNameRenumber() api.Message {
return &InterfaceNameRenumber{}
}
// InterfaceNameRenumberReply represents the VPP binary API message 'interface_name_renumber_reply'.
-// Generated from '../../bin_api/interface.api.json', line 962:
+// Generated from 'interface.api.json', line 848:
//
// "interface_name_renumber_reply",
// [
func (*InterfaceNameRenumberReply) GetMessageName() string {
return "interface_name_renumber_reply"
}
-func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*InterfaceNameRenumberReply) GetCrcString() string {
return "e8d4e804"
}
+func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewInterfaceNameRenumberReply() api.Message {
return &InterfaceNameRenumberReply{}
}
// CreateSubif represents the VPP binary API message 'create_subif'.
-// Generated from '../../bin_api/interface.api.json', line 980:
+// Generated from 'interface.api.json', line 866:
//
// "create_subif",
// [
func (*CreateSubif) GetMessageName() string {
return "create_subif"
}
-func (*CreateSubif) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*CreateSubif) GetCrcString() string {
return "86cfe408"
}
+func (*CreateSubif) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewCreateSubif() api.Message {
return &CreateSubif{}
}
// CreateSubifReply represents the VPP binary API message 'create_subif_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1046:
+// Generated from 'interface.api.json', line 932:
//
// "create_subif_reply",
// [
func (*CreateSubifReply) GetMessageName() string {
return "create_subif_reply"
}
-func (*CreateSubifReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*CreateSubifReply) GetCrcString() string {
return "fda5941f"
}
+func (*CreateSubifReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewCreateSubifReply() api.Message {
return &CreateSubifReply{}
}
// CreateVlanSubif represents the VPP binary API message 'create_vlan_subif'.
-// Generated from '../../bin_api/interface.api.json', line 1068:
+// Generated from 'interface.api.json', line 954:
//
// "create_vlan_subif",
// [
func (*CreateVlanSubif) GetMessageName() string {
return "create_vlan_subif"
}
-func (*CreateVlanSubif) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*CreateVlanSubif) GetCrcString() string {
return "70cadeda"
}
+func (*CreateVlanSubif) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewCreateVlanSubif() api.Message {
return &CreateVlanSubif{}
}
// CreateVlanSubifReply represents the VPP binary API message 'create_vlan_subif_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1094:
+// Generated from 'interface.api.json', line 980:
//
// "create_vlan_subif_reply",
// [
func (*CreateVlanSubifReply) GetMessageName() string {
return "create_vlan_subif_reply"
}
-func (*CreateVlanSubifReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*CreateVlanSubifReply) GetCrcString() string {
return "fda5941f"
}
+func (*CreateVlanSubifReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewCreateVlanSubifReply() api.Message {
return &CreateVlanSubifReply{}
}
// DeleteSubif represents the VPP binary API message 'delete_subif'.
-// Generated from '../../bin_api/interface.api.json', line 1116:
+// Generated from 'interface.api.json', line 1002:
//
// "delete_subif",
// [
func (*DeleteSubif) GetMessageName() string {
return "delete_subif"
}
-func (*DeleteSubif) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*DeleteSubif) GetCrcString() string {
return "529cb13f"
}
+func (*DeleteSubif) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewDeleteSubif() api.Message {
return &DeleteSubif{}
}
// DeleteSubifReply represents the VPP binary API message 'delete_subif_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1138:
+// Generated from 'interface.api.json', line 1024:
//
// "delete_subif_reply",
// [
func (*DeleteSubifReply) GetMessageName() string {
return "delete_subif_reply"
}
-func (*DeleteSubifReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*DeleteSubifReply) GetCrcString() string {
return "e8d4e804"
}
+func (*DeleteSubifReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewDeleteSubifReply() api.Message {
return &DeleteSubifReply{}
}
// CreateLoopback represents the VPP binary API message 'create_loopback'.
-// Generated from '../../bin_api/interface.api.json', line 1156:
+// Generated from 'interface.api.json', line 1042:
//
// "create_loopback",
// [
func (*CreateLoopback) GetMessageName() string {
return "create_loopback"
}
-func (*CreateLoopback) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*CreateLoopback) GetCrcString() string {
return "3b54129c"
}
+func (*CreateLoopback) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewCreateLoopback() api.Message {
return &CreateLoopback{}
}
// CreateLoopbackReply represents the VPP binary API message 'create_loopback_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1179:
+// Generated from 'interface.api.json', line 1065:
//
// "create_loopback_reply",
// [
func (*CreateLoopbackReply) GetMessageName() string {
return "create_loopback_reply"
}
-func (*CreateLoopbackReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*CreateLoopbackReply) GetCrcString() string {
return "fda5941f"
}
+func (*CreateLoopbackReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewCreateLoopbackReply() api.Message {
return &CreateLoopbackReply{}
}
// CreateLoopbackInstance represents the VPP binary API message 'create_loopback_instance'.
-// Generated from '../../bin_api/interface.api.json', line 1201:
+// Generated from 'interface.api.json', line 1087:
//
// "create_loopback_instance",
// [
func (*CreateLoopbackInstance) GetMessageName() string {
return "create_loopback_instance"
}
-func (*CreateLoopbackInstance) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*CreateLoopbackInstance) GetCrcString() string {
return "7bbd53b6"
}
+func (*CreateLoopbackInstance) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewCreateLoopbackInstance() api.Message {
return &CreateLoopbackInstance{}
}
// CreateLoopbackInstanceReply represents the VPP binary API message 'create_loopback_instance_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1232:
+// Generated from 'interface.api.json', line 1118:
//
// "create_loopback_instance_reply",
// [
func (*CreateLoopbackInstanceReply) GetMessageName() string {
return "create_loopback_instance_reply"
}
-func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*CreateLoopbackInstanceReply) GetCrcString() string {
return "fda5941f"
}
+func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewCreateLoopbackInstanceReply() api.Message {
return &CreateLoopbackInstanceReply{}
}
// DeleteLoopback represents the VPP binary API message 'delete_loopback'.
-// Generated from '../../bin_api/interface.api.json', line 1254:
+// Generated from 'interface.api.json', line 1140:
//
// "delete_loopback",
// [
func (*DeleteLoopback) GetMessageName() string {
return "delete_loopback"
}
-func (*DeleteLoopback) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*DeleteLoopback) GetCrcString() string {
return "529cb13f"
}
+func (*DeleteLoopback) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewDeleteLoopback() api.Message {
return &DeleteLoopback{}
}
// DeleteLoopbackReply represents the VPP binary API message 'delete_loopback_reply'.
-// Generated from '../../bin_api/interface.api.json', line 1276:
+// Generated from 'interface.api.json', line 1162:
//
// "delete_loopback_reply",
// [
func (*DeleteLoopbackReply) GetMessageName() string {
return "delete_loopback_reply"
}
-func (*DeleteLoopbackReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*DeleteLoopbackReply) GetCrcString() string {
return "e8d4e804"
}
+func (*DeleteLoopbackReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewDeleteLoopbackReply() api.Message {
return &DeleteLoopbackReply{}
}
+
+// CollectDetailedInterfaceStats represents the VPP binary API message 'collect_detailed_interface_stats'.
+// Generated from 'interface.api.json', line 1180:
+//
+// "collect_detailed_interface_stats",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "enable_disable"
+// ],
+// {
+// "crc": "0x69d24598"
+// }
+//
+type CollectDetailedInterfaceStats struct {
+ SwIfIndex uint32
+ EnableDisable uint8
+}
+
+func (*CollectDetailedInterfaceStats) GetMessageName() string {
+ return "collect_detailed_interface_stats"
+}
+func (*CollectDetailedInterfaceStats) GetCrcString() string {
+ return "69d24598"
+}
+func (*CollectDetailedInterfaceStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewCollectDetailedInterfaceStats() api.Message {
+ return &CollectDetailedInterfaceStats{}
+}
+
+// CollectDetailedInterfaceStatsReply represents the VPP binary API message 'collect_detailed_interface_stats_reply'.
+// Generated from 'interface.api.json', line 1206:
+//
+// "collect_detailed_interface_stats_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type CollectDetailedInterfaceStatsReply struct {
+ Retval int32
+}
+
+func (*CollectDetailedInterfaceStatsReply) GetMessageName() string {
+ return "collect_detailed_interface_stats_reply"
+}
+func (*CollectDetailedInterfaceStatsReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*CollectDetailedInterfaceStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewCollectDetailedInterfaceStatsReply() api.Message {
+ return &CollectDetailedInterfaceStatsReply{}
+}
+
+/* Services */
+
+type Services interface {
+ DumpSwInterface(*SwInterfaceDump) (*SwInterfaceDetails, error)
+ CollectDetailedInterfaceStats(*CollectDetailedInterfaceStats) (*CollectDetailedInterfaceStatsReply, error)
+ CreateLoopback(*CreateLoopback) (*CreateLoopbackReply, error)
+ CreateLoopbackInstance(*CreateLoopbackInstance) (*CreateLoopbackInstanceReply, error)
+ CreateSubif(*CreateSubif) (*CreateSubifReply, error)
+ CreateVlanSubif(*CreateVlanSubif) (*CreateVlanSubifReply, error)
+ DeleteLoopback(*DeleteLoopback) (*DeleteLoopbackReply, error)
+ DeleteSubif(*DeleteSubif) (*DeleteSubifReply, error)
+ HwInterfaceSetMtu(*HwInterfaceSetMtu) (*HwInterfaceSetMtuReply, error)
+ InterfaceNameRenumber(*InterfaceNameRenumber) (*InterfaceNameRenumberReply, error)
+ SwInterfaceAddDelAddress(*SwInterfaceAddDelAddress) (*SwInterfaceAddDelAddressReply, error)
+ SwInterfaceClearStats(*SwInterfaceClearStats) (*SwInterfaceClearStatsReply, error)
+ SwInterfaceGetMacAddress(*SwInterfaceGetMacAddress) (*SwInterfaceGetMacAddressReply, error)
+ SwInterfaceGetTable(*SwInterfaceGetTable) (*SwInterfaceGetTableReply, error)
+ SwInterfaceSetFlags(*SwInterfaceSetFlags) (*SwInterfaceSetFlagsReply, error)
+ SwInterfaceSetMacAddress(*SwInterfaceSetMacAddress) (*SwInterfaceSetMacAddressReply, error)
+ SwInterfaceSetMtu(*SwInterfaceSetMtu) (*SwInterfaceSetMtuReply, error)
+ SwInterfaceSetRxMode(*SwInterfaceSetRxMode) (*SwInterfaceSetRxModeReply, error)
+ SwInterfaceSetTable(*SwInterfaceSetTable) (*SwInterfaceSetTableReply, error)
+ SwInterfaceSetUnnumbered(*SwInterfaceSetUnnumbered) (*SwInterfaceSetUnnumberedReply, error)
+ SwInterfaceTagAddDel(*SwInterfaceTagAddDel) (*SwInterfaceTagAddDelReply, error)
+ WantInterfaceEvents(*WantInterfaceEvents) (*WantInterfaceEventsReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*SwInterfaceSetFlags)(nil), "interface.SwInterfaceSetFlags")
+ api.RegisterMessage((*SwInterfaceSetFlagsReply)(nil), "interface.SwInterfaceSetFlagsReply")
+ api.RegisterMessage((*HwInterfaceSetMtu)(nil), "interface.HwInterfaceSetMtu")
+ api.RegisterMessage((*HwInterfaceSetMtuReply)(nil), "interface.HwInterfaceSetMtuReply")
+ api.RegisterMessage((*SwInterfaceSetMtu)(nil), "interface.SwInterfaceSetMtu")
+ api.RegisterMessage((*SwInterfaceSetMtuReply)(nil), "interface.SwInterfaceSetMtuReply")
+ api.RegisterMessage((*SwInterfaceEvent)(nil), "interface.SwInterfaceEvent")
+ api.RegisterMessage((*WantInterfaceEvents)(nil), "interface.WantInterfaceEvents")
+ api.RegisterMessage((*WantInterfaceEventsReply)(nil), "interface.WantInterfaceEventsReply")
+ api.RegisterMessage((*SwInterfaceDetails)(nil), "interface.SwInterfaceDetails")
+ api.RegisterMessage((*SwInterfaceDump)(nil), "interface.SwInterfaceDump")
+ api.RegisterMessage((*SwInterfaceAddDelAddress)(nil), "interface.SwInterfaceAddDelAddress")
+ api.RegisterMessage((*SwInterfaceAddDelAddressReply)(nil), "interface.SwInterfaceAddDelAddressReply")
+ api.RegisterMessage((*SwInterfaceSetTable)(nil), "interface.SwInterfaceSetTable")
+ api.RegisterMessage((*SwInterfaceSetTableReply)(nil), "interface.SwInterfaceSetTableReply")
+ api.RegisterMessage((*SwInterfaceGetTable)(nil), "interface.SwInterfaceGetTable")
+ api.RegisterMessage((*SwInterfaceGetTableReply)(nil), "interface.SwInterfaceGetTableReply")
+ api.RegisterMessage((*SwInterfaceSetUnnumbered)(nil), "interface.SwInterfaceSetUnnumbered")
+ api.RegisterMessage((*SwInterfaceSetUnnumberedReply)(nil), "interface.SwInterfaceSetUnnumberedReply")
+ api.RegisterMessage((*SwInterfaceClearStats)(nil), "interface.SwInterfaceClearStats")
+ api.RegisterMessage((*SwInterfaceClearStatsReply)(nil), "interface.SwInterfaceClearStatsReply")
+ api.RegisterMessage((*SwInterfaceTagAddDel)(nil), "interface.SwInterfaceTagAddDel")
+ api.RegisterMessage((*SwInterfaceTagAddDelReply)(nil), "interface.SwInterfaceTagAddDelReply")
+ api.RegisterMessage((*SwInterfaceSetMacAddress)(nil), "interface.SwInterfaceSetMacAddress")
+ api.RegisterMessage((*SwInterfaceSetMacAddressReply)(nil), "interface.SwInterfaceSetMacAddressReply")
+ api.RegisterMessage((*SwInterfaceGetMacAddress)(nil), "interface.SwInterfaceGetMacAddress")
+ api.RegisterMessage((*SwInterfaceGetMacAddressReply)(nil), "interface.SwInterfaceGetMacAddressReply")
+ api.RegisterMessage((*SwInterfaceSetRxMode)(nil), "interface.SwInterfaceSetRxMode")
+ api.RegisterMessage((*SwInterfaceSetRxModeReply)(nil), "interface.SwInterfaceSetRxModeReply")
+ api.RegisterMessage((*InterfaceNameRenumber)(nil), "interface.InterfaceNameRenumber")
+ api.RegisterMessage((*InterfaceNameRenumberReply)(nil), "interface.InterfaceNameRenumberReply")
+ api.RegisterMessage((*CreateSubif)(nil), "interface.CreateSubif")
+ api.RegisterMessage((*CreateSubifReply)(nil), "interface.CreateSubifReply")
+ api.RegisterMessage((*CreateVlanSubif)(nil), "interface.CreateVlanSubif")
+ api.RegisterMessage((*CreateVlanSubifReply)(nil), "interface.CreateVlanSubifReply")
+ api.RegisterMessage((*DeleteSubif)(nil), "interface.DeleteSubif")
+ api.RegisterMessage((*DeleteSubifReply)(nil), "interface.DeleteSubifReply")
+ api.RegisterMessage((*CreateLoopback)(nil), "interface.CreateLoopback")
+ api.RegisterMessage((*CreateLoopbackReply)(nil), "interface.CreateLoopbackReply")
+ api.RegisterMessage((*CreateLoopbackInstance)(nil), "interface.CreateLoopbackInstance")
+ api.RegisterMessage((*CreateLoopbackInstanceReply)(nil), "interface.CreateLoopbackInstanceReply")
+ api.RegisterMessage((*DeleteLoopback)(nil), "interface.DeleteLoopback")
+ api.RegisterMessage((*DeleteLoopbackReply)(nil), "interface.DeleteLoopbackReply")
+ api.RegisterMessage((*CollectDetailedInterfaceStats)(nil), "interface.CollectDetailedInterfaceStats")
+ api.RegisterMessage((*CollectDetailedInterfaceStatsReply)(nil), "interface.CollectDetailedInterfaceStatsReply")
+}
{
- "services": [
- {
- "ip_source_and_port_range_check_add_del": {
- "reply": "ip_source_and_port_range_check_add_del_reply"
- }
- },
- {
- "ip6_fib_dump": {
- "reply": "ip6_fib_details",
- "stream": true
- }
- },
- {
- "want_ip6_nd_events": {
- "reply": "want_ip6_nd_events_reply"
- }
- },
- {
- "ip_punt_police": {
- "reply": "ip_punt_police_reply"
- }
- },
- {
- "set_arp_neighbor_limit": {
- "reply": "set_arp_neighbor_limit_reply"
- }
- },
- {
- "ip6nd_proxy_add_del": {
- "reply": "ip6nd_proxy_add_del_reply"
- }
- },
- {
- "ioam_disable": {
- "reply": "ioam_disable_reply"
- }
- },
- {
- "ip_table_add_del": {
- "reply": "ip_table_add_del_reply"
- }
- },
- {
- "ip_neighbor_dump": {
- "reply": "ip_neighbor_details",
- "stream": true
- }
- },
- {
- "ip4_arp_event": {
- "reply": null
- }
- },
- {
- "ip_punt_redirect": {
- "reply": "ip_punt_redirect_reply"
- }
- },
- {
- "sw_interface_ip6nd_ra_prefix": {
- "reply": "sw_interface_ip6nd_ra_prefix_reply"
- }
- },
- {
- "reset_fib": {
- "reply": "reset_fib_reply"
- }
- },
- {
- "ip6_mfib_dump": {
- "reply": "ip6_mfib_details",
- "stream": true
- }
- },
- {
- "sw_interface_ip6nd_ra_config": {
- "reply": "sw_interface_ip6nd_ra_config_reply"
- }
- },
- {
- "sw_interface_ip6_enable_disable": {
- "reply": "sw_interface_ip6_enable_disable_reply"
- }
- },
- {
- "sw_interface_ip6_set_link_local_address": {
- "reply": "sw_interface_ip6_set_link_local_address_reply"
- }
- },
- {
- "mfib_signal_dump": {
- "reply": "mfib_signal_details",
- "stream": true
- }
- },
- {
- "ip_container_proxy_add_del": {
- "reply": "ip_container_proxy_add_del_reply"
- }
- },
- {
- "ip_mfib_dump": {
- "reply": "ip_mfib_details",
- "stream": true
- }
- },
- {
- "ip_address_dump": {
- "reply": "ip_address_details",
- "stream": true
- }
- },
- {
- "ip_dump": {
- "reply": "ip_details",
- "stream": true
- }
- },
- {
- "ip_neighbor_add_del": {
- "reply": "ip_neighbor_add_del_reply"
- }
- },
- {
- "proxy_arp_intfc_enable_disable": {
- "reply": "proxy_arp_intfc_enable_disable_reply"
- }
- },
- {
- "proxy_arp_add_del": {
- "reply": "proxy_arp_add_del_reply"
- }
- },
- {
- "ip_add_del_route": {
- "reply": "ip_add_del_route_reply"
- }
- },
- {
- "ip6nd_proxy_dump": {
- "reply": "ip6nd_proxy_details",
- "stream": true
- }
- },
- {
- "ip_fib_dump": {
- "reply": "ip_fib_details",
- "stream": true
- }
- },
- {
- "want_ip4_arp_events": {
- "reply": "want_ip4_arp_events_reply"
- }
- },
- {
- "ioam_enable": {
- "reply": "ioam_enable_reply"
- }
- },
- {
- "ip6_nd_event": {
- "reply": null
- }
- },
- {
- "ip_mroute_add_del": {
- "reply": "ip_mroute_add_del_reply"
- }
- },
- {
- "ip_source_and_port_range_check_interface_add_del": {
- "reply": "ip_source_and_port_range_check_interface_add_del_reply"
- }
- },
- {
- "set_ip_flow_hash": {
- "reply": "set_ip_flow_hash_reply"
- }
- }
- ],
- "vl_api_version": "0xb395c625",
- "enums": [],
"messages": [
[
"ip_table_add_del",
"crc": "0x51077d14"
}
],
+ [
+ "ip6nd_send_router_solicitation",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "irt"
+ ],
+ [
+ "u32",
+ "mrt"
+ ],
+ [
+ "u32",
+ "mrc"
+ ],
+ [
+ "u32",
+ "mrd"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "stop"
+ ],
+ {
+ "crc": "0xbd968917"
+ }
+ ],
+ [
+ "ip6nd_send_router_solicitation_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
[
"sw_interface_ip6_enable_disable",
[
"next_hop_via_label"
],
[
- "u32",
+ "vl_api_fib_mpls_label_t",
"next_hop_out_label_stack",
0,
"next_hop_n_out_labels"
],
{
- "crc": "0xc85f8290"
+ "crc": "0x4219d62d"
}
],
[
"src_address",
16
],
+ [
+ "u8",
+ "nh_address",
+ 16
+ ],
{
- "crc": "0xc37112f7"
+ "crc": "0xf44c17b1"
}
],
[
"crc": "0x6b7bcd0a"
}
],
+ [
+ "ip_unnumbered_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u32",
+ "ip_sw_if_index"
+ ],
+ {
+ "crc": "0x05b717ca"
+ }
+ ],
+ [
+ "ip_unnumbered_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ {
+ "crc": "0x529cb13f"
+ }
+ ],
[
"ip_details",
[
}
],
[
- "want_ip4_arp_events",
+ "ip_scan_neighbor_enable_disable",
[
"u16",
"_vl_msg_id"
],
[
"u8",
- "enable_disable"
+ "mode"
],
[
- "u32",
- "pid"
+ "u8",
+ "scan_interval"
],
[
- "u32",
- "address"
+ "u8",
+ "max_proc_time"
+ ],
+ [
+ "u8",
+ "max_update"
+ ],
+ [
+ "u8",
+ "scan_int_delay"
+ ],
+ [
+ "u8",
+ "stale_threshold"
],
{
- "crc": "0x77e06379"
+ "crc": "0x0a6bf57a"
}
],
[
- "want_ip4_arp_events_reply",
+ "ip_scan_neighbor_enable_disable_reply",
[
"u16",
"_vl_msg_id"
}
],
[
- "ip4_arp_event",
+ "ip_probe_neighbor",
[
"u16",
"_vl_msg_id"
],
[
"u32",
- "address"
- ],
- [
- "u32",
- "pid"
+ "context"
],
[
"u32",
],
[
"u8",
- "new_mac",
- 6
+ "dst_address",
+ 16
],
[
"u8",
- "mac_ip"
+ "is_ipv6"
],
{
- "crc": "0xef7235f7"
+ "crc": "0x1e44bfd7"
}
],
[
- "want_ip6_nd_events",
+ "ip_probe_neighbor_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "want_ip4_arp_events",
[
"u16",
"_vl_msg_id"
"pid"
],
[
- "u8",
- "address",
- 16
+ "u32",
+ "address"
],
{
- "crc": "0x1cf65fbb"
+ "crc": "0x77e06379"
}
],
[
- "want_ip6_nd_events_reply",
+ "want_ip4_arp_events_reply",
[
"u16",
"_vl_msg_id"
}
],
[
- "ip6_nd_event",
+ "ip4_arp_event",
[
"u16",
"_vl_msg_id"
],
[
"u32",
- "pid"
+ "address"
],
[
"u32",
- "sw_if_index"
+ "pid"
],
[
- "u8",
- "address",
- 16
+ "u32",
+ "sw_if_index"
],
[
"u8",
"mac_ip"
],
{
- "crc": "0x96ab2fdd"
+ "crc": "0xef7235f7"
}
],
[
- "proxy_arp_add_del",
+ "want_ip6_nd_events",
[
"u16",
"_vl_msg_id"
"u32",
"context"
],
- [
- "u32",
- "vrf_id"
- ],
[
"u8",
- "is_add"
+ "enable_disable"
],
[
- "u8",
- "low_address",
- 4
+ "u32",
+ "pid"
],
[
"u8",
- "hi_address",
- 4
+ "address",
+ 16
+ ],
+ {
+ "crc": "0x1cf65fbb"
+ }
+ ],
+ [
+ "want_ip6_nd_events_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "ip6_nd_event",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "pid"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "address",
+ 16
+ ],
+ [
+ "u8",
+ "new_mac",
+ 6
+ ],
+ [
+ "u8",
+ "mac_ip"
+ ],
+ {
+ "crc": "0x96ab2fdd"
+ }
+ ],
+ [
+ "want_ip6_ra_events",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u8",
+ "enable_disable"
+ ],
+ [
+ "u32",
+ "pid"
+ ],
+ {
+ "crc": "0x05b454b5"
+ }
+ ],
+ [
+ "want_ip6_ra_events_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "ip6_ra_event",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "pid"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "router_address",
+ 16
+ ],
+ [
+ "u8",
+ "current_hop_limit"
+ ],
+ [
+ "u8",
+ "flags"
+ ],
+ [
+ "u16",
+ "router_lifetime_in_sec"
+ ],
+ [
+ "u32",
+ "neighbor_reachable_time_in_msec"
+ ],
+ [
+ "u32",
+ "time_in_msec_between_retransmitted_neighbor_solicitations"
+ ],
+ [
+ "u32",
+ "n_prefixes"
+ ],
+ [
+ "vl_api_ip6_ra_prefix_info_t",
+ "prefixes",
+ 0,
+ "n_prefixes"
+ ],
+ {
+ "crc": "0xc5e54257"
+ }
+ ],
+ [
+ "proxy_arp_add_del",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u8",
+ "is_add"
+ ],
+ [
+ "vl_api_proxy_arp_t",
+ "proxy"
],
{
- "crc": "0xc2442918"
+ "crc": "0x227988d9"
}
],
[
"crc": "0xe8d4e804"
}
],
+ [
+ "proxy_arp_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ {
+ "crc": "0x51077d14"
+ }
+ ],
+ [
+ "proxy_arp_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "vl_api_proxy_arp_t",
+ "proxy"
+ ],
+ {
+ "crc": "0x9b707c77"
+ }
+ ],
[
"proxy_arp_intfc_enable_disable",
[
"crc": "0xe8d4e804"
}
],
+ [
+ "proxy_arp_intfc_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ {
+ "crc": "0x51077d14"
+ }
+ ],
+ [
+ "proxy_arp_intfc_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ {
+ "crc": "0xf6458e5f"
+ }
+ ],
[
"reset_fib",
[
{
"crc": "0xe8d4e804"
}
- ]
- ],
- "types": [
+ ],
[
- "fib_path",
+ "ip_reassembly_set",
[
- "u32",
- "sw_if_index"
+ "u16",
+ "_vl_msg_id"
],
[
"u32",
- "table_id"
+ "client_index"
],
[
- "u8",
- "weight"
+ "u32",
+ "context"
],
[
- "u8",
- "preference"
+ "u32",
+ "timeout_ms"
],
[
- "u8",
- "is_local"
+ "u32",
+ "max_reassemblies"
],
[
- "u8",
- "is_drop"
+ "u32",
+ "expire_walk_interval_ms"
+ ],
+ [
+ "u8",
+ "is_ip6"
+ ],
+ {
+ "crc": "0x1db184de"
+ }
+ ],
+ [
+ "ip_reassembly_set_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "ip_reassembly_get",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u8",
+ "is_ip6"
+ ],
+ {
+ "crc": "0x6fe91190"
+ }
+ ],
+ [
+ "ip_reassembly_get_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ [
+ "u32",
+ "timeout_ms"
+ ],
+ [
+ "u32",
+ "max_reassemblies"
+ ],
+ [
+ "u32",
+ "expire_walk_interval_ms"
+ ],
+ [
+ "u8",
+ "is_ip6"
+ ],
+ {
+ "crc": "0xd746fc57"
+ }
+ ],
+ [
+ "ip_reassembly_enable_disable",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u8",
+ "enable_ip4"
+ ],
+ [
+ "u8",
+ "enable_ip6"
+ ],
+ {
+ "crc": "0xbb8dc5d0"
+ }
+ ],
+ [
+ "ip_reassembly_enable_disable_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ]
+ ],
+ "vl_api_version": "0xff691c00",
+ "unions": [
+ [
+ "address_union",
+ [
+ "vl_api_ip4_address_t",
+ "ip4"
+ ],
+ [
+ "vl_api_ip6_address_t",
+ "ip6"
+ ],
+ {
+ "crc": "0xd68a2fb4"
+ }
+ ]
+ ],
+ "services": {
+ "ip_address_dump": {
+ "reply": "ip_address_details",
+ "stream": true
+ },
+ "ip_source_and_port_range_check_add_del": {
+ "reply": "ip_source_and_port_range_check_add_del_reply"
+ },
+ "reset_fib": {
+ "reply": "reset_fib_reply"
+ },
+ "ip_probe_neighbor": {
+ "reply": "ip_probe_neighbor_reply"
+ },
+ "want_ip6_nd_events": {
+ "reply": "want_ip6_nd_events_reply",
+ "events": [
+ "ip6_nd_event"
+ ]
+ },
+ "ip_punt_police": {
+ "reply": "ip_punt_police_reply"
+ },
+ "ip6nd_proxy_add_del": {
+ "reply": "ip6nd_proxy_add_del_reply"
+ },
+ "set_arp_neighbor_limit": {
+ "reply": "set_arp_neighbor_limit_reply"
+ },
+ "ip_reassembly_enable_disable": {
+ "reply": "ip_reassembly_enable_disable_reply"
+ },
+ "ip6_fib_dump": {
+ "reply": "ip6_fib_details",
+ "stream": true
+ },
+ "ip6nd_send_router_solicitation": {
+ "reply": "ip6nd_send_router_solicitation_reply"
+ },
+ "ip_table_add_del": {
+ "reply": "ip_table_add_del_reply"
+ },
+ "ip_neighbor_dump": {
+ "reply": "ip_neighbor_details",
+ "stream": true
+ },
+ "ip_punt_redirect": {
+ "reply": "ip_punt_redirect_reply"
+ },
+ "sw_interface_ip6nd_ra_prefix": {
+ "reply": "sw_interface_ip6nd_ra_prefix_reply"
+ },
+ "ip_reassembly_set": {
+ "reply": "ip_reassembly_set_reply"
+ },
+ "ip6_mfib_dump": {
+ "reply": "ip6_mfib_details",
+ "stream": true
+ },
+ "sw_interface_ip6nd_ra_config": {
+ "reply": "sw_interface_ip6nd_ra_config_reply"
+ },
+ "proxy_arp_dump": {
+ "reply": "proxy_arp_details",
+ "stream": true
+ },
+ "sw_interface_ip6_enable_disable": {
+ "reply": "sw_interface_ip6_enable_disable_reply"
+ },
+ "ip_source_and_port_range_check_interface_add_del": {
+ "reply": "ip_source_and_port_range_check_interface_add_del_reply"
+ },
+ "sw_interface_ip6_set_link_local_address": {
+ "reply": "sw_interface_ip6_set_link_local_address_reply"
+ },
+ "mfib_signal_dump": {
+ "reply": "mfib_signal_details",
+ "stream": true
+ },
+ "ip_container_proxy_add_del": {
+ "reply": "ip_container_proxy_add_del_reply"
+ },
+ "ip_mfib_dump": {
+ "reply": "ip_mfib_details",
+ "stream": true
+ },
+ "ip_unnumbered_dump": {
+ "reply": "ip_unnumbered_details",
+ "stream": true
+ },
+ "ip_dump": {
+ "reply": "ip_details",
+ "stream": true
+ },
+ "ip_neighbor_add_del": {
+ "reply": "ip_neighbor_add_del_reply"
+ },
+ "proxy_arp_intfc_enable_disable": {
+ "reply": "proxy_arp_intfc_enable_disable_reply"
+ },
+ "proxy_arp_add_del": {
+ "reply": "proxy_arp_add_del_reply"
+ },
+ "ip_add_del_route": {
+ "reply": "ip_add_del_route_reply"
+ },
+ "ip6nd_proxy_dump": {
+ "reply": "ip6nd_proxy_details",
+ "stream": true
+ },
+ "want_ip6_ra_events": {
+ "reply": "want_ip6_ra_events_reply",
+ "events": [
+ "ip6_ra_event"
+ ]
+ },
+ "ip_fib_dump": {
+ "reply": "ip_fib_details",
+ "stream": true
+ },
+ "ip_scan_neighbor_enable_disable": {
+ "reply": "ip_scan_neighbor_enable_disable_reply"
+ },
+ "ioam_enable": {
+ "reply": "ioam_enable_reply"
+ },
+ "ip_mroute_add_del": {
+ "reply": "ip_mroute_add_del_reply"
+ },
+ "proxy_arp_intfc_dump": {
+ "reply": "proxy_arp_intfc_details",
+ "stream": true
+ },
+ "want_ip4_arp_events": {
+ "reply": "want_ip4_arp_events_reply",
+ "events": [
+ "ip4_arp_event"
+ ]
+ },
+ "ip_reassembly_get": {
+ "reply": "ip_reassembly_get_reply"
+ },
+ "set_ip_flow_hash": {
+ "reply": "set_ip_flow_hash_reply"
+ },
+ "ioam_disable": {
+ "reply": "ioam_disable_reply"
+ }
+ },
+ "enums": [
+ [
+ "address_family",
+ [
+ "ADDRESS_IP4",
+ 0
+ ],
+ [
+ "ADDRESS_IP6",
+ 1
+ ],
+ {
+ "enumtype": "u32"
+ }
+ ]
+ ],
+ "types": [
+ [
+ "ip4_address",
+ [
+ "u8",
+ "address",
+ 4
+ ],
+ {
+ "crc": "0xfc4baa28"
+ }
+ ],
+ [
+ "ip6_address",
+ [
+ "u8",
+ "address",
+ 16
+ ],
+ {
+ "crc": "0xad99ccc2"
+ }
+ ],
+ [
+ "address",
+ [
+ "vl_api_address_family_t",
+ "af"
+ ],
+ [
+ "vl_api_address_union_t",
+ "un"
+ ],
+ {
+ "crc": "0x09f11671"
+ }
+ ],
+ [
+ "prefix",
+ [
+ "vl_api_address_t",
+ "address"
+ ],
+ [
+ "u8",
+ "address_length"
+ ],
+ {
+ "crc": "0x0403aebc"
+ }
+ ],
+ [
+ "fib_mpls_label",
+ [
+ "u8",
+ "is_uniform"
+ ],
+ [
+ "u32",
+ "label"
+ ],
+ [
+ "u8",
+ "ttl"
+ ],
+ [
+ "u8",
+ "exp"
+ ],
+ {
+ "crc": "0xc93bf35c"
+ }
+ ],
+ [
+ "fib_path",
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u32",
+ "table_id"
+ ],
+ [
+ "u8",
+ "weight"
+ ],
+ [
+ "u8",
+ "preference"
+ ],
+ [
+ "u8",
+ "is_local"
+ ],
+ [
+ "u8",
+ "is_drop"
+ ],
+ [
+ "u8",
+ "is_udp_encap"
],
[
"u8",
"u8",
"is_prohibit"
],
+ [
+ "u8",
+ "is_resolve_host"
+ ],
+ [
+ "u8",
+ "is_resolve_attached"
+ ],
+ [
+ "u8",
+ "is_dvr"
+ ],
+ [
+ "u8",
+ "is_source_lookup"
+ ],
[
"u8",
"afi"
"next_hop",
16
],
+ [
+ "u32",
+ "next_hop_id"
+ ],
+ [
+ "u32",
+ "rpf_id"
+ ],
+ [
+ "u32",
+ "via_label"
+ ],
+ [
+ "u8",
+ "n_labels"
+ ],
+ [
+ "vl_api_fib_mpls_label_t",
+ "label_stack",
+ 16
+ ],
+ {
+ "crc": "0xabe483ef"
+ }
+ ],
+ [
+ "ip6_ra_prefix_info",
+ [
+ "u8",
+ "dst_address",
+ 16
+ ],
+ [
+ "u8",
+ "dst_address_length"
+ ],
+ [
+ "u8",
+ "flags"
+ ],
+ [
+ "u32",
+ "valid_time"
+ ],
+ [
+ "u32",
+ "preferred_time"
+ ],
+ {
+ "crc": "0x83d7c6e5"
+ }
+ ],
+ [
+ "proxy_arp",
+ [
+ "u32",
+ "vrf_id"
+ ],
+ [
+ "u8",
+ "low_address",
+ 4
+ ],
+ [
+ "u8",
+ "hi_address",
+ 4
+ ],
{
- "crc": "0xcd899e0a"
+ "crc": "0x6d88106e"
}
]
]
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package ip represents the VPP binary API of the 'ip' VPP module.
-// Generated from '../../bin_api/ip.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: ip.api.json
+
+/*
+Package ip is a generated VPP binary API of the 'ip' VPP module.
+
+It is generated from this file:
+ ip.api.json
+
+It contains these VPP binary API objects:
+ 87 messages
+ 8 types
+ 1 enum
+ 1 union
+ 42 services
+*/
package ip
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0xb395c625
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
-// FibPath represents the VPP binary API data type 'fib_path'.
-// Generated from '../../bin_api/ip.api.json', line 2199:
+/* Enums */
+
+// AddressFamily represents the VPP binary API enum 'address_family'.
+// Generated from 'ip.api.json', line 2727:
+//
+// "address_family",
+// [
+// "ADDRESS_IP4",
+// 0
+// ],
+// [
+// "ADDRESS_IP6",
+// 1
+// ],
+// {
+// "enumtype": "u32"
+// }
+//
+type AddressFamily uint32
+
+const (
+ ADDRESS_IP4 AddressFamily = 0
+ ADDRESS_IP6 AddressFamily = 1
+)
+
+/* Types */
+
+// IP4Address represents the VPP binary API type 'ip4_address'.
+// Generated from 'ip.api.json', line 2743:
+//
+// "ip4_address",
+// [
+// "u8",
+// "address",
+// 4
+// ],
+// {
+// "crc": "0xfc4baa28"
+// }
+//
+type IP4Address struct {
+ Address []byte `struc:"[4]byte"`
+}
+
+func (*IP4Address) GetTypeName() string {
+ return "ip4_address"
+}
+func (*IP4Address) GetCrcString() string {
+ return "fc4baa28"
+}
+
+// IP6Address represents the VPP binary API type 'ip6_address'.
+// Generated from 'ip.api.json', line 2754:
+//
+// "ip6_address",
+// [
+// "u8",
+// "address",
+// 16
+// ],
+// {
+// "crc": "0xad99ccc2"
+// }
+//
+type IP6Address struct {
+ Address []byte `struc:"[16]byte"`
+}
+
+func (*IP6Address) GetTypeName() string {
+ return "ip6_address"
+}
+func (*IP6Address) GetCrcString() string {
+ return "ad99ccc2"
+}
+
+// Address represents the VPP binary API type 'address'.
+// Generated from 'ip.api.json', line 2765:
+//
+// "address",
+// [
+// "vl_api_address_family_t",
+// "af"
+// ],
+// [
+// "vl_api_address_union_t",
+// "un"
+// ],
+// {
+// "crc": "0x09f11671"
+// }
+//
+type Address struct {
+ Af AddressFamily
+ Un AddressUnion
+}
+
+func (*Address) GetTypeName() string {
+ return "address"
+}
+func (*Address) GetCrcString() string {
+ return "09f11671"
+}
+
+// Prefix represents the VPP binary API type 'prefix'.
+// Generated from 'ip.api.json', line 2779:
+//
+// "prefix",
+// [
+// "vl_api_address_t",
+// "address"
+// ],
+// [
+// "u8",
+// "address_length"
+// ],
+// {
+// "crc": "0x0403aebc"
+// }
+//
+type Prefix struct {
+ Address Address
+ AddressLength uint8
+}
+
+func (*Prefix) GetTypeName() string {
+ return "prefix"
+}
+func (*Prefix) GetCrcString() string {
+ return "0403aebc"
+}
+
+// FibMplsLabel represents the VPP binary API type 'fib_mpls_label'.
+// Generated from 'ip.api.json', line 2793:
+//
+// "fib_mpls_label",
+// [
+// "u8",
+// "is_uniform"
+// ],
+// [
+// "u32",
+// "label"
+// ],
+// [
+// "u8",
+// "ttl"
+// ],
+// [
+// "u8",
+// "exp"
+// ],
+// {
+// "crc": "0xc93bf35c"
+// }
+//
+type FibMplsLabel struct {
+ IsUniform uint8
+ Label uint32
+ TTL uint8
+ Exp uint8
+}
+
+func (*FibMplsLabel) GetTypeName() string {
+ return "fib_mpls_label"
+}
+func (*FibMplsLabel) GetCrcString() string {
+ return "c93bf35c"
+}
+
+// FibPath represents the VPP binary API type 'fib_path'.
+// Generated from 'ip.api.json', line 2815:
//
// "fib_path",
// [
// ],
// [
// "u8",
+// "is_udp_encap"
+// ],
+// [
+// "u8",
// "is_unreach"
// ],
// [
// ],
// [
// "u8",
+// "is_resolve_host"
+// ],
+// [
+// "u8",
+// "is_resolve_attached"
+// ],
+// [
+// "u8",
+// "is_dvr"
+// ],
+// [
+// "u8",
+// "is_source_lookup"
+// ],
+// [
+// "u8",
// "afi"
// ],
// [
// "next_hop",
// 16
// ],
+// [
+// "u32",
+// "next_hop_id"
+// ],
+// [
+// "u32",
+// "rpf_id"
+// ],
+// [
+// "u32",
+// "via_label"
+// ],
+// [
+// "u8",
+// "n_labels"
+// ],
+// [
+// "vl_api_fib_mpls_label_t",
+// "label_stack",
+// 16
+// ],
// {
-// "crc": "0xcd899e0a"
+// "crc": "0xabe483ef"
// }
//
type FibPath struct {
- SwIfIndex uint32
- TableID uint32
- Weight uint8
- Preference uint8
- IsLocal uint8
- IsDrop uint8
- IsUnreach uint8
- IsProhibit uint8
- Afi uint8
- NextHop []byte `struc:"[16]byte"`
+ SwIfIndex uint32
+ TableID uint32
+ Weight uint8
+ Preference uint8
+ IsLocal uint8
+ IsDrop uint8
+ IsUDPEncap uint8
+ IsUnreach uint8
+ IsProhibit uint8
+ IsResolveHost uint8
+ IsResolveAttached uint8
+ IsDvr uint8
+ IsSourceLookup uint8
+ Afi uint8
+ NextHop []byte `struc:"[16]byte"`
+ NextHopID uint32
+ RpfID uint32
+ ViaLabel uint32
+ NLabels uint8
+ LabelStack []FibMplsLabel `struc:"[16]FibMplsLabel"`
}
func (*FibPath) GetTypeName() string {
return "fib_path"
}
func (*FibPath) GetCrcString() string {
- return "cd899e0a"
+ return "abe483ef"
+}
+
+// IP6RaPrefixInfo represents the VPP binary API type 'ip6_ra_prefix_info'.
+// Generated from 'ip.api.json', line 2903:
+//
+// "ip6_ra_prefix_info",
+// [
+// "u8",
+// "dst_address",
+// 16
+// ],
+// [
+// "u8",
+// "dst_address_length"
+// ],
+// [
+// "u8",
+// "flags"
+// ],
+// [
+// "u32",
+// "valid_time"
+// ],
+// [
+// "u32",
+// "preferred_time"
+// ],
+// {
+// "crc": "0x83d7c6e5"
+// }
+//
+type IP6RaPrefixInfo struct {
+ DstAddress []byte `struc:"[16]byte"`
+ DstAddressLength uint8
+ Flags uint8
+ ValidTime uint32
+ PreferredTime uint32
+}
+
+func (*IP6RaPrefixInfo) GetTypeName() string {
+ return "ip6_ra_prefix_info"
+}
+func (*IP6RaPrefixInfo) GetCrcString() string {
+ return "83d7c6e5"
+}
+
+// ProxyArp represents the VPP binary API type 'proxy_arp'.
+// Generated from 'ip.api.json', line 2930:
+//
+// "proxy_arp",
+// [
+// "u32",
+// "vrf_id"
+// ],
+// [
+// "u8",
+// "low_address",
+// 4
+// ],
+// [
+// "u8",
+// "hi_address",
+// 4
+// ],
+// {
+// "crc": "0x6d88106e"
+// }
+//
+type ProxyArp struct {
+ VrfID uint32
+ LowAddress []byte `struc:"[4]byte"`
+ HiAddress []byte `struc:"[4]byte"`
+}
+
+func (*ProxyArp) GetTypeName() string {
+ return "proxy_arp"
+}
+func (*ProxyArp) GetCrcString() string {
+ return "6d88106e"
+}
+
+/* Unions */
+
+// AddressUnion represents the VPP binary API union 'address_union'.
+// Generated from 'ip.api.json', line 2562:
+//
+// "address_union",
+// [
+// "vl_api_ip4_address_t",
+// "ip4"
+// ],
+// [
+// "vl_api_ip6_address_t",
+// "ip6"
+// ],
+// {
+// "crc": "0xd68a2fb4"
+// }
+//
+type AddressUnion struct {
+ Union_data [16]byte
+}
+
+func (*AddressUnion) GetTypeName() string {
+ return "address_union"
+}
+func (*AddressUnion) GetCrcString() string {
+ return "d68a2fb4"
+}
+
+func (u *AddressUnion) SetIP4(a IP4Address) {
+ var b = new(bytes.Buffer)
+ if err := struc.Pack(b, &a); err != nil {
+ return
+ }
+ copy(u.Union_data[:], b.Bytes())
+}
+func (u *AddressUnion) GetIP4() (a IP4Address) {
+ var b = bytes.NewReader(u.Union_data[:])
+ struc.Unpack(b, &a)
+ return
+}
+
+func (u *AddressUnion) SetIP6(a IP6Address) {
+ var b = new(bytes.Buffer)
+ if err := struc.Pack(b, &a); err != nil {
+ return
+ }
+ copy(u.Union_data[:], b.Bytes())
+}
+func (u *AddressUnion) GetIP6() (a IP6Address) {
+ var b = bytes.NewReader(u.Union_data[:])
+ struc.Unpack(b, &a)
+ return
}
+/* Messages */
+
// IPTableAddDel represents the VPP binary API message 'ip_table_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 187:
+// Generated from 'ip.api.json', line 4:
//
// "ip_table_add_del",
// [
//
type IPTableAddDel struct {
TableID uint32
- IsIpv6 uint8
+ IsIPv6 uint8
IsAdd uint8
Name []byte `struc:"[64]byte"`
}
func (*IPTableAddDel) GetMessageName() string {
return "ip_table_add_del"
}
-func (*IPTableAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPTableAddDel) GetCrcString() string {
return "0240c89d"
}
+func (*IPTableAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPTableAddDel() api.Message {
return &IPTableAddDel{}
}
// IPTableAddDelReply represents the VPP binary API message 'ip_table_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 222:
+// Generated from 'ip.api.json', line 39:
//
// "ip_table_add_del_reply",
// [
func (*IPTableAddDelReply) GetMessageName() string {
return "ip_table_add_del_reply"
}
-func (*IPTableAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPTableAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPTableAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPTableAddDelReply() api.Message {
return &IPTableAddDelReply{}
}
// IPFibDump represents the VPP binary API message 'ip_fib_dump'.
-// Generated from '../../bin_api/ip.api.json', line 240:
+// Generated from 'ip.api.json', line 57:
//
// "ip_fib_dump",
// [
// "crc": "0x51077d14"
// }
//
-type IPFibDump struct {
-}
+type IPFibDump struct{}
func (*IPFibDump) GetMessageName() string {
return "ip_fib_dump"
}
-func (*IPFibDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPFibDump) GetCrcString() string {
return "51077d14"
}
+func (*IPFibDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPFibDump() api.Message {
return &IPFibDump{}
}
// IPFibDetails represents the VPP binary API message 'ip_fib_details'.
-// Generated from '../../bin_api/ip.api.json', line 258:
+// Generated from 'ip.api.json', line 75:
//
// "ip_fib_details",
// [
func (*IPFibDetails) GetMessageName() string {
return "ip_fib_details"
}
-func (*IPFibDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPFibDetails) GetCrcString() string {
return "99dfd73b"
}
+func (*IPFibDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPFibDetails() api.Message {
return &IPFibDetails{}
}
// IP6FibDump represents the VPP binary API message 'ip6_fib_dump'.
-// Generated from '../../bin_api/ip.api.json', line 300:
+// Generated from 'ip.api.json', line 117:
//
// "ip6_fib_dump",
// [
// "crc": "0x51077d14"
// }
//
-type IP6FibDump struct {
-}
+type IP6FibDump struct{}
func (*IP6FibDump) GetMessageName() string {
return "ip6_fib_dump"
}
-func (*IP6FibDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IP6FibDump) GetCrcString() string {
return "51077d14"
}
+func (*IP6FibDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIP6FibDump() api.Message {
return &IP6FibDump{}
}
// IP6FibDetails represents the VPP binary API message 'ip6_fib_details'.
-// Generated from '../../bin_api/ip.api.json', line 318:
+// Generated from 'ip.api.json', line 135:
//
// "ip6_fib_details",
// [
func (*IP6FibDetails) GetMessageName() string {
return "ip6_fib_details"
}
-func (*IP6FibDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IP6FibDetails) GetCrcString() string {
return "abd0060e"
}
+func (*IP6FibDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIP6FibDetails() api.Message {
return &IP6FibDetails{}
}
// IPNeighborDump represents the VPP binary API message 'ip_neighbor_dump'.
-// Generated from '../../bin_api/ip.api.json', line 360:
+// Generated from 'ip.api.json', line 177:
//
// "ip_neighbor_dump",
// [
//
type IPNeighborDump struct {
SwIfIndex uint32
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*IPNeighborDump) GetMessageName() string {
return "ip_neighbor_dump"
}
-func (*IPNeighborDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPNeighborDump) GetCrcString() string {
return "6b7bcd0a"
}
+func (*IPNeighborDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPNeighborDump() api.Message {
return &IPNeighborDump{}
}
// IPNeighborDetails represents the VPP binary API message 'ip_neighbor_details'.
-// Generated from '../../bin_api/ip.api.json', line 386:
+// Generated from 'ip.api.json', line 203:
//
// "ip_neighbor_details",
// [
type IPNeighborDetails struct {
SwIfIndex uint32
IsStatic uint8
- IsIpv6 uint8
+ IsIPv6 uint8
MacAddress []byte `struc:"[6]byte"`
IPAddress []byte `struc:"[16]byte"`
}
func (*IPNeighborDetails) GetMessageName() string {
return "ip_neighbor_details"
}
-func (*IPNeighborDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPNeighborDetails) GetCrcString() string {
return "85e32a72"
}
+func (*IPNeighborDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPNeighborDetails() api.Message {
return &IPNeighborDetails{}
}
// IPNeighborAddDel represents the VPP binary API message 'ip_neighbor_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 422:
+// Generated from 'ip.api.json', line 239:
//
// "ip_neighbor_add_del",
// [
type IPNeighborAddDel struct {
SwIfIndex uint32
IsAdd uint8
- IsIpv6 uint8
+ IsIPv6 uint8
IsStatic uint8
IsNoAdjFib uint8
MacAddress []byte `struc:"[6]byte"`
func (*IPNeighborAddDel) GetMessageName() string {
return "ip_neighbor_add_del"
}
-func (*IPNeighborAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPNeighborAddDel) GetCrcString() string {
return "4711eb25"
}
+func (*IPNeighborAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPNeighborAddDel() api.Message {
return &IPNeighborAddDel{}
}
// IPNeighborAddDelReply represents the VPP binary API message 'ip_neighbor_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 470:
+// Generated from 'ip.api.json', line 287:
//
// "ip_neighbor_add_del_reply",
// [
func (*IPNeighborAddDelReply) GetMessageName() string {
return "ip_neighbor_add_del_reply"
}
-func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPNeighborAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPNeighborAddDelReply() api.Message {
return &IPNeighborAddDelReply{}
}
// SetIPFlowHash represents the VPP binary API message 'set_ip_flow_hash'.
-// Generated from '../../bin_api/ip.api.json', line 488:
+// Generated from 'ip.api.json', line 305:
//
// "set_ip_flow_hash",
// [
//
type SetIPFlowHash struct {
VrfID uint32
- IsIpv6 uint8
+ IsIPv6 uint8
Src uint8
Dst uint8
Sport uint8
func (*SetIPFlowHash) GetMessageName() string {
return "set_ip_flow_hash"
}
-func (*SetIPFlowHash) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SetIPFlowHash) GetCrcString() string {
return "32ebf737"
}
+func (*SetIPFlowHash) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSetIPFlowHash() api.Message {
return &SetIPFlowHash{}
}
// SetIPFlowHashReply represents the VPP binary API message 'set_ip_flow_hash_reply'.
-// Generated from '../../bin_api/ip.api.json', line 538:
+// Generated from 'ip.api.json', line 355:
//
// "set_ip_flow_hash_reply",
// [
func (*SetIPFlowHashReply) GetMessageName() string {
return "set_ip_flow_hash_reply"
}
-func (*SetIPFlowHashReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SetIPFlowHashReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SetIPFlowHashReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSetIPFlowHashReply() api.Message {
return &SetIPFlowHashReply{}
}
// SwInterfaceIP6ndRaConfig represents the VPP binary API message 'sw_interface_ip6nd_ra_config'.
-// Generated from '../../bin_api/ip.api.json', line 556:
+// Generated from 'ip.api.json', line 373:
//
// "sw_interface_ip6nd_ra_config",
// [
func (*SwInterfaceIP6ndRaConfig) GetMessageName() string {
return "sw_interface_ip6nd_ra_config"
}
-func (*SwInterfaceIP6ndRaConfig) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceIP6ndRaConfig) GetCrcString() string {
return "c3f02daa"
}
+func (*SwInterfaceIP6ndRaConfig) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceIP6ndRaConfig() api.Message {
return &SwInterfaceIP6ndRaConfig{}
}
// SwInterfaceIP6ndRaConfigReply represents the VPP binary API message 'sw_interface_ip6nd_ra_config_reply'.
-// Generated from '../../bin_api/ip.api.json', line 630:
+// Generated from 'ip.api.json', line 447:
//
// "sw_interface_ip6nd_ra_config_reply",
// [
func (*SwInterfaceIP6ndRaConfigReply) GetMessageName() string {
return "sw_interface_ip6nd_ra_config_reply"
}
-func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceIP6ndRaConfigReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceIP6ndRaConfigReply() api.Message {
return &SwInterfaceIP6ndRaConfigReply{}
}
// SwInterfaceIP6ndRaPrefix represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix'.
-// Generated from '../../bin_api/ip.api.json', line 648:
+// Generated from 'ip.api.json', line 465:
//
// "sw_interface_ip6nd_ra_prefix",
// [
func (*SwInterfaceIP6ndRaPrefix) GetMessageName() string {
return "sw_interface_ip6nd_ra_prefix"
}
-func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceIP6ndRaPrefix) GetCrcString() string {
return "ca763c9a"
}
+func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceIP6ndRaPrefix() api.Message {
return &SwInterfaceIP6ndRaPrefix{}
}
// SwInterfaceIP6ndRaPrefixReply represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix_reply'.
-// Generated from '../../bin_api/ip.api.json', line 711:
+// Generated from 'ip.api.json', line 528:
//
// "sw_interface_ip6nd_ra_prefix_reply",
// [
func (*SwInterfaceIP6ndRaPrefixReply) GetMessageName() string {
return "sw_interface_ip6nd_ra_prefix_reply"
}
-func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceIP6ndRaPrefixReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceIP6ndRaPrefixReply() api.Message {
return &SwInterfaceIP6ndRaPrefixReply{}
}
// IP6ndProxyAddDel represents the VPP binary API message 'ip6nd_proxy_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 729:
+// Generated from 'ip.api.json', line 546:
//
// "ip6nd_proxy_add_del",
// [
func (*IP6ndProxyAddDel) GetMessageName() string {
return "ip6nd_proxy_add_del"
}
-func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IP6ndProxyAddDel) GetCrcString() string {
return "d95f0fa0"
}
+func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIP6ndProxyAddDel() api.Message {
return &IP6ndProxyAddDel{}
}
// IP6ndProxyAddDelReply represents the VPP binary API message 'ip6nd_proxy_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 760:
+// Generated from 'ip.api.json', line 577:
//
// "ip6nd_proxy_add_del_reply",
// [
func (*IP6ndProxyAddDelReply) GetMessageName() string {
return "ip6nd_proxy_add_del_reply"
}
-func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IP6ndProxyAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIP6ndProxyAddDelReply() api.Message {
return &IP6ndProxyAddDelReply{}
}
// IP6ndProxyDetails represents the VPP binary API message 'ip6nd_proxy_details'.
-// Generated from '../../bin_api/ip.api.json', line 778:
+// Generated from 'ip.api.json', line 595:
//
// "ip6nd_proxy_details",
// [
func (*IP6ndProxyDetails) GetMessageName() string {
return "ip6nd_proxy_details"
}
-func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IP6ndProxyDetails) GetCrcString() string {
return "d73bf1ab"
}
+func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIP6ndProxyDetails() api.Message {
return &IP6ndProxyDetails{}
}
// IP6ndProxyDump represents the VPP binary API message 'ip6nd_proxy_dump'.
-// Generated from '../../bin_api/ip.api.json', line 805:
+// Generated from 'ip.api.json', line 622:
//
// "ip6nd_proxy_dump",
// [
// "crc": "0x51077d14"
// }
//
-type IP6ndProxyDump struct {
-}
+type IP6ndProxyDump struct{}
func (*IP6ndProxyDump) GetMessageName() string {
return "ip6nd_proxy_dump"
}
-func (*IP6ndProxyDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IP6ndProxyDump) GetCrcString() string {
return "51077d14"
}
+func (*IP6ndProxyDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIP6ndProxyDump() api.Message {
return &IP6ndProxyDump{}
}
+// IP6ndSendRouterSolicitation represents the VPP binary API message 'ip6nd_send_router_solicitation'.
+// Generated from 'ip.api.json', line 640:
+//
+// "ip6nd_send_router_solicitation",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "irt"
+// ],
+// [
+// "u32",
+// "mrt"
+// ],
+// [
+// "u32",
+// "mrc"
+// ],
+// [
+// "u32",
+// "mrd"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "stop"
+// ],
+// {
+// "crc": "0xbd968917"
+// }
+//
+type IP6ndSendRouterSolicitation struct {
+ Irt uint32
+ Mrt uint32
+ Mrc uint32
+ Mrd uint32
+ SwIfIndex uint32
+ Stop uint8
+}
+
+func (*IP6ndSendRouterSolicitation) GetMessageName() string {
+ return "ip6nd_send_router_solicitation"
+}
+func (*IP6ndSendRouterSolicitation) GetCrcString() string {
+ return "bd968917"
+}
+func (*IP6ndSendRouterSolicitation) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIP6ndSendRouterSolicitation() api.Message {
+ return &IP6ndSendRouterSolicitation{}
+}
+
+// IP6ndSendRouterSolicitationReply represents the VPP binary API message 'ip6nd_send_router_solicitation_reply'.
+// Generated from 'ip.api.json', line 682:
+//
+// "ip6nd_send_router_solicitation_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type IP6ndSendRouterSolicitationReply struct {
+ Retval int32
+}
+
+func (*IP6ndSendRouterSolicitationReply) GetMessageName() string {
+ return "ip6nd_send_router_solicitation_reply"
+}
+func (*IP6ndSendRouterSolicitationReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*IP6ndSendRouterSolicitationReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewIP6ndSendRouterSolicitationReply() api.Message {
+ return &IP6ndSendRouterSolicitationReply{}
+}
+
// SwInterfaceIP6EnableDisable represents the VPP binary API message 'sw_interface_ip6_enable_disable'.
-// Generated from '../../bin_api/ip.api.json', line 823:
+// Generated from 'ip.api.json', line 700:
//
// "sw_interface_ip6_enable_disable",
// [
func (*SwInterfaceIP6EnableDisable) GetMessageName() string {
return "sw_interface_ip6_enable_disable"
}
-func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceIP6EnableDisable) GetCrcString() string {
return "a36fadc0"
}
+func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceIP6EnableDisable() api.Message {
return &SwInterfaceIP6EnableDisable{}
}
// SwInterfaceIP6EnableDisableReply represents the VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
-// Generated from '../../bin_api/ip.api.json', line 849:
+// Generated from 'ip.api.json', line 726:
//
// "sw_interface_ip6_enable_disable_reply",
// [
func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
return "sw_interface_ip6_enable_disable_reply"
}
-func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceIP6EnableDisableReply() api.Message {
return &SwInterfaceIP6EnableDisableReply{}
}
// SwInterfaceIP6SetLinkLocalAddress represents the VPP binary API message 'sw_interface_ip6_set_link_local_address'.
-// Generated from '../../bin_api/ip.api.json', line 867:
+// Generated from 'ip.api.json', line 744:
//
// "sw_interface_ip6_set_link_local_address",
// [
func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
return "sw_interface_ip6_set_link_local_address"
}
-func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string {
return "d73bf1ab"
}
+func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceIP6SetLinkLocalAddress() api.Message {
return &SwInterfaceIP6SetLinkLocalAddress{}
}
// SwInterfaceIP6SetLinkLocalAddressReply represents the VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
-// Generated from '../../bin_api/ip.api.json', line 894:
+// Generated from 'ip.api.json', line 771:
//
// "sw_interface_ip6_set_link_local_address_reply",
// [
func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
return "sw_interface_ip6_set_link_local_address_reply"
}
-func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceIP6SetLinkLocalAddressReply() api.Message {
return &SwInterfaceIP6SetLinkLocalAddressReply{}
}
// IPAddDelRoute represents the VPP binary API message 'ip_add_del_route'.
-// Generated from '../../bin_api/ip.api.json', line 912:
+// Generated from 'ip.api.json', line 789:
//
// "ip_add_del_route",
// [
// "next_hop_via_label"
// ],
// [
-// "u32",
+// "vl_api_fib_mpls_label_t",
// "next_hop_out_label_stack",
// 0,
// "next_hop_n_out_labels"
// ],
// {
-// "crc": "0xc85f8290"
+// "crc": "0x4219d62d"
// }
//
type IPAddDelRoute struct {
IsDrop uint8
IsUnreach uint8
IsProhibit uint8
- IsIpv6 uint8
+ IsIPv6 uint8
IsLocal uint8
IsClassify uint8
IsMultipath uint8
NextHopAddress []byte `struc:"[16]byte"`
NextHopNOutLabels uint8 `struc:"sizeof=NextHopOutLabelStack"`
NextHopViaLabel uint32
- NextHopOutLabelStack []uint32
+ NextHopOutLabelStack []FibMplsLabel
}
func (*IPAddDelRoute) GetMessageName() string {
return "ip_add_del_route"
}
+func (*IPAddDelRoute) GetCrcString() string {
+ return "4219d62d"
+}
func (*IPAddDelRoute) GetMessageType() api.MessageType {
return api.RequestMessage
}
-func (*IPAddDelRoute) GetCrcString() string {
- return "c85f8290"
-}
func NewIPAddDelRoute() api.Message {
return &IPAddDelRoute{}
}
// IPAddDelRouteReply represents the VPP binary API message 'ip_add_del_route_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1042:
+// Generated from 'ip.api.json', line 919:
//
// "ip_add_del_route_reply",
// [
func (*IPAddDelRouteReply) GetMessageName() string {
return "ip_add_del_route_reply"
}
-func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPAddDelRouteReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPAddDelRouteReply() api.Message {
return &IPAddDelRouteReply{}
}
// IPMrouteAddDel represents the VPP binary API message 'ip_mroute_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 1060:
+// Generated from 'ip.api.json', line 937:
//
// "ip_mroute_add_del",
// [
// "src_address",
// 16
// ],
+// [
+// "u8",
+// "nh_address",
+// 16
+// ],
// {
-// "crc": "0xc37112f7"
+// "crc": "0xf44c17b1"
// }
//
type IPMrouteAddDel struct {
GrpAddressLength uint16
NextHopAfi uint8
IsAdd uint8
- IsIpv6 uint8
+ IsIPv6 uint8
IsLocal uint8
GrpAddress []byte `struc:"[16]byte"`
SrcAddress []byte `struc:"[16]byte"`
+ NhAddress []byte `struc:"[16]byte"`
}
func (*IPMrouteAddDel) GetMessageName() string {
return "ip_mroute_add_del"
}
+func (*IPMrouteAddDel) GetCrcString() string {
+ return "f44c17b1"
+}
func (*IPMrouteAddDel) GetMessageType() api.MessageType {
return api.RequestMessage
}
-func (*IPMrouteAddDel) GetCrcString() string {
- return "c37112f7"
-}
func NewIPMrouteAddDel() api.Message {
return &IPMrouteAddDel{}
}
// IPMrouteAddDelReply represents the VPP binary API message 'ip_mroute_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1132:
+// Generated from 'ip.api.json', line 1014:
//
// "ip_mroute_add_del_reply",
// [
func (*IPMrouteAddDelReply) GetMessageName() string {
return "ip_mroute_add_del_reply"
}
-func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPMrouteAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPMrouteAddDelReply() api.Message {
return &IPMrouteAddDelReply{}
}
// IPMfibDump represents the VPP binary API message 'ip_mfib_dump'.
-// Generated from '../../bin_api/ip.api.json', line 1150:
+// Generated from 'ip.api.json', line 1032:
//
// "ip_mfib_dump",
// [
// "crc": "0x51077d14"
// }
//
-type IPMfibDump struct {
-}
+type IPMfibDump struct{}
func (*IPMfibDump) GetMessageName() string {
return "ip_mfib_dump"
}
-func (*IPMfibDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPMfibDump) GetCrcString() string {
return "51077d14"
}
+func (*IPMfibDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPMfibDump() api.Message {
return &IPMfibDump{}
}
// IPMfibDetails represents the VPP binary API message 'ip_mfib_details'.
-// Generated from '../../bin_api/ip.api.json', line 1168:
+// Generated from 'ip.api.json', line 1050:
//
// "ip_mfib_details",
// [
func (*IPMfibDetails) GetMessageName() string {
return "ip_mfib_details"
}
-func (*IPMfibDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPMfibDetails) GetCrcString() string {
return "5e530d5e"
}
+func (*IPMfibDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPMfibDetails() api.Message {
return &IPMfibDetails{}
}
// IP6MfibDump represents the VPP binary API message 'ip6_mfib_dump'.
-// Generated from '../../bin_api/ip.api.json', line 1218:
+// Generated from 'ip.api.json', line 1100:
//
// "ip6_mfib_dump",
// [
// "crc": "0x51077d14"
// }
//
-type IP6MfibDump struct {
-}
+type IP6MfibDump struct{}
func (*IP6MfibDump) GetMessageName() string {
return "ip6_mfib_dump"
}
-func (*IP6MfibDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IP6MfibDump) GetCrcString() string {
return "51077d14"
}
+func (*IP6MfibDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIP6MfibDump() api.Message {
return &IP6MfibDump{}
}
// IP6MfibDetails represents the VPP binary API message 'ip6_mfib_details'.
-// Generated from '../../bin_api/ip.api.json', line 1236:
+// Generated from 'ip.api.json', line 1118:
//
// "ip6_mfib_details",
// [
func (*IP6MfibDetails) GetMessageName() string {
return "ip6_mfib_details"
}
-func (*IP6MfibDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IP6MfibDetails) GetCrcString() string {
return "e02dcb4b"
}
+func (*IP6MfibDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIP6MfibDetails() api.Message {
return &IP6MfibDetails{}
}
// IPAddressDetails represents the VPP binary API message 'ip_address_details'.
-// Generated from '../../bin_api/ip.api.json', line 1278:
+// Generated from 'ip.api.json', line 1160:
//
// "ip_address_details",
// [
IP []byte `struc:"[16]byte"`
PrefixLength uint8
SwIfIndex uint32
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*IPAddressDetails) GetMessageName() string {
return "ip_address_details"
}
-func (*IPAddressDetails) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPAddressDetails) GetCrcString() string {
return "bc7442f2"
}
+func (*IPAddressDetails) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPAddressDetails() api.Message {
return &IPAddressDetails{}
}
// IPAddressDump represents the VPP binary API message 'ip_address_dump'.
-// Generated from '../../bin_api/ip.api.json', line 1313:
+// Generated from 'ip.api.json', line 1195:
//
// "ip_address_dump",
// [
//
type IPAddressDump struct {
SwIfIndex uint32
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*IPAddressDump) GetMessageName() string {
return "ip_address_dump"
}
-func (*IPAddressDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPAddressDump) GetCrcString() string {
return "6b7bcd0a"
}
+func (*IPAddressDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPAddressDump() api.Message {
return &IPAddressDump{}
}
-// IPDetails represents the VPP binary API message 'ip_details'.
-// Generated from '../../bin_api/ip.api.json', line 1339:
+// IPUnnumberedDetails represents the VPP binary API message 'ip_unnumbered_details'.
+// Generated from 'ip.api.json', line 1221:
//
-// "ip_details",
+// "ip_unnumbered_details",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
// "u32",
-// "sw_if_index"
+// "client_index"
// ],
// [
// "u32",
// "context"
// ],
// [
-// "u8",
-// "is_ipv6"
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u32",
+// "ip_sw_if_index"
// ],
// {
-// "crc": "0x452ffc5a"
+// "crc": "0x05b717ca"
// }
//
-type IPDetails struct {
- SwIfIndex uint32
- Context uint32
- IsIpv6 uint8
+type IPUnnumberedDetails struct {
+ SwIfIndex uint32
+ IPSwIfIndex uint32
}
-func (*IPDetails) GetMessageName() string {
- return "ip_details"
+func (*IPUnnumberedDetails) GetMessageName() string {
+ return "ip_unnumbered_details"
}
-func (*IPDetails) GetMessageType() api.MessageType {
- return api.OtherMessage
+func (*IPUnnumberedDetails) GetCrcString() string {
+ return "05b717ca"
}
-func (*IPDetails) GetCrcString() string {
- return "452ffc5a"
+func (*IPUnnumberedDetails) GetMessageType() api.MessageType {
+ return api.RequestMessage
}
-func NewIPDetails() api.Message {
- return &IPDetails{}
+func NewIPUnnumberedDetails() api.Message {
+ return &IPUnnumberedDetails{}
}
-// IPDump represents the VPP binary API message 'ip_dump'.
-// Generated from '../../bin_api/ip.api.json', line 1361:
+// IPUnnumberedDump represents the VPP binary API message 'ip_unnumbered_dump'.
+// Generated from 'ip.api.json', line 1247:
//
-// "ip_dump",
+// "ip_unnumbered_dump",
// [
// "u16",
// "_vl_msg_id"
// "context"
// ],
// [
-// "u8",
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0x529cb13f"
+// }
+//
+type IPUnnumberedDump struct {
+ SwIfIndex uint32
+}
+
+func (*IPUnnumberedDump) GetMessageName() string {
+ return "ip_unnumbered_dump"
+}
+func (*IPUnnumberedDump) GetCrcString() string {
+ return "529cb13f"
+}
+func (*IPUnnumberedDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIPUnnumberedDump() api.Message {
+ return &IPUnnumberedDump{}
+}
+
+// IPDetails represents the VPP binary API message 'ip_details'.
+// Generated from 'ip.api.json', line 1269:
+//
+// "ip_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "is_ipv6"
+// ],
+// {
+// "crc": "0x452ffc5a"
+// }
+//
+type IPDetails struct {
+ SwIfIndex uint32
+ Context uint32
+ IsIPv6 uint8
+}
+
+func (*IPDetails) GetMessageName() string {
+ return "ip_details"
+}
+func (*IPDetails) GetCrcString() string {
+ return "452ffc5a"
+}
+func (*IPDetails) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewIPDetails() api.Message {
+ return &IPDetails{}
+}
+
+// IPDump represents the VPP binary API message 'ip_dump'.
+// Generated from 'ip.api.json', line 1291:
+//
+// "ip_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
// "is_ipv6"
// ],
// {
// }
//
type IPDump struct {
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*IPDump) GetMessageName() string {
return "ip_dump"
}
-func (*IPDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPDump) GetCrcString() string {
return "de883da4"
}
+func (*IPDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPDump() api.Message {
return &IPDump{}
}
// MfibSignalDump represents the VPP binary API message 'mfib_signal_dump'.
-// Generated from '../../bin_api/ip.api.json', line 1383:
+// Generated from 'ip.api.json', line 1313:
//
// "mfib_signal_dump",
// [
// "crc": "0x51077d14"
// }
//
-type MfibSignalDump struct {
-}
+type MfibSignalDump struct{}
func (*MfibSignalDump) GetMessageName() string {
return "mfib_signal_dump"
}
-func (*MfibSignalDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MfibSignalDump) GetCrcString() string {
return "51077d14"
}
+func (*MfibSignalDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMfibSignalDump() api.Message {
return &MfibSignalDump{}
}
// MfibSignalDetails represents the VPP binary API message 'mfib_signal_details'.
-// Generated from '../../bin_api/ip.api.json', line 1401:
+// Generated from 'ip.api.json', line 1331:
//
// "mfib_signal_details",
// [
func (*MfibSignalDetails) GetMessageName() string {
return "mfib_signal_details"
}
-func (*MfibSignalDetails) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*MfibSignalDetails) GetCrcString() string {
return "791bbeab"
}
+func (*MfibSignalDetails) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewMfibSignalDetails() api.Message {
return &MfibSignalDetails{}
}
// IPPuntPolice represents the VPP binary API message 'ip_punt_police'.
-// Generated from '../../bin_api/ip.api.json', line 1450:
+// Generated from 'ip.api.json', line 1380:
//
// "ip_punt_police",
// [
func (*IPPuntPolice) GetMessageName() string {
return "ip_punt_police"
}
-func (*IPPuntPolice) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPPuntPolice) GetCrcString() string {
return "38691592"
}
+func (*IPPuntPolice) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPPuntPolice() api.Message {
return &IPPuntPolice{}
}
// IPPuntPoliceReply represents the VPP binary API message 'ip_punt_police_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1480:
+// Generated from 'ip.api.json', line 1410:
//
// "ip_punt_police_reply",
// [
func (*IPPuntPoliceReply) GetMessageName() string {
return "ip_punt_police_reply"
}
-func (*IPPuntPoliceReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPPuntPoliceReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPPuntPoliceReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPPuntPoliceReply() api.Message {
return &IPPuntPoliceReply{}
}
// IPPuntRedirect represents the VPP binary API message 'ip_punt_redirect'.
-// Generated from '../../bin_api/ip.api.json', line 1498:
+// Generated from 'ip.api.json', line 1428:
//
// "ip_punt_redirect",
// [
func (*IPPuntRedirect) GetMessageName() string {
return "ip_punt_redirect"
}
-func (*IPPuntRedirect) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPPuntRedirect) GetCrcString() string {
return "996b6603"
}
+func (*IPPuntRedirect) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPPuntRedirect() api.Message {
return &IPPuntRedirect{}
}
// IPPuntRedirectReply represents the VPP binary API message 'ip_punt_redirect_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1537:
+// Generated from 'ip.api.json', line 1467:
//
// "ip_punt_redirect_reply",
// [
func (*IPPuntRedirectReply) GetMessageName() string {
return "ip_punt_redirect_reply"
}
-func (*IPPuntRedirectReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPPuntRedirectReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPPuntRedirectReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPPuntRedirectReply() api.Message {
return &IPPuntRedirectReply{}
}
// IPContainerProxyAddDel represents the VPP binary API message 'ip_container_proxy_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 1555:
+// Generated from 'ip.api.json', line 1485:
//
// "ip_container_proxy_add_del",
// [
func (*IPContainerProxyAddDel) GetMessageName() string {
return "ip_container_proxy_add_del"
}
-func (*IPContainerProxyAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPContainerProxyAddDel) GetCrcString() string {
return "0a355d39"
}
+func (*IPContainerProxyAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPContainerProxyAddDel() api.Message {
return &IPContainerProxyAddDel{}
}
// IPContainerProxyAddDelReply represents the VPP binary API message 'ip_container_proxy_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1594:
+// Generated from 'ip.api.json', line 1524:
//
// "ip_container_proxy_add_del_reply",
// [
func (*IPContainerProxyAddDelReply) GetMessageName() string {
return "ip_container_proxy_add_del_reply"
}
-func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPContainerProxyAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPContainerProxyAddDelReply() api.Message {
return &IPContainerProxyAddDelReply{}
}
// IPSourceAndPortRangeCheckAddDel represents the VPP binary API message 'ip_source_and_port_range_check_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 1612:
+// Generated from 'ip.api.json', line 1542:
//
// "ip_source_and_port_range_check_add_del",
// [
// }
//
type IPSourceAndPortRangeCheckAddDel struct {
- IsIpv6 uint8
+ IsIPv6 uint8
IsAdd uint8
MaskLength uint8
Address []byte `struc:"[16]byte"`
func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
return "ip_source_and_port_range_check_add_del"
}
-func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string {
return "03d6b03a"
}
+func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPSourceAndPortRangeCheckAddDel() api.Message {
return &IPSourceAndPortRangeCheckAddDel{}
}
// IPSourceAndPortRangeCheckAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1665:
+// Generated from 'ip.api.json', line 1595:
//
// "ip_source_and_port_range_check_add_del_reply",
// [
func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
return "ip_source_and_port_range_check_add_del_reply"
}
-func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPSourceAndPortRangeCheckAddDelReply() api.Message {
return &IPSourceAndPortRangeCheckAddDelReply{}
}
// IPSourceAndPortRangeCheckInterfaceAddDel represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 1683:
+// Generated from 'ip.api.json', line 1613:
//
// "ip_source_and_port_range_check_interface_add_del",
// [
func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
return "ip_source_and_port_range_check_interface_add_del"
}
-func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string {
return "6966bc44"
}
+func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIPSourceAndPortRangeCheckInterfaceAddDel() api.Message {
return &IPSourceAndPortRangeCheckInterfaceAddDel{}
}
// IPSourceAndPortRangeCheckInterfaceAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1725:
+// Generated from 'ip.api.json', line 1655:
//
// "ip_source_and_port_range_check_interface_add_del_reply",
// [
func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
return "ip_source_and_port_range_check_interface_add_del_reply"
}
-func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIPSourceAndPortRangeCheckInterfaceAddDelReply() api.Message {
return &IPSourceAndPortRangeCheckInterfaceAddDelReply{}
}
-// WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'.
-// Generated from '../../bin_api/ip.api.json', line 1743:
+// IPScanNeighborEnableDisable represents the VPP binary API message 'ip_scan_neighbor_enable_disable'.
+// Generated from 'ip.api.json', line 1673:
//
-// "want_ip4_arp_events",
+// "ip_scan_neighbor_enable_disable",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
// "u8",
-// "enable_disable"
+// "mode"
// ],
// [
-// "u32",
-// "pid"
+// "u8",
+// "scan_interval"
// ],
// [
-// "u32",
-// "address"
+// "u8",
+// "max_proc_time"
+// ],
+// [
+// "u8",
+// "max_update"
+// ],
+// [
+// "u8",
+// "scan_int_delay"
+// ],
+// [
+// "u8",
+// "stale_threshold"
// ],
// {
-// "crc": "0x77e06379"
+// "crc": "0x0a6bf57a"
// }
//
-type WantIP4ArpEvents struct {
- EnableDisable uint8
- Pid uint32
- Address uint32
+type IPScanNeighborEnableDisable struct {
+ Mode uint8
+ ScanInterval uint8
+ MaxProcTime uint8
+ MaxUpdate uint8
+ ScanIntDelay uint8
+ StaleThreshold uint8
}
-func (*WantIP4ArpEvents) GetMessageName() string {
- return "want_ip4_arp_events"
+func (*IPScanNeighborEnableDisable) GetMessageName() string {
+ return "ip_scan_neighbor_enable_disable"
}
-func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
- return api.RequestMessage
+func (*IPScanNeighborEnableDisable) GetCrcString() string {
+ return "0a6bf57a"
}
-func (*WantIP4ArpEvents) GetCrcString() string {
- return "77e06379"
+func (*IPScanNeighborEnableDisable) GetMessageType() api.MessageType {
+ return api.RequestMessage
}
-func NewWantIP4ArpEvents() api.Message {
- return &WantIP4ArpEvents{}
+func NewIPScanNeighborEnableDisable() api.Message {
+ return &IPScanNeighborEnableDisable{}
}
-// WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1773:
+// IPScanNeighborEnableDisableReply represents the VPP binary API message 'ip_scan_neighbor_enable_disable_reply'.
+// Generated from 'ip.api.json', line 1715:
//
-// "want_ip4_arp_events_reply",
+// "ip_scan_neighbor_enable_disable_reply",
// [
// "u16",
// "_vl_msg_id"
// "crc": "0xe8d4e804"
// }
//
-type WantIP4ArpEventsReply struct {
+type IPScanNeighborEnableDisableReply struct {
Retval int32
}
-func (*WantIP4ArpEventsReply) GetMessageName() string {
- return "want_ip4_arp_events_reply"
+func (*IPScanNeighborEnableDisableReply) GetMessageName() string {
+ return "ip_scan_neighbor_enable_disable_reply"
}
-func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*WantIP4ArpEventsReply) GetCrcString() string {
+func (*IPScanNeighborEnableDisableReply) GetCrcString() string {
return "e8d4e804"
}
-func NewWantIP4ArpEventsReply() api.Message {
- return &WantIP4ArpEventsReply{}
+func (*IPScanNeighborEnableDisableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewIPScanNeighborEnableDisableReply() api.Message {
+ return &IPScanNeighborEnableDisableReply{}
}
-// IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'.
-// Generated from '../../bin_api/ip.api.json', line 1791:
+// IPProbeNeighbor represents the VPP binary API message 'ip_probe_neighbor'.
+// Generated from 'ip.api.json', line 1733:
//
-// "ip4_arp_event",
+// "ip_probe_neighbor",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
// "u32",
-// "address"
-// ],
-// [
-// "u32",
-// "pid"
+// "context"
// ],
// [
// "u32",
// ],
// [
// "u8",
-// "new_mac",
-// 6
+// "dst_address",
+// 16
// ],
// [
// "u8",
-// "mac_ip"
+// "is_ipv6"
// ],
// {
-// "crc": "0xef7235f7"
+// "crc": "0x1e44bfd7"
// }
//
-type IP4ArpEvent struct {
- Address uint32
- Pid uint32
- SwIfIndex uint32
- NewMac []byte `struc:"[6]byte"`
- MacIP uint8
+type IPProbeNeighbor struct {
+ SwIfIndex uint32
+ DstAddress []byte `struc:"[16]byte"`
+ IsIPv6 uint8
}
-func (*IP4ArpEvent) GetMessageName() string {
- return "ip4_arp_event"
+func (*IPProbeNeighbor) GetMessageName() string {
+ return "ip_probe_neighbor"
}
-func (*IP4ArpEvent) GetMessageType() api.MessageType {
- return api.EventMessage
+func (*IPProbeNeighbor) GetCrcString() string {
+ return "1e44bfd7"
}
-func (*IP4ArpEvent) GetCrcString() string {
- return "ef7235f7"
+func (*IPProbeNeighbor) GetMessageType() api.MessageType {
+ return api.RequestMessage
}
-func NewIP4ArpEvent() api.Message {
- return &IP4ArpEvent{}
+func NewIPProbeNeighbor() api.Message {
+ return &IPProbeNeighbor{}
}
-// WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'.
-// Generated from '../../bin_api/ip.api.json', line 1826:
+// IPProbeNeighborReply represents the VPP binary API message 'ip_probe_neighbor_reply'.
+// Generated from 'ip.api.json', line 1764:
//
-// "want_ip6_nd_events",
+// "ip_probe_neighbor_reply",
// [
// "u16",
// "_vl_msg_id"
// ],
// [
// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
// "context"
// ],
// [
-// "u8",
-// "enable_disable"
-// ],
-// [
-// "u32",
-// "pid"
-// ],
-// [
-// "u8",
-// "address",
-// 16
+// "i32",
+// "retval"
// ],
// {
-// "crc": "0x1cf65fbb"
+// "crc": "0xe8d4e804"
// }
//
-type WantIP6NdEvents struct {
- EnableDisable uint8
- Pid uint32
- Address []byte `struc:"[16]byte"`
+type IPProbeNeighborReply struct {
+ Retval int32
}
-func (*WantIP6NdEvents) GetMessageName() string {
- return "want_ip6_nd_events"
+func (*IPProbeNeighborReply) GetMessageName() string {
+ return "ip_probe_neighbor_reply"
}
-func (*WantIP6NdEvents) GetMessageType() api.MessageType {
- return api.RequestMessage
+func (*IPProbeNeighborReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*IPProbeNeighborReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewIPProbeNeighborReply() api.Message {
+ return &IPProbeNeighborReply{}
+}
+
+// WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'.
+// Generated from 'ip.api.json', line 1782:
+//
+// "want_ip4_arp_events",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "enable_disable"
+// ],
+// [
+// "u32",
+// "pid"
+// ],
+// [
+// "u32",
+// "address"
+// ],
+// {
+// "crc": "0x77e06379"
+// }
+//
+type WantIP4ArpEvents struct {
+ EnableDisable uint8
+ PID uint32
+ Address uint32
+}
+
+func (*WantIP4ArpEvents) GetMessageName() string {
+ return "want_ip4_arp_events"
+}
+func (*WantIP4ArpEvents) GetCrcString() string {
+ return "77e06379"
+}
+func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewWantIP4ArpEvents() api.Message {
+ return &WantIP4ArpEvents{}
+}
+
+// WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'.
+// Generated from 'ip.api.json', line 1812:
+//
+// "want_ip4_arp_events_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type WantIP4ArpEventsReply struct {
+ Retval int32
+}
+
+func (*WantIP4ArpEventsReply) GetMessageName() string {
+ return "want_ip4_arp_events_reply"
+}
+func (*WantIP4ArpEventsReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewWantIP4ArpEventsReply() api.Message {
+ return &WantIP4ArpEventsReply{}
+}
+
+// IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'.
+// Generated from 'ip.api.json', line 1830:
+//
+// "ip4_arp_event",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "address"
+// ],
+// [
+// "u32",
+// "pid"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "new_mac",
+// 6
+// ],
+// [
+// "u8",
+// "mac_ip"
+// ],
+// {
+// "crc": "0xef7235f7"
+// }
+//
+type IP4ArpEvent struct {
+ Address uint32
+ PID uint32
+ SwIfIndex uint32
+ NewMac []byte `struc:"[6]byte"`
+ MacIP uint8
+}
+
+func (*IP4ArpEvent) GetMessageName() string {
+ return "ip4_arp_event"
+}
+func (*IP4ArpEvent) GetCrcString() string {
+ return "ef7235f7"
+}
+func (*IP4ArpEvent) GetMessageType() api.MessageType {
+ return api.EventMessage
+}
+func NewIP4ArpEvent() api.Message {
+ return &IP4ArpEvent{}
+}
+
+// WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'.
+// Generated from 'ip.api.json', line 1865:
+//
+// "want_ip6_nd_events",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "enable_disable"
+// ],
+// [
+// "u32",
+// "pid"
+// ],
+// [
+// "u8",
+// "address",
+// 16
+// ],
+// {
+// "crc": "0x1cf65fbb"
+// }
+//
+type WantIP6NdEvents struct {
+ EnableDisable uint8
+ PID uint32
+ Address []byte `struc:"[16]byte"`
+}
+
+func (*WantIP6NdEvents) GetMessageName() string {
+ return "want_ip6_nd_events"
}
func (*WantIP6NdEvents) GetCrcString() string {
return "1cf65fbb"
}
+func (*WantIP6NdEvents) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP6NdEvents() api.Message {
return &WantIP6NdEvents{}
}
// WantIP6NdEventsReply represents the VPP binary API message 'want_ip6_nd_events_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1857:
+// Generated from 'ip.api.json', line 1896:
//
// "want_ip6_nd_events_reply",
// [
func (*WantIP6NdEventsReply) GetMessageName() string {
return "want_ip6_nd_events_reply"
}
-func (*WantIP6NdEventsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP6NdEventsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP6NdEventsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP6NdEventsReply() api.Message {
return &WantIP6NdEventsReply{}
}
// IP6NdEvent represents the VPP binary API message 'ip6_nd_event'.
-// Generated from '../../bin_api/ip.api.json', line 1875:
+// Generated from 'ip.api.json', line 1914:
//
// "ip6_nd_event",
// [
// }
//
type IP6NdEvent struct {
- Pid uint32
+ PID uint32
SwIfIndex uint32
Address []byte `struc:"[16]byte"`
NewMac []byte `struc:"[6]byte"`
func (*IP6NdEvent) GetMessageName() string {
return "ip6_nd_event"
}
-func (*IP6NdEvent) GetMessageType() api.MessageType {
- return api.EventMessage
-}
func (*IP6NdEvent) GetCrcString() string {
return "96ab2fdd"
}
+func (*IP6NdEvent) GetMessageType() api.MessageType {
+ return api.EventMessage
+}
func NewIP6NdEvent() api.Message {
return &IP6NdEvent{}
}
-// ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'.
-// Generated from '../../bin_api/ip.api.json', line 1911:
+// WantIP6RaEvents represents the VPP binary API message 'want_ip6_ra_events'.
+// Generated from 'ip.api.json', line 1950:
//
-// "proxy_arp_add_del",
+// "want_ip6_ra_events",
// [
// "u16",
// "_vl_msg_id"
// "context"
// ],
// [
+// "u8",
+// "enable_disable"
+// ],
+// [
// "u32",
-// "vrf_id"
+// "pid"
+// ],
+// {
+// "crc": "0x05b454b5"
+// }
+//
+type WantIP6RaEvents struct {
+ EnableDisable uint8
+ PID uint32
+}
+
+func (*WantIP6RaEvents) GetMessageName() string {
+ return "want_ip6_ra_events"
+}
+func (*WantIP6RaEvents) GetCrcString() string {
+ return "05b454b5"
+}
+func (*WantIP6RaEvents) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewWantIP6RaEvents() api.Message {
+ return &WantIP6RaEvents{}
+}
+
+// WantIP6RaEventsReply represents the VPP binary API message 'want_ip6_ra_events_reply'.
+// Generated from 'ip.api.json', line 1976:
+//
+// "want_ip6_ra_events_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type WantIP6RaEventsReply struct {
+ Retval int32
+}
+
+func (*WantIP6RaEventsReply) GetMessageName() string {
+ return "want_ip6_ra_events_reply"
+}
+func (*WantIP6RaEventsReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*WantIP6RaEventsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewWantIP6RaEventsReply() api.Message {
+ return &WantIP6RaEventsReply{}
+}
+
+// IP6RaEvent represents the VPP binary API message 'ip6_ra_event'.
+// Generated from 'ip.api.json', line 1994:
+//
+// "ip6_ra_event",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "pid"
+// ],
+// [
+// "u32",
+// "sw_if_index"
// ],
// [
// "u8",
-// "is_add"
+// "router_address",
+// 16
// ],
// [
// "u8",
-// "low_address",
-// 4
+// "current_hop_limit"
// ],
// [
// "u8",
-// "hi_address",
-// 4
+// "flags"
+// ],
+// [
+// "u16",
+// "router_lifetime_in_sec"
+// ],
+// [
+// "u32",
+// "neighbor_reachable_time_in_msec"
+// ],
+// [
+// "u32",
+// "time_in_msec_between_retransmitted_neighbor_solicitations"
+// ],
+// [
+// "u32",
+// "n_prefixes"
+// ],
+// [
+// "vl_api_ip6_ra_prefix_info_t",
+// "prefixes",
+// 0,
+// "n_prefixes"
// ],
// {
-// "crc": "0xc2442918"
+// "crc": "0xc5e54257"
+// }
+//
+type IP6RaEvent struct {
+ PID uint32
+ SwIfIndex uint32
+ RouterAddress []byte `struc:"[16]byte"`
+ CurrentHopLimit uint8
+ Flags uint8
+ RouterLifetimeInSec uint16
+ NeighborReachableTimeInMsec uint32
+ TimeInMsecBetweenRetransmittedNeighborSolicitations uint32
+ NPrefixes uint32 `struc:"sizeof=Prefixes"`
+ Prefixes []IP6RaPrefixInfo
+}
+
+func (*IP6RaEvent) GetMessageName() string {
+ return "ip6_ra_event"
+}
+func (*IP6RaEvent) GetCrcString() string {
+ return "c5e54257"
+}
+func (*IP6RaEvent) GetMessageType() api.MessageType {
+ return api.EventMessage
+}
+func NewIP6RaEvent() api.Message {
+ return &IP6RaEvent{}
+}
+
+// ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'.
+// Generated from 'ip.api.json', line 2051:
+//
+// "proxy_arp_add_del",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "is_add"
+// ],
+// [
+// "vl_api_proxy_arp_t",
+// "proxy"
+// ],
+// {
+// "crc": "0x227988d9"
// }
//
type ProxyArpAddDel struct {
- VrfID uint32
- IsAdd uint8
- LowAddress []byte `struc:"[4]byte"`
- HiAddress []byte `struc:"[4]byte"`
+ IsAdd uint8
+ Proxy ProxyArp
}
func (*ProxyArpAddDel) GetMessageName() string {
return "proxy_arp_add_del"
}
+func (*ProxyArpAddDel) GetCrcString() string {
+ return "227988d9"
+}
func (*ProxyArpAddDel) GetMessageType() api.MessageType {
return api.RequestMessage
}
-func (*ProxyArpAddDel) GetCrcString() string {
- return "c2442918"
-}
func NewProxyArpAddDel() api.Message {
return &ProxyArpAddDel{}
}
// ProxyArpAddDelReply represents the VPP binary API message 'proxy_arp_add_del_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1947:
+// Generated from 'ip.api.json', line 2077:
//
// "proxy_arp_add_del_reply",
// [
func (*ProxyArpAddDelReply) GetMessageName() string {
return "proxy_arp_add_del_reply"
}
-func (*ProxyArpAddDelReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ProxyArpAddDelReply) GetCrcString() string {
return "e8d4e804"
}
+func (*ProxyArpAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewProxyArpAddDelReply() api.Message {
return &ProxyArpAddDelReply{}
}
+// ProxyArpDump represents the VPP binary API message 'proxy_arp_dump'.
+// Generated from 'ip.api.json', line 2095:
+//
+// "proxy_arp_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type ProxyArpDump struct{}
+
+func (*ProxyArpDump) GetMessageName() string {
+ return "proxy_arp_dump"
+}
+func (*ProxyArpDump) GetCrcString() string {
+ return "51077d14"
+}
+func (*ProxyArpDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewProxyArpDump() api.Message {
+ return &ProxyArpDump{}
+}
+
+// ProxyArpDetails represents the VPP binary API message 'proxy_arp_details'.
+// Generated from 'ip.api.json', line 2113:
+//
+// "proxy_arp_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "vl_api_proxy_arp_t",
+// "proxy"
+// ],
+// {
+// "crc": "0x9b707c77"
+// }
+//
+type ProxyArpDetails struct {
+ Proxy ProxyArp
+}
+
+func (*ProxyArpDetails) GetMessageName() string {
+ return "proxy_arp_details"
+}
+func (*ProxyArpDetails) GetCrcString() string {
+ return "9b707c77"
+}
+func (*ProxyArpDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewProxyArpDetails() api.Message {
+ return &ProxyArpDetails{}
+}
+
// ProxyArpIntfcEnableDisable represents the VPP binary API message 'proxy_arp_intfc_enable_disable'.
-// Generated from '../../bin_api/ip.api.json', line 1965:
+// Generated from 'ip.api.json', line 2131:
//
// "proxy_arp_intfc_enable_disable",
// [
func (*ProxyArpIntfcEnableDisable) GetMessageName() string {
return "proxy_arp_intfc_enable_disable"
}
-func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ProxyArpIntfcEnableDisable) GetCrcString() string {
return "69d24598"
}
+func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewProxyArpIntfcEnableDisable() api.Message {
return &ProxyArpIntfcEnableDisable{}
}
// ProxyArpIntfcEnableDisableReply represents the VPP binary API message 'proxy_arp_intfc_enable_disable_reply'.
-// Generated from '../../bin_api/ip.api.json', line 1991:
+// Generated from 'ip.api.json', line 2157:
//
// "proxy_arp_intfc_enable_disable_reply",
// [
// "retval"
// ],
// {
-// "crc": "0xe8d4e804"
+// "crc": "0xe8d4e804"
+// }
+//
+type ProxyArpIntfcEnableDisableReply struct {
+ Retval int32
+}
+
+func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string {
+ return "proxy_arp_intfc_enable_disable_reply"
+}
+func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewProxyArpIntfcEnableDisableReply() api.Message {
+ return &ProxyArpIntfcEnableDisableReply{}
+}
+
+// ProxyArpIntfcDump represents the VPP binary API message 'proxy_arp_intfc_dump'.
+// Generated from 'ip.api.json', line 2175:
+//
+// "proxy_arp_intfc_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type ProxyArpIntfcDump struct{}
+
+func (*ProxyArpIntfcDump) GetMessageName() string {
+ return "proxy_arp_intfc_dump"
+}
+func (*ProxyArpIntfcDump) GetCrcString() string {
+ return "51077d14"
+}
+func (*ProxyArpIntfcDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewProxyArpIntfcDump() api.Message {
+ return &ProxyArpIntfcDump{}
+}
+
+// ProxyArpIntfcDetails represents the VPP binary API message 'proxy_arp_intfc_details'.
+// Generated from 'ip.api.json', line 2193:
+//
+// "proxy_arp_intfc_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0xf6458e5f"
// }
//
-type ProxyArpIntfcEnableDisableReply struct {
- Retval int32
+type ProxyArpIntfcDetails struct {
+ SwIfIndex uint32
}
-func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string {
- return "proxy_arp_intfc_enable_disable_reply"
+func (*ProxyArpIntfcDetails) GetMessageName() string {
+ return "proxy_arp_intfc_details"
}
-func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
+func (*ProxyArpIntfcDetails) GetCrcString() string {
+ return "f6458e5f"
}
-func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string {
- return "e8d4e804"
+func (*ProxyArpIntfcDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
}
-func NewProxyArpIntfcEnableDisableReply() api.Message {
- return &ProxyArpIntfcEnableDisableReply{}
+func NewProxyArpIntfcDetails() api.Message {
+ return &ProxyArpIntfcDetails{}
}
// ResetFib represents the VPP binary API message 'reset_fib'.
-// Generated from '../../bin_api/ip.api.json', line 2009:
+// Generated from 'ip.api.json', line 2211:
//
// "reset_fib",
// [
//
type ResetFib struct {
VrfID uint32
- IsIpv6 uint8
+ IsIPv6 uint8
}
func (*ResetFib) GetMessageName() string {
return "reset_fib"
}
-func (*ResetFib) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*ResetFib) GetCrcString() string {
return "8553ebd9"
}
+func (*ResetFib) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewResetFib() api.Message {
return &ResetFib{}
}
// ResetFibReply represents the VPP binary API message 'reset_fib_reply'.
-// Generated from '../../bin_api/ip.api.json', line 2035:
+// Generated from 'ip.api.json', line 2237:
//
// "reset_fib_reply",
// [
func (*ResetFibReply) GetMessageName() string {
return "reset_fib_reply"
}
-func (*ResetFibReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*ResetFibReply) GetCrcString() string {
return "e8d4e804"
}
+func (*ResetFibReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewResetFibReply() api.Message {
return &ResetFibReply{}
}
// SetArpNeighborLimit represents the VPP binary API message 'set_arp_neighbor_limit'.
-// Generated from '../../bin_api/ip.api.json', line 2053:
+// Generated from 'ip.api.json', line 2255:
//
// "set_arp_neighbor_limit",
// [
// }
//
type SetArpNeighborLimit struct {
- IsIpv6 uint8
+ IsIPv6 uint8
ArpNeighborLimit uint32
}
func (*SetArpNeighborLimit) GetMessageName() string {
return "set_arp_neighbor_limit"
}
-func (*SetArpNeighborLimit) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SetArpNeighborLimit) GetCrcString() string {
return "97d01fd6"
}
+func (*SetArpNeighborLimit) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSetArpNeighborLimit() api.Message {
return &SetArpNeighborLimit{}
}
// SetArpNeighborLimitReply represents the VPP binary API message 'set_arp_neighbor_limit_reply'.
-// Generated from '../../bin_api/ip.api.json', line 2079:
+// Generated from 'ip.api.json', line 2281:
//
// "set_arp_neighbor_limit_reply",
// [
func (*SetArpNeighborLimitReply) GetMessageName() string {
return "set_arp_neighbor_limit_reply"
}
-func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SetArpNeighborLimitReply) GetCrcString() string {
return "e8d4e804"
}
+func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSetArpNeighborLimitReply() api.Message {
return &SetArpNeighborLimitReply{}
}
// IoamEnable represents the VPP binary API message 'ioam_enable'.
-// Generated from '../../bin_api/ip.api.json', line 2097:
+// Generated from 'ip.api.json', line 2299:
//
// "ioam_enable",
// [
func (*IoamEnable) GetMessageName() string {
return "ioam_enable"
}
-func (*IoamEnable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IoamEnable) GetCrcString() string {
return "9392e032"
}
+func (*IoamEnable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIoamEnable() api.Message {
return &IoamEnable{}
}
// IoamEnableReply represents the VPP binary API message 'ioam_enable_reply'.
-// Generated from '../../bin_api/ip.api.json', line 2139:
+// Generated from 'ip.api.json', line 2341:
//
// "ioam_enable_reply",
// [
func (*IoamEnableReply) GetMessageName() string {
return "ioam_enable_reply"
}
-func (*IoamEnableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IoamEnableReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IoamEnableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIoamEnableReply() api.Message {
return &IoamEnableReply{}
}
// IoamDisable represents the VPP binary API message 'ioam_disable'.
-// Generated from '../../bin_api/ip.api.json', line 2157:
+// Generated from 'ip.api.json', line 2359:
//
// "ioam_disable",
// [
func (*IoamDisable) GetMessageName() string {
return "ioam_disable"
}
-func (*IoamDisable) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*IoamDisable) GetCrcString() string {
return "6b16a45e"
}
+func (*IoamDisable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewIoamDisable() api.Message {
return &IoamDisable{}
}
// IoamDisableReply represents the VPP binary API message 'ioam_disable_reply'.
-// Generated from '../../bin_api/ip.api.json', line 2179:
+// Generated from 'ip.api.json', line 2381:
//
// "ioam_disable_reply",
// [
func (*IoamDisableReply) GetMessageName() string {
return "ioam_disable_reply"
}
-func (*IoamDisableReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*IoamDisableReply) GetCrcString() string {
return "e8d4e804"
}
+func (*IoamDisableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewIoamDisableReply() api.Message {
return &IoamDisableReply{}
}
+
+// IPReassemblySet represents the VPP binary API message 'ip_reassembly_set'.
+// Generated from 'ip.api.json', line 2399:
+//
+// "ip_reassembly_set",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "timeout_ms"
+// ],
+// [
+// "u32",
+// "max_reassemblies"
+// ],
+// [
+// "u32",
+// "expire_walk_interval_ms"
+// ],
+// [
+// "u8",
+// "is_ip6"
+// ],
+// {
+// "crc": "0x1db184de"
+// }
+//
+type IPReassemblySet struct {
+ TimeoutMs uint32
+ MaxReassemblies uint32
+ ExpireWalkIntervalMs uint32
+ IsIP6 uint8
+}
+
+func (*IPReassemblySet) GetMessageName() string {
+ return "ip_reassembly_set"
+}
+func (*IPReassemblySet) GetCrcString() string {
+ return "1db184de"
+}
+func (*IPReassemblySet) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIPReassemblySet() api.Message {
+ return &IPReassemblySet{}
+}
+
+// IPReassemblySetReply represents the VPP binary API message 'ip_reassembly_set_reply'.
+// Generated from 'ip.api.json', line 2433:
+//
+// "ip_reassembly_set_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type IPReassemblySetReply struct {
+ Retval int32
+}
+
+func (*IPReassemblySetReply) GetMessageName() string {
+ return "ip_reassembly_set_reply"
+}
+func (*IPReassemblySetReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*IPReassemblySetReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewIPReassemblySetReply() api.Message {
+ return &IPReassemblySetReply{}
+}
+
+// IPReassemblyGet represents the VPP binary API message 'ip_reassembly_get'.
+// Generated from 'ip.api.json', line 2451:
+//
+// "ip_reassembly_get",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "is_ip6"
+// ],
+// {
+// "crc": "0x6fe91190"
+// }
+//
+type IPReassemblyGet struct {
+ IsIP6 uint8
+}
+
+func (*IPReassemblyGet) GetMessageName() string {
+ return "ip_reassembly_get"
+}
+func (*IPReassemblyGet) GetCrcString() string {
+ return "6fe91190"
+}
+func (*IPReassemblyGet) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIPReassemblyGet() api.Message {
+ return &IPReassemblyGet{}
+}
+
+// IPReassemblyGetReply represents the VPP binary API message 'ip_reassembly_get_reply'.
+// Generated from 'ip.api.json', line 2473:
+//
+// "ip_reassembly_get_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// [
+// "u32",
+// "timeout_ms"
+// ],
+// [
+// "u32",
+// "max_reassemblies"
+// ],
+// [
+// "u32",
+// "expire_walk_interval_ms"
+// ],
+// [
+// "u8",
+// "is_ip6"
+// ],
+// {
+// "crc": "0xd746fc57"
+// }
+//
+type IPReassemblyGetReply struct {
+ Retval int32
+ TimeoutMs uint32
+ MaxReassemblies uint32
+ ExpireWalkIntervalMs uint32
+ IsIP6 uint8
+}
+
+func (*IPReassemblyGetReply) GetMessageName() string {
+ return "ip_reassembly_get_reply"
+}
+func (*IPReassemblyGetReply) GetCrcString() string {
+ return "d746fc57"
+}
+func (*IPReassemblyGetReply) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIPReassemblyGetReply() api.Message {
+ return &IPReassemblyGetReply{}
+}
+
+// IPReassemblyEnableDisable represents the VPP binary API message 'ip_reassembly_enable_disable'.
+// Generated from 'ip.api.json', line 2511:
+//
+// "ip_reassembly_enable_disable",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "enable_ip4"
+// ],
+// [
+// "u8",
+// "enable_ip6"
+// ],
+// {
+// "crc": "0xbb8dc5d0"
+// }
+//
+type IPReassemblyEnableDisable struct {
+ SwIfIndex uint32
+ EnableIP4 uint8
+ EnableIP6 uint8
+}
+
+func (*IPReassemblyEnableDisable) GetMessageName() string {
+ return "ip_reassembly_enable_disable"
+}
+func (*IPReassemblyEnableDisable) GetCrcString() string {
+ return "bb8dc5d0"
+}
+func (*IPReassemblyEnableDisable) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewIPReassemblyEnableDisable() api.Message {
+ return &IPReassemblyEnableDisable{}
+}
+
+// IPReassemblyEnableDisableReply represents the VPP binary API message 'ip_reassembly_enable_disable_reply'.
+// Generated from 'ip.api.json', line 2541:
+//
+// "ip_reassembly_enable_disable_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type IPReassemblyEnableDisableReply struct {
+ Retval int32
+}
+
+func (*IPReassemblyEnableDisableReply) GetMessageName() string {
+ return "ip_reassembly_enable_disable_reply"
+}
+func (*IPReassemblyEnableDisableReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*IPReassemblyEnableDisableReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewIPReassemblyEnableDisableReply() api.Message {
+ return &IPReassemblyEnableDisableReply{}
+}
+
+/* Services */
+
+type Services interface {
+ DumpIP6Fib(*IP6FibDump) (*IP6FibDetails, error)
+ DumpIP6Mfib(*IP6MfibDump) (*IP6MfibDetails, error)
+ DumpIP6ndProxy(*IP6ndProxyDump) (*IP6ndProxyDetails, error)
+ DumpIPAddress(*IPAddressDump) (*IPAddressDetails, error)
+ DumpIP(*IPDump) (*IPDetails, error)
+ DumpIPFib(*IPFibDump) (*IPFibDetails, error)
+ DumpIPMfib(*IPMfibDump) (*IPMfibDetails, error)
+ DumpIPNeighbor(*IPNeighborDump) (*IPNeighborDetails, error)
+ DumpIPUnnumbered(*IPUnnumberedDump) (*IPUnnumberedDetails, error)
+ DumpMfibSignal(*MfibSignalDump) (*MfibSignalDetails, error)
+ DumpProxyArp(*ProxyArpDump) (*ProxyArpDetails, error)
+ DumpProxyArpIntfc(*ProxyArpIntfcDump) (*ProxyArpIntfcDetails, error)
+ IoamDisable(*IoamDisable) (*IoamDisableReply, error)
+ IoamEnable(*IoamEnable) (*IoamEnableReply, error)
+ IP6ndProxyAddDel(*IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error)
+ IP6ndSendRouterSolicitation(*IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error)
+ IPAddDelRoute(*IPAddDelRoute) (*IPAddDelRouteReply, error)
+ IPContainerProxyAddDel(*IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
+ IPMrouteAddDel(*IPMrouteAddDel) (*IPMrouteAddDelReply, error)
+ IPNeighborAddDel(*IPNeighborAddDel) (*IPNeighborAddDelReply, error)
+ IPProbeNeighbor(*IPProbeNeighbor) (*IPProbeNeighborReply, error)
+ IPPuntPolice(*IPPuntPolice) (*IPPuntPoliceReply, error)
+ IPPuntRedirect(*IPPuntRedirect) (*IPPuntRedirectReply, error)
+ IPReassemblyEnableDisable(*IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
+ IPReassemblyGet(*IPReassemblyGet) (*IPReassemblyGetReply, error)
+ IPReassemblySet(*IPReassemblySet) (*IPReassemblySetReply, error)
+ IPScanNeighborEnableDisable(*IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error)
+ IPSourceAndPortRangeCheckAddDel(*IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
+ IPSourceAndPortRangeCheckInterfaceAddDel(*IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
+ IPTableAddDel(*IPTableAddDel) (*IPTableAddDelReply, error)
+ ProxyArpAddDel(*ProxyArpAddDel) (*ProxyArpAddDelReply, error)
+ ProxyArpIntfcEnableDisable(*ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error)
+ ResetFib(*ResetFib) (*ResetFibReply, error)
+ SetArpNeighborLimit(*SetArpNeighborLimit) (*SetArpNeighborLimitReply, error)
+ SetIPFlowHash(*SetIPFlowHash) (*SetIPFlowHashReply, error)
+ SwInterfaceIP6EnableDisable(*SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
+ SwInterfaceIP6SetLinkLocalAddress(*SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error)
+ SwInterfaceIP6ndRaConfig(*SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error)
+ SwInterfaceIP6ndRaPrefix(*SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error)
+ WantIP4ArpEvents(*WantIP4ArpEvents) (*WantIP4ArpEventsReply, error)
+ WantIP6NdEvents(*WantIP6NdEvents) (*WantIP6NdEventsReply, error)
+ WantIP6RaEvents(*WantIP6RaEvents) (*WantIP6RaEventsReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*IPTableAddDel)(nil), "ip.IPTableAddDel")
+ api.RegisterMessage((*IPTableAddDelReply)(nil), "ip.IPTableAddDelReply")
+ api.RegisterMessage((*IPFibDump)(nil), "ip.IPFibDump")
+ api.RegisterMessage((*IPFibDetails)(nil), "ip.IPFibDetails")
+ api.RegisterMessage((*IP6FibDump)(nil), "ip.IP6FibDump")
+ api.RegisterMessage((*IP6FibDetails)(nil), "ip.IP6FibDetails")
+ api.RegisterMessage((*IPNeighborDump)(nil), "ip.IPNeighborDump")
+ api.RegisterMessage((*IPNeighborDetails)(nil), "ip.IPNeighborDetails")
+ api.RegisterMessage((*IPNeighborAddDel)(nil), "ip.IPNeighborAddDel")
+ api.RegisterMessage((*IPNeighborAddDelReply)(nil), "ip.IPNeighborAddDelReply")
+ api.RegisterMessage((*SetIPFlowHash)(nil), "ip.SetIPFlowHash")
+ api.RegisterMessage((*SetIPFlowHashReply)(nil), "ip.SetIPFlowHashReply")
+ api.RegisterMessage((*SwInterfaceIP6ndRaConfig)(nil), "ip.SwInterfaceIP6ndRaConfig")
+ api.RegisterMessage((*SwInterfaceIP6ndRaConfigReply)(nil), "ip.SwInterfaceIP6ndRaConfigReply")
+ api.RegisterMessage((*SwInterfaceIP6ndRaPrefix)(nil), "ip.SwInterfaceIP6ndRaPrefix")
+ api.RegisterMessage((*SwInterfaceIP6ndRaPrefixReply)(nil), "ip.SwInterfaceIP6ndRaPrefixReply")
+ api.RegisterMessage((*IP6ndProxyAddDel)(nil), "ip.IP6ndProxyAddDel")
+ api.RegisterMessage((*IP6ndProxyAddDelReply)(nil), "ip.IP6ndProxyAddDelReply")
+ api.RegisterMessage((*IP6ndProxyDetails)(nil), "ip.IP6ndProxyDetails")
+ api.RegisterMessage((*IP6ndProxyDump)(nil), "ip.IP6ndProxyDump")
+ api.RegisterMessage((*IP6ndSendRouterSolicitation)(nil), "ip.IP6ndSendRouterSolicitation")
+ api.RegisterMessage((*IP6ndSendRouterSolicitationReply)(nil), "ip.IP6ndSendRouterSolicitationReply")
+ api.RegisterMessage((*SwInterfaceIP6EnableDisable)(nil), "ip.SwInterfaceIP6EnableDisable")
+ api.RegisterMessage((*SwInterfaceIP6EnableDisableReply)(nil), "ip.SwInterfaceIP6EnableDisableReply")
+ api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddress)(nil), "ip.SwInterfaceIP6SetLinkLocalAddress")
+ api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddressReply)(nil), "ip.SwInterfaceIP6SetLinkLocalAddressReply")
+ api.RegisterMessage((*IPAddDelRoute)(nil), "ip.IPAddDelRoute")
+ api.RegisterMessage((*IPAddDelRouteReply)(nil), "ip.IPAddDelRouteReply")
+ api.RegisterMessage((*IPMrouteAddDel)(nil), "ip.IPMrouteAddDel")
+ api.RegisterMessage((*IPMrouteAddDelReply)(nil), "ip.IPMrouteAddDelReply")
+ api.RegisterMessage((*IPMfibDump)(nil), "ip.IPMfibDump")
+ api.RegisterMessage((*IPMfibDetails)(nil), "ip.IPMfibDetails")
+ api.RegisterMessage((*IP6MfibDump)(nil), "ip.IP6MfibDump")
+ api.RegisterMessage((*IP6MfibDetails)(nil), "ip.IP6MfibDetails")
+ api.RegisterMessage((*IPAddressDetails)(nil), "ip.IPAddressDetails")
+ api.RegisterMessage((*IPAddressDump)(nil), "ip.IPAddressDump")
+ api.RegisterMessage((*IPUnnumberedDetails)(nil), "ip.IPUnnumberedDetails")
+ api.RegisterMessage((*IPUnnumberedDump)(nil), "ip.IPUnnumberedDump")
+ api.RegisterMessage((*IPDetails)(nil), "ip.IPDetails")
+ api.RegisterMessage((*IPDump)(nil), "ip.IPDump")
+ api.RegisterMessage((*MfibSignalDump)(nil), "ip.MfibSignalDump")
+ api.RegisterMessage((*MfibSignalDetails)(nil), "ip.MfibSignalDetails")
+ api.RegisterMessage((*IPPuntPolice)(nil), "ip.IPPuntPolice")
+ api.RegisterMessage((*IPPuntPoliceReply)(nil), "ip.IPPuntPoliceReply")
+ api.RegisterMessage((*IPPuntRedirect)(nil), "ip.IPPuntRedirect")
+ api.RegisterMessage((*IPPuntRedirectReply)(nil), "ip.IPPuntRedirectReply")
+ api.RegisterMessage((*IPContainerProxyAddDel)(nil), "ip.IPContainerProxyAddDel")
+ api.RegisterMessage((*IPContainerProxyAddDelReply)(nil), "ip.IPContainerProxyAddDelReply")
+ api.RegisterMessage((*IPSourceAndPortRangeCheckAddDel)(nil), "ip.IPSourceAndPortRangeCheckAddDel")
+ api.RegisterMessage((*IPSourceAndPortRangeCheckAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckAddDelReply")
+ api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDel)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDel")
+ api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDelReply")
+ api.RegisterMessage((*IPScanNeighborEnableDisable)(nil), "ip.IPScanNeighborEnableDisable")
+ api.RegisterMessage((*IPScanNeighborEnableDisableReply)(nil), "ip.IPScanNeighborEnableDisableReply")
+ api.RegisterMessage((*IPProbeNeighbor)(nil), "ip.IPProbeNeighbor")
+ api.RegisterMessage((*IPProbeNeighborReply)(nil), "ip.IPProbeNeighborReply")
+ api.RegisterMessage((*WantIP4ArpEvents)(nil), "ip.WantIP4ArpEvents")
+ api.RegisterMessage((*WantIP4ArpEventsReply)(nil), "ip.WantIP4ArpEventsReply")
+ api.RegisterMessage((*IP4ArpEvent)(nil), "ip.IP4ArpEvent")
+ api.RegisterMessage((*WantIP6NdEvents)(nil), "ip.WantIP6NdEvents")
+ api.RegisterMessage((*WantIP6NdEventsReply)(nil), "ip.WantIP6NdEventsReply")
+ api.RegisterMessage((*IP6NdEvent)(nil), "ip.IP6NdEvent")
+ api.RegisterMessage((*WantIP6RaEvents)(nil), "ip.WantIP6RaEvents")
+ api.RegisterMessage((*WantIP6RaEventsReply)(nil), "ip.WantIP6RaEventsReply")
+ api.RegisterMessage((*IP6RaEvent)(nil), "ip.IP6RaEvent")
+ api.RegisterMessage((*ProxyArpAddDel)(nil), "ip.ProxyArpAddDel")
+ api.RegisterMessage((*ProxyArpAddDelReply)(nil), "ip.ProxyArpAddDelReply")
+ api.RegisterMessage((*ProxyArpDump)(nil), "ip.ProxyArpDump")
+ api.RegisterMessage((*ProxyArpDetails)(nil), "ip.ProxyArpDetails")
+ api.RegisterMessage((*ProxyArpIntfcEnableDisable)(nil), "ip.ProxyArpIntfcEnableDisable")
+ api.RegisterMessage((*ProxyArpIntfcEnableDisableReply)(nil), "ip.ProxyArpIntfcEnableDisableReply")
+ api.RegisterMessage((*ProxyArpIntfcDump)(nil), "ip.ProxyArpIntfcDump")
+ api.RegisterMessage((*ProxyArpIntfcDetails)(nil), "ip.ProxyArpIntfcDetails")
+ api.RegisterMessage((*ResetFib)(nil), "ip.ResetFib")
+ api.RegisterMessage((*ResetFibReply)(nil), "ip.ResetFibReply")
+ api.RegisterMessage((*SetArpNeighborLimit)(nil), "ip.SetArpNeighborLimit")
+ api.RegisterMessage((*SetArpNeighborLimitReply)(nil), "ip.SetArpNeighborLimitReply")
+ api.RegisterMessage((*IoamEnable)(nil), "ip.IoamEnable")
+ api.RegisterMessage((*IoamEnableReply)(nil), "ip.IoamEnableReply")
+ api.RegisterMessage((*IoamDisable)(nil), "ip.IoamDisable")
+ api.RegisterMessage((*IoamDisableReply)(nil), "ip.IoamDisableReply")
+ api.RegisterMessage((*IPReassemblySet)(nil), "ip.IPReassemblySet")
+ api.RegisterMessage((*IPReassemblySetReply)(nil), "ip.IPReassemblySetReply")
+ api.RegisterMessage((*IPReassemblyGet)(nil), "ip.IPReassemblyGet")
+ api.RegisterMessage((*IPReassemblyGetReply)(nil), "ip.IPReassemblyGetReply")
+ api.RegisterMessage((*IPReassemblyEnableDisable)(nil), "ip.IPReassemblyEnableDisable")
+ api.RegisterMessage((*IPReassemblyEnableDisableReply)(nil), "ip.IPReassemblyEnableDisableReply")
+}
{
- "services": [
- {
- "memif_dump": {
- "reply": "memif_details",
- "stream": true
- }
- },
- {
- "memif_create": {
- "reply": "memif_create_reply"
+ "messages": [
+ [
+ "memif_socket_filename_add_del",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u8",
+ "is_add"
+ ],
+ [
+ "u32",
+ "socket_id"
+ ],
+ [
+ "u8",
+ "socket_filename",
+ 128
+ ],
+ {
+ "crc": "0x30e3929d"
}
- },
- {
- "memif_delete": {
- "reply": "memif_delete_reply"
+ ],
+ [
+ "memif_socket_filename_add_del_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
}
- }
- ],
- "vl_api_version": "0x824c4ae0",
- "enums": [],
- "messages": [
+ ],
[
"memif_create",
[
"id"
],
[
- "u8",
- "socket_filename",
- 128
+ "u32",
+ "socket_id"
],
[
"u8",
6
],
{
- "crc": "0x3551c914"
+ "crc": "0x6597cdb2"
}
],
[
"crc": "0xe8d4e804"
}
],
+ [
+ "memif_socket_filename_details",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "socket_id"
+ ],
+ [
+ "u8",
+ "socket_filename",
+ 128
+ ],
+ {
+ "crc": "0xe347e32f"
+ }
+ ],
+ [
+ "memif_socket_filename_dump",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ {
+ "crc": "0x51077d14"
+ }
+ ],
[
"memif_details",
[
"mode"
],
[
- "u8",
- "socket_filename",
- 128
+ "u32",
+ "socket_id"
],
[
"u32",
"link_up_down"
],
{
- "crc": "0x0e1da928"
+ "crc": "0x4f5a3397"
}
],
[
}
]
],
+ "vl_api_version": "0x31b42e17",
+ "unions": [],
+ "services": {
+ "memif_delete": {
+ "reply": "memif_delete_reply"
+ },
+ "memif_socket_filename_add_del": {
+ "reply": "memif_socket_filename_add_del_reply"
+ },
+ "memif_create": {
+ "reply": "memif_create_reply"
+ },
+ "memif_socket_filename_dump": {
+ "reply": "memif_socket_filename_details",
+ "stream": true
+ },
+ "memif_dump": {
+ "reply": "memif_details",
+ "stream": true
+ }
+ },
+ "enums": [],
"types": []
}
--- /dev/null
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: memif.api.json
+
+/*
+Package memif is a generated VPP binary API of the 'memif' VPP module.
+
+It is generated from this file:
+ memif.api.json
+
+It contains these VPP binary API objects:
+ 10 messages
+ 5 services
+*/
+package memif
+
+import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
+
+/* Messages */
+
+// MemifSocketFilenameAddDel represents the VPP binary API message 'memif_socket_filename_add_del'.
+// Generated from 'memif.api.json', line 4:
+//
+// "memif_socket_filename_add_del",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "is_add"
+// ],
+// [
+// "u32",
+// "socket_id"
+// ],
+// [
+// "u8",
+// "socket_filename",
+// 128
+// ],
+// {
+// "crc": "0x30e3929d"
+// }
+//
+type MemifSocketFilenameAddDel struct {
+ IsAdd uint8
+ SocketID uint32
+ SocketFilename []byte `struc:"[128]byte"`
+}
+
+func (*MemifSocketFilenameAddDel) GetMessageName() string {
+ return "memif_socket_filename_add_del"
+}
+func (*MemifSocketFilenameAddDel) GetCrcString() string {
+ return "30e3929d"
+}
+func (*MemifSocketFilenameAddDel) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewMemifSocketFilenameAddDel() api.Message {
+ return &MemifSocketFilenameAddDel{}
+}
+
+// MemifSocketFilenameAddDelReply represents the VPP binary API message 'memif_socket_filename_add_del_reply'.
+// Generated from 'memif.api.json', line 35:
+//
+// "memif_socket_filename_add_del_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type MemifSocketFilenameAddDelReply struct {
+ Retval int32
+}
+
+func (*MemifSocketFilenameAddDelReply) GetMessageName() string {
+ return "memif_socket_filename_add_del_reply"
+}
+func (*MemifSocketFilenameAddDelReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*MemifSocketFilenameAddDelReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewMemifSocketFilenameAddDelReply() api.Message {
+ return &MemifSocketFilenameAddDelReply{}
+}
+
+// MemifCreate represents the VPP binary API message 'memif_create'.
+// Generated from 'memif.api.json', line 53:
+//
+// "memif_create",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u8",
+// "role"
+// ],
+// [
+// "u8",
+// "mode"
+// ],
+// [
+// "u8",
+// "rx_queues"
+// ],
+// [
+// "u8",
+// "tx_queues"
+// ],
+// [
+// "u32",
+// "id"
+// ],
+// [
+// "u32",
+// "socket_id"
+// ],
+// [
+// "u8",
+// "secret",
+// 24
+// ],
+// [
+// "u32",
+// "ring_size"
+// ],
+// [
+// "u16",
+// "buffer_size"
+// ],
+// [
+// "u8",
+// "hw_addr",
+// 6
+// ],
+// {
+// "crc": "0x6597cdb2"
+// }
+//
+type MemifCreate struct {
+ Role uint8
+ Mode uint8
+ RxQueues uint8
+ TxQueues uint8
+ ID uint32
+ SocketID uint32
+ Secret []byte `struc:"[24]byte"`
+ RingSize uint32
+ BufferSize uint16
+ HwAddr []byte `struc:"[6]byte"`
+}
+
+func (*MemifCreate) GetMessageName() string {
+ return "memif_create"
+}
+func (*MemifCreate) GetCrcString() string {
+ return "6597cdb2"
+}
+func (*MemifCreate) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewMemifCreate() api.Message {
+ return &MemifCreate{}
+}
+
+// MemifCreateReply represents the VPP binary API message 'memif_create_reply'.
+// Generated from 'memif.api.json', line 113:
+//
+// "memif_create_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0xfda5941f"
+// }
+//
+type MemifCreateReply struct {
+ Retval int32
+ SwIfIndex uint32
+}
+
+func (*MemifCreateReply) GetMessageName() string {
+ return "memif_create_reply"
+}
+func (*MemifCreateReply) GetCrcString() string {
+ return "fda5941f"
+}
+func (*MemifCreateReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewMemifCreateReply() api.Message {
+ return &MemifCreateReply{}
+}
+
+// MemifDelete represents the VPP binary API message 'memif_delete'.
+// Generated from 'memif.api.json', line 135:
+//
+// "memif_delete",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// {
+// "crc": "0x529cb13f"
+// }
+//
+type MemifDelete struct {
+ SwIfIndex uint32
+}
+
+func (*MemifDelete) GetMessageName() string {
+ return "memif_delete"
+}
+func (*MemifDelete) GetCrcString() string {
+ return "529cb13f"
+}
+func (*MemifDelete) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewMemifDelete() api.Message {
+ return &MemifDelete{}
+}
+
+// MemifDeleteReply represents the VPP binary API message 'memif_delete_reply'.
+// Generated from 'memif.api.json', line 157:
+//
+// "memif_delete_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type MemifDeleteReply struct {
+ Retval int32
+}
+
+func (*MemifDeleteReply) GetMessageName() string {
+ return "memif_delete_reply"
+}
+func (*MemifDeleteReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*MemifDeleteReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewMemifDeleteReply() api.Message {
+ return &MemifDeleteReply{}
+}
+
+// MemifSocketFilenameDetails represents the VPP binary API message 'memif_socket_filename_details'.
+// Generated from 'memif.api.json', line 175:
+//
+// "memif_socket_filename_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "socket_id"
+// ],
+// [
+// "u8",
+// "socket_filename",
+// 128
+// ],
+// {
+// "crc": "0xe347e32f"
+// }
+//
+type MemifSocketFilenameDetails struct {
+ SocketID uint32
+ SocketFilename []byte `struc:"[128]byte"`
+}
+
+func (*MemifSocketFilenameDetails) GetMessageName() string {
+ return "memif_socket_filename_details"
+}
+func (*MemifSocketFilenameDetails) GetCrcString() string {
+ return "e347e32f"
+}
+func (*MemifSocketFilenameDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewMemifSocketFilenameDetails() api.Message {
+ return &MemifSocketFilenameDetails{}
+}
+
+// MemifSocketFilenameDump represents the VPP binary API message 'memif_socket_filename_dump'.
+// Generated from 'memif.api.json', line 198:
+//
+// "memif_socket_filename_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type MemifSocketFilenameDump struct{}
+
+func (*MemifSocketFilenameDump) GetMessageName() string {
+ return "memif_socket_filename_dump"
+}
+func (*MemifSocketFilenameDump) GetCrcString() string {
+ return "51077d14"
+}
+func (*MemifSocketFilenameDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewMemifSocketFilenameDump() api.Message {
+ return &MemifSocketFilenameDump{}
+}
+
+// MemifDetails represents the VPP binary API message 'memif_details'.
+// Generated from 'memif.api.json', line 216:
+//
+// "memif_details",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u8",
+// "if_name",
+// 64
+// ],
+// [
+// "u8",
+// "hw_addr",
+// 6
+// ],
+// [
+// "u32",
+// "id"
+// ],
+// [
+// "u8",
+// "role"
+// ],
+// [
+// "u8",
+// "mode"
+// ],
+// [
+// "u32",
+// "socket_id"
+// ],
+// [
+// "u32",
+// "ring_size"
+// ],
+// [
+// "u16",
+// "buffer_size"
+// ],
+// [
+// "u8",
+// "admin_up_down"
+// ],
+// [
+// "u8",
+// "link_up_down"
+// ],
+// {
+// "crc": "0x4f5a3397"
+// }
+//
+type MemifDetails struct {
+ SwIfIndex uint32
+ IfName []byte `struc:"[64]byte"`
+ HwAddr []byte `struc:"[6]byte"`
+ ID uint32
+ Role uint8
+ Mode uint8
+ SocketID uint32
+ RingSize uint32
+ BufferSize uint16
+ AdminUpDown uint8
+ LinkUpDown uint8
+}
+
+func (*MemifDetails) GetMessageName() string {
+ return "memif_details"
+}
+func (*MemifDetails) GetCrcString() string {
+ return "4f5a3397"
+}
+func (*MemifDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewMemifDetails() api.Message {
+ return &MemifDetails{}
+}
+
+// MemifDump represents the VPP binary API message 'memif_dump'.
+// Generated from 'memif.api.json', line 276:
+//
+// "memif_dump",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type MemifDump struct{}
+
+func (*MemifDump) GetMessageName() string {
+ return "memif_dump"
+}
+func (*MemifDump) GetCrcString() string {
+ return "51077d14"
+}
+func (*MemifDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewMemifDump() api.Message {
+ return &MemifDump{}
+}
+
+/* Services */
+
+type Services interface {
+ DumpMemif(*MemifDump) (*MemifDetails, error)
+ DumpMemifSocketFilename(*MemifSocketFilenameDump) (*MemifSocketFilenameDetails, error)
+ MemifCreate(*MemifCreate) (*MemifCreateReply, error)
+ MemifDelete(*MemifDelete) (*MemifDeleteReply, error)
+ MemifSocketFilenameAddDel(*MemifSocketFilenameAddDel) (*MemifSocketFilenameAddDelReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*MemifSocketFilenameAddDel)(nil), "memif.MemifSocketFilenameAddDel")
+ api.RegisterMessage((*MemifSocketFilenameAddDelReply)(nil), "memif.MemifSocketFilenameAddDelReply")
+ api.RegisterMessage((*MemifCreate)(nil), "memif.MemifCreate")
+ api.RegisterMessage((*MemifCreateReply)(nil), "memif.MemifCreateReply")
+ api.RegisterMessage((*MemifDelete)(nil), "memif.MemifDelete")
+ api.RegisterMessage((*MemifDeleteReply)(nil), "memif.MemifDeleteReply")
+ api.RegisterMessage((*MemifSocketFilenameDetails)(nil), "memif.MemifSocketFilenameDetails")
+ api.RegisterMessage((*MemifSocketFilenameDump)(nil), "memif.MemifSocketFilenameDump")
+ api.RegisterMessage((*MemifDetails)(nil), "memif.MemifDetails")
+ api.RegisterMessage((*MemifDump)(nil), "memif.MemifDump")
+}
+++ /dev/null
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package memif represents the VPP binary API of the 'memif' VPP module.
-// Generated from '../../bin_api/memif.api.json'
-package memif
-
-import "git.fd.io/govpp.git/api"
-
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0x824c4ae0
-
-// MemifCreate represents the VPP binary API message 'memif_create'.
-// Generated from '../../bin_api/memif.api.json', line 24:
-//
-// "memif_create",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u8",
-// "role"
-// ],
-// [
-// "u8",
-// "mode"
-// ],
-// [
-// "u8",
-// "rx_queues"
-// ],
-// [
-// "u8",
-// "tx_queues"
-// ],
-// [
-// "u32",
-// "id"
-// ],
-// [
-// "u8",
-// "socket_filename",
-// 128
-// ],
-// [
-// "u8",
-// "secret",
-// 24
-// ],
-// [
-// "u32",
-// "ring_size"
-// ],
-// [
-// "u16",
-// "buffer_size"
-// ],
-// [
-// "u8",
-// "hw_addr",
-// 6
-// ],
-// {
-// "crc": "0x3551c914"
-// }
-//
-type MemifCreate struct {
- Role uint8
- Mode uint8
- RxQueues uint8
- TxQueues uint8
- ID uint32
- SocketFilename []byte `struc:"[128]byte"`
- Secret []byte `struc:"[24]byte"`
- RingSize uint32
- BufferSize uint16
- HwAddr []byte `struc:"[6]byte"`
-}
-
-func (*MemifCreate) GetMessageName() string {
- return "memif_create"
-}
-func (*MemifCreate) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*MemifCreate) GetCrcString() string {
- return "3551c914"
-}
-func NewMemifCreate() api.Message {
- return &MemifCreate{}
-}
-
-// MemifCreateReply represents the VPP binary API message 'memif_create_reply'.
-// Generated from '../../bin_api/memif.api.json', line 85:
-//
-// "memif_create_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// [
-// "u32",
-// "sw_if_index"
-// ],
-// {
-// "crc": "0xfda5941f"
-// }
-//
-type MemifCreateReply struct {
- Retval int32
- SwIfIndex uint32
-}
-
-func (*MemifCreateReply) GetMessageName() string {
- return "memif_create_reply"
-}
-func (*MemifCreateReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*MemifCreateReply) GetCrcString() string {
- return "fda5941f"
-}
-func NewMemifCreateReply() api.Message {
- return &MemifCreateReply{}
-}
-
-// MemifDelete represents the VPP binary API message 'memif_delete'.
-// Generated from '../../bin_api/memif.api.json', line 107:
-//
-// "memif_delete",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u32",
-// "sw_if_index"
-// ],
-// {
-// "crc": "0x529cb13f"
-// }
-//
-type MemifDelete struct {
- SwIfIndex uint32
-}
-
-func (*MemifDelete) GetMessageName() string {
- return "memif_delete"
-}
-func (*MemifDelete) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*MemifDelete) GetCrcString() string {
- return "529cb13f"
-}
-func NewMemifDelete() api.Message {
- return &MemifDelete{}
-}
-
-// MemifDeleteReply represents the VPP binary API message 'memif_delete_reply'.
-// Generated from '../../bin_api/memif.api.json', line 129:
-//
-// "memif_delete_reply",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "i32",
-// "retval"
-// ],
-// {
-// "crc": "0xe8d4e804"
-// }
-//
-type MemifDeleteReply struct {
- Retval int32
-}
-
-func (*MemifDeleteReply) GetMessageName() string {
- return "memif_delete_reply"
-}
-func (*MemifDeleteReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*MemifDeleteReply) GetCrcString() string {
- return "e8d4e804"
-}
-func NewMemifDeleteReply() api.Message {
- return &MemifDeleteReply{}
-}
-
-// MemifDetails represents the VPP binary API message 'memif_details'.
-// Generated from '../../bin_api/memif.api.json', line 147:
-//
-// "memif_details",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// [
-// "u32",
-// "sw_if_index"
-// ],
-// [
-// "u8",
-// "if_name",
-// 64
-// ],
-// [
-// "u8",
-// "hw_addr",
-// 6
-// ],
-// [
-// "u32",
-// "id"
-// ],
-// [
-// "u8",
-// "role"
-// ],
-// [
-// "u8",
-// "mode"
-// ],
-// [
-// "u8",
-// "socket_filename",
-// 128
-// ],
-// [
-// "u32",
-// "ring_size"
-// ],
-// [
-// "u16",
-// "buffer_size"
-// ],
-// [
-// "u8",
-// "admin_up_down"
-// ],
-// [
-// "u8",
-// "link_up_down"
-// ],
-// {
-// "crc": "0x0e1da928"
-// }
-//
-type MemifDetails struct {
- SwIfIndex uint32
- IfName []byte `struc:"[64]byte"`
- HwAddr []byte `struc:"[6]byte"`
- ID uint32
- Role uint8
- Mode uint8
- SocketFilename []byte `struc:"[128]byte"`
- RingSize uint32
- BufferSize uint16
- AdminUpDown uint8
- LinkUpDown uint8
-}
-
-func (*MemifDetails) GetMessageName() string {
- return "memif_details"
-}
-func (*MemifDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
-func (*MemifDetails) GetCrcString() string {
- return "0e1da928"
-}
-func NewMemifDetails() api.Message {
- return &MemifDetails{}
-}
-
-// MemifDump represents the VPP binary API message 'memif_dump'.
-// Generated from '../../bin_api/memif.api.json', line 208:
-//
-// "memif_dump",
-// [
-// "u16",
-// "_vl_msg_id"
-// ],
-// [
-// "u32",
-// "client_index"
-// ],
-// [
-// "u32",
-// "context"
-// ],
-// {
-// "crc": "0x51077d14"
-// }
-//
-type MemifDump struct {
-}
-
-func (*MemifDump) GetMessageName() string {
- return "memif_dump"
-}
-func (*MemifDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
-func (*MemifDump) GetCrcString() string {
- return "51077d14"
-}
-func NewMemifDump() api.Message {
- return &MemifDump{}
-}
{
- "services": [
- {
- "want_ip4_fib_stats": {
- "reply": "want_ip4_fib_stats_reply"
- }
- },
- {
- "want_ip4_mfib_stats": {
- "reply": "want_ip4_mfib_stats_reply"
- }
- },
- {
- "want_interface_combined_stats": {
- "reply": "want_interface_combined_stats_reply"
- }
- },
- {
- "want_ip6_fib_stats": {
- "reply": "want_ip6_fib_stats_reply"
- }
- },
- {
- "want_stats": {
- "reply": "want_stats_reply"
- }
- },
- {
- "want_per_interface_simple_stats": {
- "reply": "want_per_interface_simple_stats_reply"
- }
- },
- {
- "want_per_interface_combined_stats": {
- "reply": "want_per_interface_combined_stats_reply"
- }
- },
- {
- "vnet_get_summary_stats": {
- "reply": "vnet_get_summary_stats_reply"
- }
- },
- {
- "want_ip6_mfib_stats": {
- "reply": "want_ip6_mfib_stats_reply"
- }
- },
- {
- "want_interface_simple_stats": {
- "reply": "want_interface_simple_stats_reply"
- }
- },
- {
- "want_ip4_nbr_stats": {
- "reply": "want_ip4_nbr_stats_reply"
- }
- },
- {
- "want_ip6_nbr_stats": {
- "reply": "want_ip6_nbr_stats_reply"
- }
- }
- ],
- "vl_api_version": "0x50890812",
- "enums": [],
"messages": [
[
"want_stats",
"crc": "0x650161c0"
}
],
+ [
+ "vnet_interface_simple_counters",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u8",
+ "vnet_counter_type"
+ ],
+ [
+ "u32",
+ "first_sw_if_index"
+ ],
+ [
+ "u32",
+ "count"
+ ],
+ [
+ "u64",
+ "data",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0x9bc4a808"
+ }
+ ],
+ [
+ "vnet_interface_combined_counters",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u8",
+ "vnet_counter_type"
+ ],
+ [
+ "u32",
+ "first_sw_if_index"
+ ],
+ [
+ "u32",
+ "count"
+ ],
+ [
+ "vl_api_vlib_counter_t",
+ "data",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0x2c595002"
+ }
+ ],
+ [
+ "vnet_per_interface_simple_counters",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "count"
+ ],
+ [
+ "u32",
+ "timestamp"
+ ],
+ [
+ "vl_api_vnet_simple_counter_t",
+ "data",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0xd1fba9ba"
+ }
+ ],
+ [
+ "vnet_per_interface_combined_counters",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "count"
+ ],
+ [
+ "u32",
+ "timestamp"
+ ],
+ [
+ "vl_api_vnet_combined_counter_t",
+ "data",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0xdc578375"
+ }
+ ],
[
"vnet_get_summary_stats",
[
{
"crc": "0x32b87c56"
}
+ ],
+ [
+ "stats_get_poller_delay",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ {
+ "crc": "0x51077d14"
+ }
+ ],
+ [
+ "stats_get_poller_delay_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ [
+ "u32",
+ "delay"
+ ],
+ {
+ "crc": "0x8c445a33"
+ }
+ ],
+ [
+ "want_udp_encap_stats",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "client_index"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "u32",
+ "enable"
+ ],
+ [
+ "u32",
+ "pid"
+ ],
+ {
+ "crc": "0xcfaccc1f"
+ }
+ ],
+ [
+ "want_udp_encap_stats_reply",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "context"
+ ],
+ [
+ "i32",
+ "retval"
+ ],
+ {
+ "crc": "0xe8d4e804"
+ }
+ ],
+ [
+ "vnet_udp_encap_counters",
+ [
+ "u16",
+ "_vl_msg_id"
+ ],
+ [
+ "u32",
+ "timestamp"
+ ],
+ [
+ "u32",
+ "count"
+ ],
+ [
+ "vl_api_udp_encap_counter_t",
+ "c",
+ 0,
+ "count"
+ ],
+ {
+ "crc": "0x1ab5e649"
+ }
]
],
+ "vl_api_version": "0xfc484aa",
+ "unions": [],
+ "services": {
+ "want_ip4_fib_stats": {
+ "reply": "want_ip4_fib_stats_reply",
+ "events": [
+ "vnet_ip4_fib_counters"
+ ]
+ },
+ "want_ip6_fib_stats": {
+ "reply": "want_ip6_fib_stats_reply",
+ "events": [
+ "vnet_ip6_fib_counters"
+ ]
+ },
+ "want_stats": {
+ "reply": "want_stats_reply"
+ },
+ "want_interface_simple_stats": {
+ "reply": "want_interface_simple_stats_reply",
+ "events": [
+ "vnet_interface_simple_counters"
+ ]
+ },
+ "stats_get_poller_delay": {
+ "reply": "stats_get_poller_delay_reply"
+ },
+ "want_per_interface_combined_stats": {
+ "reply": "want_per_interface_combined_stats_reply",
+ "events": [
+ "vnet_per_interface_combined_counters"
+ ]
+ },
+ "vnet_get_summary_stats": {
+ "reply": "vnet_get_summary_stats_reply"
+ },
+ "want_udp_encap_stats": {
+ "reply": "want_udp_encap_stats_reply",
+ "events": [
+ "vnet_udp_encap_counters"
+ ]
+ },
+ "want_ip6_nbr_stats": {
+ "reply": "want_ip6_nbr_stats_reply",
+ "events": [
+ "vnet_ip6_nbr_counters"
+ ]
+ },
+ "want_ip4_mfib_stats": {
+ "reply": "want_ip4_mfib_stats_reply",
+ "events": [
+ "vnet_ip4_mfib_counters"
+ ]
+ },
+ "want_ip6_mfib_stats": {
+ "reply": "want_ip6_mfib_stats_reply",
+ "events": [
+ "vnet_ip6_mfib_counters"
+ ]
+ },
+ "want_per_interface_simple_stats": {
+ "reply": "want_per_interface_simple_stats_reply",
+ "events": [
+ "vnet_per_interface_simple_counters"
+ ]
+ },
+ "want_interface_combined_stats": {
+ "reply": "want_interface_combined_stats_reply",
+ "events": [
+ "vnet_interface_combined_counters"
+ ]
+ },
+ "want_ip4_nbr_stats": {
+ "reply": "want_ip4_nbr_stats_reply",
+ "events": [
+ "vnet_ip4_nbr_counters"
+ ]
+ }
+ },
+ "enums": [],
"types": [
+ [
+ "vlib_counter",
+ [
+ "u64",
+ "packets"
+ ],
+ [
+ "u64",
+ "bytes"
+ ],
+ {
+ "crc": "0xce2325a2"
+ }
+ ],
+ [
+ "vnet_combined_counter",
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u64",
+ "rx_packets"
+ ],
+ [
+ "u64",
+ "rx_bytes"
+ ],
+ [
+ "u64",
+ "rx_unicast_packets"
+ ],
+ [
+ "u64",
+ "rx_unicast_bytes"
+ ],
+ [
+ "u64",
+ "rx_multicast_packets"
+ ],
+ [
+ "u64",
+ "rx_multicast_bytes"
+ ],
+ [
+ "u64",
+ "rx_broadcast_packets"
+ ],
+ [
+ "u64",
+ "rx_broadcast_bytes"
+ ],
+ [
+ "u64",
+ "tx_packets"
+ ],
+ [
+ "u64",
+ "tx_bytes"
+ ],
+ [
+ "u64",
+ "tx_unicast_packets"
+ ],
+ [
+ "u64",
+ "tx_unicast_bytes"
+ ],
+ [
+ "u64",
+ "tx_multicast_packets"
+ ],
+ [
+ "u64",
+ "tx_multicast_bytes"
+ ],
+ [
+ "u64",
+ "tx_broadcast_packets"
+ ],
+ [
+ "u64",
+ "tx_broadcast_bytes"
+ ],
+ {
+ "crc": "0x20905ca4"
+ }
+ ],
+ [
+ "vnet_simple_counter",
+ [
+ "u32",
+ "sw_if_index"
+ ],
+ [
+ "u64",
+ "drop"
+ ],
+ [
+ "u64",
+ "punt"
+ ],
+ [
+ "u64",
+ "rx_ip4"
+ ],
+ [
+ "u64",
+ "rx_ip6"
+ ],
+ [
+ "u64",
+ "rx_no_buffer"
+ ],
+ [
+ "u64",
+ "rx_miss"
+ ],
+ [
+ "u64",
+ "rx_error"
+ ],
+ [
+ "u64",
+ "tx_error"
+ ],
+ [
+ "u64",
+ "rx_mpls"
+ ],
+ {
+ "crc": "0x8bd65e2d"
+ }
+ ],
[
"ip4_fib_counter",
[
{
"crc": "0x2d755474"
}
+ ],
+ [
+ "udp_encap_counter",
+ [
+ "u32",
+ "id"
+ ],
+ [
+ "u64",
+ "packets"
+ ],
+ [
+ "u64",
+ "bytes"
+ ],
+ {
+ "crc": "0x7107035f"
+ }
]
]
}
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package stats represents the VPP binary API of the 'stats' VPP module.
-// Generated from '../../bin_api/stats.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: stats.api.json
+
+/*
+Package stats is a generated VPP binary API of the 'stats' VPP module.
+
+It is generated from this file:
+ stats.api.json
+
+It contains these VPP binary API objects:
+ 39 messages
+ 10 types
+ 14 services
+*/
package stats
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
+
+/* Types */
+
+// VlibCounter represents the VPP binary API type 'vlib_counter'.
+// Generated from 'stats.api.json', line 1004:
+//
+// "vlib_counter",
+// [
+// "u64",
+// "packets"
+// ],
+// [
+// "u64",
+// "bytes"
+// ],
+// {
+// "crc": "0xce2325a2"
+// }
+//
+type VlibCounter struct {
+ Packets uint64
+ Bytes uint64
+}
+
+func (*VlibCounter) GetTypeName() string {
+ return "vlib_counter"
+}
+func (*VlibCounter) GetCrcString() string {
+ return "ce2325a2"
+}
+
+// VnetCombinedCounter represents the VPP binary API type 'vnet_combined_counter'.
+// Generated from 'stats.api.json', line 1018:
+//
+// "vnet_combined_counter",
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u64",
+// "rx_packets"
+// ],
+// [
+// "u64",
+// "rx_bytes"
+// ],
+// [
+// "u64",
+// "rx_unicast_packets"
+// ],
+// [
+// "u64",
+// "rx_unicast_bytes"
+// ],
+// [
+// "u64",
+// "rx_multicast_packets"
+// ],
+// [
+// "u64",
+// "rx_multicast_bytes"
+// ],
+// [
+// "u64",
+// "rx_broadcast_packets"
+// ],
+// [
+// "u64",
+// "rx_broadcast_bytes"
+// ],
+// [
+// "u64",
+// "tx_packets"
+// ],
+// [
+// "u64",
+// "tx_bytes"
+// ],
+// [
+// "u64",
+// "tx_unicast_packets"
+// ],
+// [
+// "u64",
+// "tx_unicast_bytes"
+// ],
+// [
+// "u64",
+// "tx_multicast_packets"
+// ],
+// [
+// "u64",
+// "tx_multicast_bytes"
+// ],
+// [
+// "u64",
+// "tx_broadcast_packets"
+// ],
+// [
+// "u64",
+// "tx_broadcast_bytes"
+// ],
+// {
+// "crc": "0x20905ca4"
+// }
+//
+type VnetCombinedCounter struct {
+ SwIfIndex uint32
+ RxPackets uint64
+ RxBytes uint64
+ RxUnicastPackets uint64
+ RxUnicastBytes uint64
+ RxMulticastPackets uint64
+ RxMulticastBytes uint64
+ RxBroadcastPackets uint64
+ RxBroadcastBytes uint64
+ TxPackets uint64
+ TxBytes uint64
+ TxUnicastPackets uint64
+ TxUnicastBytes uint64
+ TxMulticastPackets uint64
+ TxMulticastBytes uint64
+ TxBroadcastPackets uint64
+ TxBroadcastBytes uint64
+}
+
+func (*VnetCombinedCounter) GetTypeName() string {
+ return "vnet_combined_counter"
+}
+func (*VnetCombinedCounter) GetCrcString() string {
+ return "20905ca4"
+}
+
+// VnetSimpleCounter represents the VPP binary API type 'vnet_simple_counter'.
+// Generated from 'stats.api.json', line 1092:
+//
+// "vnet_simple_counter",
+// [
+// "u32",
+// "sw_if_index"
+// ],
+// [
+// "u64",
+// "drop"
+// ],
+// [
+// "u64",
+// "punt"
+// ],
+// [
+// "u64",
+// "rx_ip4"
+// ],
+// [
+// "u64",
+// "rx_ip6"
+// ],
+// [
+// "u64",
+// "rx_no_buffer"
+// ],
+// [
+// "u64",
+// "rx_miss"
+// ],
+// [
+// "u64",
+// "rx_error"
+// ],
+// [
+// "u64",
+// "tx_error"
+// ],
+// [
+// "u64",
+// "rx_mpls"
+// ],
+// {
+// "crc": "0x8bd65e2d"
+// }
+//
+type VnetSimpleCounter struct {
+ SwIfIndex uint32
+ Drop uint64
+ Punt uint64
+ RxIP4 uint64
+ RxIP6 uint64
+ RxNoBuffer uint64
+ RxMiss uint64
+ RxError uint64
+ TxError uint64
+ RxMpls uint64
+}
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0x50890812
+func (*VnetSimpleCounter) GetTypeName() string {
+ return "vnet_simple_counter"
+}
+func (*VnetSimpleCounter) GetCrcString() string {
+ return "8bd65e2d"
+}
-// IP4FibCounter represents the VPP binary API data type 'ip4_fib_counter'.
-// Generated from '../../bin_api/stats.api.json', line 776:
+// IP4FibCounter represents the VPP binary API type 'ip4_fib_counter'.
+// Generated from 'stats.api.json', line 1138:
//
// "ip4_fib_counter",
// [
return "a6ceb0c9"
}
-// IP4MfibCounter represents the VPP binary API data type 'ip4_mfib_counter'.
-// Generated from '../../bin_api/stats.api.json', line 798:
+// IP4MfibCounter represents the VPP binary API type 'ip4_mfib_counter'.
+// Generated from 'stats.api.json', line 1160:
//
// "ip4_mfib_counter",
// [
return "2cee4721"
}
-// IP4NbrCounter represents the VPP binary API data type 'ip4_nbr_counter'.
-// Generated from '../../bin_api/stats.api.json', line 826:
+// IP4NbrCounter represents the VPP binary API type 'ip4_nbr_counter'.
+// Generated from 'stats.api.json', line 1188:
//
// "ip4_nbr_counter",
// [
return "b9f974d6"
}
-// IP6FibCounter represents the VPP binary API data type 'ip6_fib_counter'.
-// Generated from '../../bin_api/stats.api.json', line 848:
+// IP6FibCounter represents the VPP binary API type 'ip6_fib_counter'.
+// Generated from 'stats.api.json', line 1210:
//
// "ip6_fib_counter",
// [
return "f1197efb"
}
-// IP6MfibCounter represents the VPP binary API data type 'ip6_mfib_counter'.
-// Generated from '../../bin_api/stats.api.json', line 871:
+// IP6MfibCounter represents the VPP binary API type 'ip6_mfib_counter'.
+// Generated from 'stats.api.json', line 1233:
//
// "ip6_mfib_counter",
// [
return "90a9590e"
}
-// IP6NbrCounter represents the VPP binary API data type 'ip6_nbr_counter'.
-// Generated from '../../bin_api/stats.api.json', line 899:
+// IP6NbrCounter represents the VPP binary API type 'ip6_nbr_counter'.
+// Generated from 'stats.api.json', line 1261:
//
// "ip6_nbr_counter",
// [
return "2d755474"
}
+// UDPEncapCounter represents the VPP binary API type 'udp_encap_counter'.
+// Generated from 'stats.api.json', line 1284:
+//
+// "udp_encap_counter",
+// [
+// "u32",
+// "id"
+// ],
+// [
+// "u64",
+// "packets"
+// ],
+// [
+// "u64",
+// "bytes"
+// ],
+// {
+// "crc": "0x7107035f"
+// }
+//
+type UDPEncapCounter struct {
+ ID uint32
+ Packets uint64
+ Bytes uint64
+}
+
+func (*UDPEncapCounter) GetTypeName() string {
+ return "udp_encap_counter"
+}
+func (*UDPEncapCounter) GetCrcString() string {
+ return "7107035f"
+}
+
+/* Messages */
+
// WantStats represents the VPP binary API message 'want_stats'.
-// Generated from '../../bin_api/stats.api.json', line 68:
+// Generated from 'stats.api.json', line 4:
//
// "want_stats",
// [
//
type WantStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantStats) GetMessageName() string {
return "want_stats"
}
-func (*WantStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantStats() api.Message {
return &WantStats{}
}
// WantStatsReply represents the VPP binary API message 'want_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 94:
+// Generated from 'stats.api.json', line 30:
//
// "want_stats_reply",
// [
func (*WantStatsReply) GetMessageName() string {
return "want_stats_reply"
}
-func (*WantStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantStatsReply() api.Message {
return &WantStatsReply{}
}
// WantInterfaceSimpleStats represents the VPP binary API message 'want_interface_simple_stats'.
-// Generated from '../../bin_api/stats.api.json', line 112:
+// Generated from 'stats.api.json', line 48:
//
// "want_interface_simple_stats",
// [
//
type WantInterfaceSimpleStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantInterfaceSimpleStats) GetMessageName() string {
return "want_interface_simple_stats"
}
-func (*WantInterfaceSimpleStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantInterfaceSimpleStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantInterfaceSimpleStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantInterfaceSimpleStats() api.Message {
return &WantInterfaceSimpleStats{}
}
// WantInterfaceSimpleStatsReply represents the VPP binary API message 'want_interface_simple_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 138:
+// Generated from 'stats.api.json', line 74:
//
// "want_interface_simple_stats_reply",
// [
func (*WantInterfaceSimpleStatsReply) GetMessageName() string {
return "want_interface_simple_stats_reply"
}
-func (*WantInterfaceSimpleStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantInterfaceSimpleStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantInterfaceSimpleStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantInterfaceSimpleStatsReply() api.Message {
return &WantInterfaceSimpleStatsReply{}
}
// WantPerInterfaceSimpleStats represents the VPP binary API message 'want_per_interface_simple_stats'.
-// Generated from '../../bin_api/stats.api.json', line 156:
+// Generated from 'stats.api.json', line 92:
//
// "want_per_interface_simple_stats",
// [
//
type WantPerInterfaceSimpleStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
Num uint32 `struc:"sizeof=SwIfs"`
SwIfs []uint32
}
func (*WantPerInterfaceSimpleStats) GetMessageName() string {
return "want_per_interface_simple_stats"
}
-func (*WantPerInterfaceSimpleStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantPerInterfaceSimpleStats) GetCrcString() string {
return "729d04f1"
}
+func (*WantPerInterfaceSimpleStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantPerInterfaceSimpleStats() api.Message {
return &WantPerInterfaceSimpleStats{}
}
// WantPerInterfaceSimpleStatsReply represents the VPP binary API message 'want_per_interface_simple_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 192:
+// Generated from 'stats.api.json', line 128:
//
// "want_per_interface_simple_stats_reply",
// [
func (*WantPerInterfaceSimpleStatsReply) GetMessageName() string {
return "want_per_interface_simple_stats_reply"
}
-func (*WantPerInterfaceSimpleStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantPerInterfaceSimpleStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantPerInterfaceSimpleStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantPerInterfaceSimpleStatsReply() api.Message {
return &WantPerInterfaceSimpleStatsReply{}
}
// WantInterfaceCombinedStats represents the VPP binary API message 'want_interface_combined_stats'.
-// Generated from '../../bin_api/stats.api.json', line 210:
+// Generated from 'stats.api.json', line 146:
//
// "want_interface_combined_stats",
// [
//
type WantInterfaceCombinedStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantInterfaceCombinedStats) GetMessageName() string {
return "want_interface_combined_stats"
}
-func (*WantInterfaceCombinedStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantInterfaceCombinedStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantInterfaceCombinedStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantInterfaceCombinedStats() api.Message {
return &WantInterfaceCombinedStats{}
}
// WantInterfaceCombinedStatsReply represents the VPP binary API message 'want_interface_combined_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 236:
+// Generated from 'stats.api.json', line 172:
//
// "want_interface_combined_stats_reply",
// [
func (*WantInterfaceCombinedStatsReply) GetMessageName() string {
return "want_interface_combined_stats_reply"
}
-func (*WantInterfaceCombinedStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantInterfaceCombinedStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantInterfaceCombinedStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantInterfaceCombinedStatsReply() api.Message {
return &WantInterfaceCombinedStatsReply{}
}
// WantPerInterfaceCombinedStats represents the VPP binary API message 'want_per_interface_combined_stats'.
-// Generated from '../../bin_api/stats.api.json', line 254:
+// Generated from 'stats.api.json', line 190:
//
// "want_per_interface_combined_stats",
// [
//
type WantPerInterfaceCombinedStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
Num uint32 `struc:"sizeof=SwIfs"`
SwIfs []uint32
}
func (*WantPerInterfaceCombinedStats) GetMessageName() string {
return "want_per_interface_combined_stats"
}
-func (*WantPerInterfaceCombinedStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantPerInterfaceCombinedStats) GetCrcString() string {
return "729d04f1"
}
+func (*WantPerInterfaceCombinedStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantPerInterfaceCombinedStats() api.Message {
return &WantPerInterfaceCombinedStats{}
}
// WantPerInterfaceCombinedStatsReply represents the VPP binary API message 'want_per_interface_combined_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 290:
+// Generated from 'stats.api.json', line 226:
//
// "want_per_interface_combined_stats_reply",
// [
func (*WantPerInterfaceCombinedStatsReply) GetMessageName() string {
return "want_per_interface_combined_stats_reply"
}
-func (*WantPerInterfaceCombinedStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantPerInterfaceCombinedStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantPerInterfaceCombinedStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantPerInterfaceCombinedStatsReply() api.Message {
return &WantPerInterfaceCombinedStatsReply{}
}
// WantIP4FibStats represents the VPP binary API message 'want_ip4_fib_stats'.
-// Generated from '../../bin_api/stats.api.json', line 308:
+// Generated from 'stats.api.json', line 244:
//
// "want_ip4_fib_stats",
// [
//
type WantIP4FibStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP4FibStats) GetMessageName() string {
return "want_ip4_fib_stats"
}
-func (*WantIP4FibStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP4FibStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantIP4FibStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP4FibStats() api.Message {
return &WantIP4FibStats{}
}
// WantIP4FibStatsReply represents the VPP binary API message 'want_ip4_fib_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 334:
+// Generated from 'stats.api.json', line 270:
//
// "want_ip4_fib_stats_reply",
// [
func (*WantIP4FibStatsReply) GetMessageName() string {
return "want_ip4_fib_stats_reply"
}
-func (*WantIP4FibStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP4FibStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP4FibStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP4FibStatsReply() api.Message {
return &WantIP4FibStatsReply{}
}
// WantIP6FibStats represents the VPP binary API message 'want_ip6_fib_stats'.
-// Generated from '../../bin_api/stats.api.json', line 352:
+// Generated from 'stats.api.json', line 288:
//
// "want_ip6_fib_stats",
// [
//
type WantIP6FibStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP6FibStats) GetMessageName() string {
return "want_ip6_fib_stats"
}
-func (*WantIP6FibStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP6FibStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantIP6FibStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP6FibStats() api.Message {
return &WantIP6FibStats{}
}
// WantIP6FibStatsReply represents the VPP binary API message 'want_ip6_fib_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 378:
+// Generated from 'stats.api.json', line 314:
//
// "want_ip6_fib_stats_reply",
// [
func (*WantIP6FibStatsReply) GetMessageName() string {
return "want_ip6_fib_stats_reply"
}
-func (*WantIP6FibStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP6FibStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP6FibStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP6FibStatsReply() api.Message {
return &WantIP6FibStatsReply{}
}
// WantIP4MfibStats represents the VPP binary API message 'want_ip4_mfib_stats'.
-// Generated from '../../bin_api/stats.api.json', line 396:
+// Generated from 'stats.api.json', line 332:
//
// "want_ip4_mfib_stats",
// [
//
type WantIP4MfibStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP4MfibStats) GetMessageName() string {
return "want_ip4_mfib_stats"
}
-func (*WantIP4MfibStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP4MfibStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantIP4MfibStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP4MfibStats() api.Message {
return &WantIP4MfibStats{}
}
// WantIP4MfibStatsReply represents the VPP binary API message 'want_ip4_mfib_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 422:
+// Generated from 'stats.api.json', line 358:
//
// "want_ip4_mfib_stats_reply",
// [
func (*WantIP4MfibStatsReply) GetMessageName() string {
return "want_ip4_mfib_stats_reply"
}
-func (*WantIP4MfibStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP4MfibStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP4MfibStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP4MfibStatsReply() api.Message {
return &WantIP4MfibStatsReply{}
}
// WantIP6MfibStats represents the VPP binary API message 'want_ip6_mfib_stats'.
-// Generated from '../../bin_api/stats.api.json', line 440:
+// Generated from 'stats.api.json', line 376:
//
// "want_ip6_mfib_stats",
// [
//
type WantIP6MfibStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP6MfibStats) GetMessageName() string {
return "want_ip6_mfib_stats"
}
-func (*WantIP6MfibStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP6MfibStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantIP6MfibStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP6MfibStats() api.Message {
return &WantIP6MfibStats{}
}
// WantIP6MfibStatsReply represents the VPP binary API message 'want_ip6_mfib_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 466:
+// Generated from 'stats.api.json', line 402:
//
// "want_ip6_mfib_stats_reply",
// [
func (*WantIP6MfibStatsReply) GetMessageName() string {
return "want_ip6_mfib_stats_reply"
}
-func (*WantIP6MfibStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP6MfibStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP6MfibStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP6MfibStatsReply() api.Message {
return &WantIP6MfibStatsReply{}
}
// WantIP4NbrStats represents the VPP binary API message 'want_ip4_nbr_stats'.
-// Generated from '../../bin_api/stats.api.json', line 484:
+// Generated from 'stats.api.json', line 420:
//
// "want_ip4_nbr_stats",
// [
//
type WantIP4NbrStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP4NbrStats) GetMessageName() string {
return "want_ip4_nbr_stats"
}
-func (*WantIP4NbrStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP4NbrStats) GetCrcString() string {
return "476f5a08"
}
-func NewWantIP4NbrStats() api.Message {
- return &WantIP4NbrStats{}
+func (*WantIP4NbrStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewWantIP4NbrStats() api.Message {
+ return &WantIP4NbrStats{}
}
// WantIP4NbrStatsReply represents the VPP binary API message 'want_ip4_nbr_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 510:
+// Generated from 'stats.api.json', line 446:
//
// "want_ip4_nbr_stats_reply",
// [
func (*WantIP4NbrStatsReply) GetMessageName() string {
return "want_ip4_nbr_stats_reply"
}
-func (*WantIP4NbrStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP4NbrStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP4NbrStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP4NbrStatsReply() api.Message {
return &WantIP4NbrStatsReply{}
}
// WantIP6NbrStats represents the VPP binary API message 'want_ip6_nbr_stats'.
-// Generated from '../../bin_api/stats.api.json', line 528:
+// Generated from 'stats.api.json', line 464:
//
// "want_ip6_nbr_stats",
// [
//
type WantIP6NbrStats struct {
EnableDisable uint32
- Pid uint32
+ PID uint32
}
func (*WantIP6NbrStats) GetMessageName() string {
return "want_ip6_nbr_stats"
}
-func (*WantIP6NbrStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*WantIP6NbrStats) GetCrcString() string {
return "476f5a08"
}
+func (*WantIP6NbrStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewWantIP6NbrStats() api.Message {
return &WantIP6NbrStats{}
}
// WantIP6NbrStatsReply represents the VPP binary API message 'want_ip6_nbr_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 554:
+// Generated from 'stats.api.json', line 490:
//
// "want_ip6_nbr_stats_reply",
// [
func (*WantIP6NbrStatsReply) GetMessageName() string {
return "want_ip6_nbr_stats_reply"
}
-func (*WantIP6NbrStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*WantIP6NbrStatsReply) GetCrcString() string {
return "e8d4e804"
}
+func (*WantIP6NbrStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewWantIP6NbrStatsReply() api.Message {
return &WantIP6NbrStatsReply{}
}
// VnetIP4FibCounters represents the VPP binary API message 'vnet_ip4_fib_counters'.
-// Generated from '../../bin_api/stats.api.json', line 572:
+// Generated from 'stats.api.json', line 508:
//
// "vnet_ip4_fib_counters",
// [
func (*VnetIP4FibCounters) GetMessageName() string {
return "vnet_ip4_fib_counters"
}
-func (*VnetIP4FibCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP4FibCounters) GetCrcString() string {
return "57e3feec"
}
+func (*VnetIP4FibCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP4FibCounters() api.Message {
return &VnetIP4FibCounters{}
}
// VnetIP4MfibCounters represents the VPP binary API message 'vnet_ip4_mfib_counters'.
-// Generated from '../../bin_api/stats.api.json', line 596:
+// Generated from 'stats.api.json', line 532:
//
// "vnet_ip4_mfib_counters",
// [
func (*VnetIP4MfibCounters) GetMessageName() string {
return "vnet_ip4_mfib_counters"
}
-func (*VnetIP4MfibCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP4MfibCounters) GetCrcString() string {
return "946eb588"
}
+func (*VnetIP4MfibCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP4MfibCounters() api.Message {
return &VnetIP4MfibCounters{}
}
// VnetIP4NbrCounters represents the VPP binary API message 'vnet_ip4_nbr_counters'.
-// Generated from '../../bin_api/stats.api.json', line 620:
+// Generated from 'stats.api.json', line 556:
//
// "vnet_ip4_nbr_counters",
// [
func (*VnetIP4NbrCounters) GetMessageName() string {
return "vnet_ip4_nbr_counters"
}
-func (*VnetIP4NbrCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP4NbrCounters) GetCrcString() string {
return "214c4811"
}
+func (*VnetIP4NbrCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP4NbrCounters() api.Message {
return &VnetIP4NbrCounters{}
}
// VnetIP6FibCounters represents the VPP binary API message 'vnet_ip6_fib_counters'.
-// Generated from '../../bin_api/stats.api.json', line 648:
+// Generated from 'stats.api.json', line 584:
//
// "vnet_ip6_fib_counters",
// [
func (*VnetIP6FibCounters) GetMessageName() string {
return "vnet_ip6_fib_counters"
}
-func (*VnetIP6FibCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP6FibCounters) GetCrcString() string {
return "13aed73d"
}
+func (*VnetIP6FibCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP6FibCounters() api.Message {
return &VnetIP6FibCounters{}
}
// VnetIP6MfibCounters represents the VPP binary API message 'vnet_ip6_mfib_counters'.
-// Generated from '../../bin_api/stats.api.json', line 672:
+// Generated from 'stats.api.json', line 608:
//
// "vnet_ip6_mfib_counters",
// [
func (*VnetIP6MfibCounters) GetMessageName() string {
return "vnet_ip6_mfib_counters"
}
-func (*VnetIP6MfibCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP6MfibCounters) GetCrcString() string {
return "65fe1ae3"
}
+func (*VnetIP6MfibCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP6MfibCounters() api.Message {
return &VnetIP6MfibCounters{}
}
// VnetIP6NbrCounters represents the VPP binary API message 'vnet_ip6_nbr_counters'.
-// Generated from '../../bin_api/stats.api.json', line 696:
+// Generated from 'stats.api.json', line 632:
//
// "vnet_ip6_nbr_counters",
// [
func (*VnetIP6NbrCounters) GetMessageName() string {
return "vnet_ip6_nbr_counters"
}
-func (*VnetIP6NbrCounters) GetMessageType() api.MessageType {
- return api.OtherMessage
-}
func (*VnetIP6NbrCounters) GetCrcString() string {
return "650161c0"
}
+func (*VnetIP6NbrCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
func NewVnetIP6NbrCounters() api.Message {
return &VnetIP6NbrCounters{}
}
+// VnetInterfaceSimpleCounters represents the VPP binary API message 'vnet_interface_simple_counters'.
+// Generated from 'stats.api.json', line 660:
+//
+// "vnet_interface_simple_counters",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u8",
+// "vnet_counter_type"
+// ],
+// [
+// "u32",
+// "first_sw_if_index"
+// ],
+// [
+// "u32",
+// "count"
+// ],
+// [
+// "u64",
+// "data",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0x9bc4a808"
+// }
+//
+type VnetInterfaceSimpleCounters struct {
+ VnetCounterType uint8
+ FirstSwIfIndex uint32
+ Count uint32 `struc:"sizeof=Data"`
+ Data []uint64
+}
+
+func (*VnetInterfaceSimpleCounters) GetMessageName() string {
+ return "vnet_interface_simple_counters"
+}
+func (*VnetInterfaceSimpleCounters) GetCrcString() string {
+ return "9bc4a808"
+}
+func (*VnetInterfaceSimpleCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewVnetInterfaceSimpleCounters() api.Message {
+ return &VnetInterfaceSimpleCounters{}
+}
+
+// VnetInterfaceCombinedCounters represents the VPP binary API message 'vnet_interface_combined_counters'.
+// Generated from 'stats.api.json', line 688:
+//
+// "vnet_interface_combined_counters",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u8",
+// "vnet_counter_type"
+// ],
+// [
+// "u32",
+// "first_sw_if_index"
+// ],
+// [
+// "u32",
+// "count"
+// ],
+// [
+// "vl_api_vlib_counter_t",
+// "data",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0x2c595002"
+// }
+//
+type VnetInterfaceCombinedCounters struct {
+ VnetCounterType uint8
+ FirstSwIfIndex uint32
+ Count uint32 `struc:"sizeof=Data"`
+ Data []VlibCounter
+}
+
+func (*VnetInterfaceCombinedCounters) GetMessageName() string {
+ return "vnet_interface_combined_counters"
+}
+func (*VnetInterfaceCombinedCounters) GetCrcString() string {
+ return "2c595002"
+}
+func (*VnetInterfaceCombinedCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewVnetInterfaceCombinedCounters() api.Message {
+ return &VnetInterfaceCombinedCounters{}
+}
+
+// VnetPerInterfaceSimpleCounters represents the VPP binary API message 'vnet_per_interface_simple_counters'.
+// Generated from 'stats.api.json', line 716:
+//
+// "vnet_per_interface_simple_counters",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "count"
+// ],
+// [
+// "u32",
+// "timestamp"
+// ],
+// [
+// "vl_api_vnet_simple_counter_t",
+// "data",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0xd1fba9ba"
+// }
+//
+type VnetPerInterfaceSimpleCounters struct {
+ Count uint32 `struc:"sizeof=Data"`
+ Timestamp uint32
+ Data []VnetSimpleCounter
+}
+
+func (*VnetPerInterfaceSimpleCounters) GetMessageName() string {
+ return "vnet_per_interface_simple_counters"
+}
+func (*VnetPerInterfaceSimpleCounters) GetCrcString() string {
+ return "d1fba9ba"
+}
+func (*VnetPerInterfaceSimpleCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewVnetPerInterfaceSimpleCounters() api.Message {
+ return &VnetPerInterfaceSimpleCounters{}
+}
+
+// VnetPerInterfaceCombinedCounters represents the VPP binary API message 'vnet_per_interface_combined_counters'.
+// Generated from 'stats.api.json', line 740:
+//
+// "vnet_per_interface_combined_counters",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "count"
+// ],
+// [
+// "u32",
+// "timestamp"
+// ],
+// [
+// "vl_api_vnet_combined_counter_t",
+// "data",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0xdc578375"
+// }
+//
+type VnetPerInterfaceCombinedCounters struct {
+ Count uint32 `struc:"sizeof=Data"`
+ Timestamp uint32
+ Data []VnetCombinedCounter
+}
+
+func (*VnetPerInterfaceCombinedCounters) GetMessageName() string {
+ return "vnet_per_interface_combined_counters"
+}
+func (*VnetPerInterfaceCombinedCounters) GetCrcString() string {
+ return "dc578375"
+}
+func (*VnetPerInterfaceCombinedCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewVnetPerInterfaceCombinedCounters() api.Message {
+ return &VnetPerInterfaceCombinedCounters{}
+}
+
// VnetGetSummaryStats represents the VPP binary API message 'vnet_get_summary_stats'.
-// Generated from '../../bin_api/stats.api.json', line 724:
+// Generated from 'stats.api.json', line 764:
//
// "vnet_get_summary_stats",
// [
// "crc": "0x51077d14"
// }
//
-type VnetGetSummaryStats struct {
-}
+type VnetGetSummaryStats struct{}
func (*VnetGetSummaryStats) GetMessageName() string {
return "vnet_get_summary_stats"
}
-func (*VnetGetSummaryStats) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*VnetGetSummaryStats) GetCrcString() string {
return "51077d14"
}
+func (*VnetGetSummaryStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewVnetGetSummaryStats() api.Message {
return &VnetGetSummaryStats{}
}
// VnetGetSummaryStatsReply represents the VPP binary API message 'vnet_get_summary_stats_reply'.
-// Generated from '../../bin_api/stats.api.json', line 742:
+// Generated from 'stats.api.json', line 782:
//
// "vnet_get_summary_stats_reply",
// [
func (*VnetGetSummaryStatsReply) GetMessageName() string {
return "vnet_get_summary_stats_reply"
}
-func (*VnetGetSummaryStatsReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*VnetGetSummaryStatsReply) GetCrcString() string {
return "32b87c56"
}
+func (*VnetGetSummaryStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewVnetGetSummaryStatsReply() api.Message {
return &VnetGetSummaryStatsReply{}
}
+
+// StatsGetPollerDelay represents the VPP binary API message 'stats_get_poller_delay'.
+// Generated from 'stats.api.json', line 814:
+//
+// "stats_get_poller_delay",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// {
+// "crc": "0x51077d14"
+// }
+//
+type StatsGetPollerDelay struct{}
+
+func (*StatsGetPollerDelay) GetMessageName() string {
+ return "stats_get_poller_delay"
+}
+func (*StatsGetPollerDelay) GetCrcString() string {
+ return "51077d14"
+}
+func (*StatsGetPollerDelay) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewStatsGetPollerDelay() api.Message {
+ return &StatsGetPollerDelay{}
+}
+
+// StatsGetPollerDelayReply represents the VPP binary API message 'stats_get_poller_delay_reply'.
+// Generated from 'stats.api.json', line 832:
+//
+// "stats_get_poller_delay_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// [
+// "u32",
+// "delay"
+// ],
+// {
+// "crc": "0x8c445a33"
+// }
+//
+type StatsGetPollerDelayReply struct {
+ Retval int32
+ Delay uint32
+}
+
+func (*StatsGetPollerDelayReply) GetMessageName() string {
+ return "stats_get_poller_delay_reply"
+}
+func (*StatsGetPollerDelayReply) GetCrcString() string {
+ return "8c445a33"
+}
+func (*StatsGetPollerDelayReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewStatsGetPollerDelayReply() api.Message {
+ return &StatsGetPollerDelayReply{}
+}
+
+// WantUDPEncapStats represents the VPP binary API message 'want_udp_encap_stats'.
+// Generated from 'stats.api.json', line 854:
+//
+// "want_udp_encap_stats",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "client_index"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "u32",
+// "enable"
+// ],
+// [
+// "u32",
+// "pid"
+// ],
+// {
+// "crc": "0xcfaccc1f"
+// }
+//
+type WantUDPEncapStats struct {
+ Enable uint32
+ PID uint32
+}
+
+func (*WantUDPEncapStats) GetMessageName() string {
+ return "want_udp_encap_stats"
+}
+func (*WantUDPEncapStats) GetCrcString() string {
+ return "cfaccc1f"
+}
+func (*WantUDPEncapStats) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
+func NewWantUDPEncapStats() api.Message {
+ return &WantUDPEncapStats{}
+}
+
+// WantUDPEncapStatsReply represents the VPP binary API message 'want_udp_encap_stats_reply'.
+// Generated from 'stats.api.json', line 880:
+//
+// "want_udp_encap_stats_reply",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "context"
+// ],
+// [
+// "i32",
+// "retval"
+// ],
+// {
+// "crc": "0xe8d4e804"
+// }
+//
+type WantUDPEncapStatsReply struct {
+ Retval int32
+}
+
+func (*WantUDPEncapStatsReply) GetMessageName() string {
+ return "want_udp_encap_stats_reply"
+}
+func (*WantUDPEncapStatsReply) GetCrcString() string {
+ return "e8d4e804"
+}
+func (*WantUDPEncapStatsReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
+func NewWantUDPEncapStatsReply() api.Message {
+ return &WantUDPEncapStatsReply{}
+}
+
+// VnetUDPEncapCounters represents the VPP binary API message 'vnet_udp_encap_counters'.
+// Generated from 'stats.api.json', line 898:
+//
+// "vnet_udp_encap_counters",
+// [
+// "u16",
+// "_vl_msg_id"
+// ],
+// [
+// "u32",
+// "timestamp"
+// ],
+// [
+// "u32",
+// "count"
+// ],
+// [
+// "vl_api_udp_encap_counter_t",
+// "c",
+// 0,
+// "count"
+// ],
+// {
+// "crc": "0x1ab5e649"
+// }
+//
+type VnetUDPEncapCounters struct {
+ Timestamp uint32
+ Count uint32 `struc:"sizeof=C"`
+ C []UDPEncapCounter
+}
+
+func (*VnetUDPEncapCounters) GetMessageName() string {
+ return "vnet_udp_encap_counters"
+}
+func (*VnetUDPEncapCounters) GetCrcString() string {
+ return "1ab5e649"
+}
+func (*VnetUDPEncapCounters) GetMessageType() api.MessageType {
+ return api.OtherMessage
+}
+func NewVnetUDPEncapCounters() api.Message {
+ return &VnetUDPEncapCounters{}
+}
+
+/* Services */
+
+type Services interface {
+ StatsGetPollerDelay(*StatsGetPollerDelay) (*StatsGetPollerDelayReply, error)
+ VnetGetSummaryStats(*VnetGetSummaryStats) (*VnetGetSummaryStatsReply, error)
+ WantInterfaceCombinedStats(*WantInterfaceCombinedStats) (*WantInterfaceCombinedStatsReply, error)
+ WantInterfaceSimpleStats(*WantInterfaceSimpleStats) (*WantInterfaceSimpleStatsReply, error)
+ WantIP4FibStats(*WantIP4FibStats) (*WantIP4FibStatsReply, error)
+ WantIP4MfibStats(*WantIP4MfibStats) (*WantIP4MfibStatsReply, error)
+ WantIP4NbrStats(*WantIP4NbrStats) (*WantIP4NbrStatsReply, error)
+ WantIP6FibStats(*WantIP6FibStats) (*WantIP6FibStatsReply, error)
+ WantIP6MfibStats(*WantIP6MfibStats) (*WantIP6MfibStatsReply, error)
+ WantIP6NbrStats(*WantIP6NbrStats) (*WantIP6NbrStatsReply, error)
+ WantPerInterfaceCombinedStats(*WantPerInterfaceCombinedStats) (*WantPerInterfaceCombinedStatsReply, error)
+ WantPerInterfaceSimpleStats(*WantPerInterfaceSimpleStats) (*WantPerInterfaceSimpleStatsReply, error)
+ WantStats(*WantStats) (*WantStatsReply, error)
+ WantUDPEncapStats(*WantUDPEncapStats) (*WantUDPEncapStatsReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*WantStats)(nil), "stats.WantStats")
+ api.RegisterMessage((*WantStatsReply)(nil), "stats.WantStatsReply")
+ api.RegisterMessage((*WantInterfaceSimpleStats)(nil), "stats.WantInterfaceSimpleStats")
+ api.RegisterMessage((*WantInterfaceSimpleStatsReply)(nil), "stats.WantInterfaceSimpleStatsReply")
+ api.RegisterMessage((*WantPerInterfaceSimpleStats)(nil), "stats.WantPerInterfaceSimpleStats")
+ api.RegisterMessage((*WantPerInterfaceSimpleStatsReply)(nil), "stats.WantPerInterfaceSimpleStatsReply")
+ api.RegisterMessage((*WantInterfaceCombinedStats)(nil), "stats.WantInterfaceCombinedStats")
+ api.RegisterMessage((*WantInterfaceCombinedStatsReply)(nil), "stats.WantInterfaceCombinedStatsReply")
+ api.RegisterMessage((*WantPerInterfaceCombinedStats)(nil), "stats.WantPerInterfaceCombinedStats")
+ api.RegisterMessage((*WantPerInterfaceCombinedStatsReply)(nil), "stats.WantPerInterfaceCombinedStatsReply")
+ api.RegisterMessage((*WantIP4FibStats)(nil), "stats.WantIP4FibStats")
+ api.RegisterMessage((*WantIP4FibStatsReply)(nil), "stats.WantIP4FibStatsReply")
+ api.RegisterMessage((*WantIP6FibStats)(nil), "stats.WantIP6FibStats")
+ api.RegisterMessage((*WantIP6FibStatsReply)(nil), "stats.WantIP6FibStatsReply")
+ api.RegisterMessage((*WantIP4MfibStats)(nil), "stats.WantIP4MfibStats")
+ api.RegisterMessage((*WantIP4MfibStatsReply)(nil), "stats.WantIP4MfibStatsReply")
+ api.RegisterMessage((*WantIP6MfibStats)(nil), "stats.WantIP6MfibStats")
+ api.RegisterMessage((*WantIP6MfibStatsReply)(nil), "stats.WantIP6MfibStatsReply")
+ api.RegisterMessage((*WantIP4NbrStats)(nil), "stats.WantIP4NbrStats")
+ api.RegisterMessage((*WantIP4NbrStatsReply)(nil), "stats.WantIP4NbrStatsReply")
+ api.RegisterMessage((*WantIP6NbrStats)(nil), "stats.WantIP6NbrStats")
+ api.RegisterMessage((*WantIP6NbrStatsReply)(nil), "stats.WantIP6NbrStatsReply")
+ api.RegisterMessage((*VnetIP4FibCounters)(nil), "stats.VnetIP4FibCounters")
+ api.RegisterMessage((*VnetIP4MfibCounters)(nil), "stats.VnetIP4MfibCounters")
+ api.RegisterMessage((*VnetIP4NbrCounters)(nil), "stats.VnetIP4NbrCounters")
+ api.RegisterMessage((*VnetIP6FibCounters)(nil), "stats.VnetIP6FibCounters")
+ api.RegisterMessage((*VnetIP6MfibCounters)(nil), "stats.VnetIP6MfibCounters")
+ api.RegisterMessage((*VnetIP6NbrCounters)(nil), "stats.VnetIP6NbrCounters")
+ api.RegisterMessage((*VnetInterfaceSimpleCounters)(nil), "stats.VnetInterfaceSimpleCounters")
+ api.RegisterMessage((*VnetInterfaceCombinedCounters)(nil), "stats.VnetInterfaceCombinedCounters")
+ api.RegisterMessage((*VnetPerInterfaceSimpleCounters)(nil), "stats.VnetPerInterfaceSimpleCounters")
+ api.RegisterMessage((*VnetPerInterfaceCombinedCounters)(nil), "stats.VnetPerInterfaceCombinedCounters")
+ api.RegisterMessage((*VnetGetSummaryStats)(nil), "stats.VnetGetSummaryStats")
+ api.RegisterMessage((*VnetGetSummaryStatsReply)(nil), "stats.VnetGetSummaryStatsReply")
+ api.RegisterMessage((*StatsGetPollerDelay)(nil), "stats.StatsGetPollerDelay")
+ api.RegisterMessage((*StatsGetPollerDelayReply)(nil), "stats.StatsGetPollerDelayReply")
+ api.RegisterMessage((*WantUDPEncapStats)(nil), "stats.WantUDPEncapStats")
+ api.RegisterMessage((*WantUDPEncapStatsReply)(nil), "stats.WantUDPEncapStatsReply")
+ api.RegisterMessage((*VnetUDPEncapCounters)(nil), "stats.VnetUDPEncapCounters")
+}
{
- "services": [
- {
- "sw_interface_tap_dump": {
- "reply": "sw_interface_tap_details",
- "stream": true
- }
- },
- {
- "tap_connect": {
- "reply": "tap_connect_reply"
- }
- },
- {
- "tap_modify": {
- "reply": "tap_modify_reply"
- }
- },
- {
- "tap_delete": {
- "reply": "tap_delete_reply"
- }
- }
- ],
- "vl_api_version": "0x3a0725de",
- "enums": [],
"messages": [
[
"tap_connect",
}
]
],
+ "vl_api_version": "0xacec1ba1",
+ "unions": [],
+ "services": {
+ "tap_delete": {
+ "reply": "tap_delete_reply"
+ },
+ "sw_interface_tap_dump": {
+ "reply": "sw_interface_tap_details",
+ "stream": true
+ },
+ "tap_modify": {
+ "reply": "tap_modify_reply"
+ },
+ "tap_connect": {
+ "reply": "tap_connect_reply"
+ }
+ },
+ "enums": [],
"types": []
}
-// Code generated by govpp binapi-generator DO NOT EDIT.
-// Package tap represents the VPP binary API of the 'tap' VPP module.
-// Generated from '../../bin_api/tap.api.json'
+// Code generated by GoVPP binapi-generator. DO NOT EDIT.
+// source: tap.api.json
+
+/*
+Package tap is a generated VPP binary API of the 'tap' VPP module.
+
+It is generated from this file:
+ tap.api.json
+
+It contains these VPP binary API objects:
+ 8 messages
+ 4 services
+*/
package tap
import "git.fd.io/govpp.git/api"
+import "github.com/lunixbochs/struc"
+import "bytes"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = struc.Pack
+var _ = bytes.NewBuffer
-// VlApiVersion contains version of the API.
-const VlAPIVersion = 0x3a0725de
+/* Messages */
// TapConnect represents the VPP binary API message 'tap_connect'.
-// Generated from '../../bin_api/tap.api.json', line 29:
+// Generated from 'tap.api.json', line 4:
//
// "tap_connect",
// [
func (*TapConnect) GetMessageName() string {
return "tap_connect"
}
-func (*TapConnect) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*TapConnect) GetCrcString() string {
return "9b9c396f"
}
+func (*TapConnect) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewTapConnect() api.Message {
return &TapConnect{}
}
// TapConnectReply represents the VPP binary API message 'tap_connect_reply'.
-// Generated from '../../bin_api/tap.api.json', line 100:
+// Generated from 'tap.api.json', line 75:
//
// "tap_connect_reply",
// [
func (*TapConnectReply) GetMessageName() string {
return "tap_connect_reply"
}
-func (*TapConnectReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*TapConnectReply) GetCrcString() string {
return "fda5941f"
}
+func (*TapConnectReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewTapConnectReply() api.Message {
return &TapConnectReply{}
}
// TapModify represents the VPP binary API message 'tap_modify'.
-// Generated from '../../bin_api/tap.api.json', line 122:
+// Generated from 'tap.api.json', line 97:
//
// "tap_modify",
// [
func (*TapModify) GetMessageName() string {
return "tap_modify"
}
-func (*TapModify) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*TapModify) GetCrcString() string {
return "8047ae5c"
}
+func (*TapModify) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewTapModify() api.Message {
return &TapModify{}
}
// TapModifyReply represents the VPP binary API message 'tap_modify_reply'.
-// Generated from '../../bin_api/tap.api.json', line 166:
+// Generated from 'tap.api.json', line 141:
//
// "tap_modify_reply",
// [
func (*TapModifyReply) GetMessageName() string {
return "tap_modify_reply"
}
-func (*TapModifyReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*TapModifyReply) GetCrcString() string {
return "fda5941f"
}
+func (*TapModifyReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewTapModifyReply() api.Message {
return &TapModifyReply{}
}
// TapDelete represents the VPP binary API message 'tap_delete'.
-// Generated from '../../bin_api/tap.api.json', line 188:
+// Generated from 'tap.api.json', line 163:
//
// "tap_delete",
// [
func (*TapDelete) GetMessageName() string {
return "tap_delete"
}
-func (*TapDelete) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*TapDelete) GetCrcString() string {
return "529cb13f"
}
+func (*TapDelete) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewTapDelete() api.Message {
return &TapDelete{}
}
// TapDeleteReply represents the VPP binary API message 'tap_delete_reply'.
-// Generated from '../../bin_api/tap.api.json', line 210:
+// Generated from 'tap.api.json', line 185:
//
// "tap_delete_reply",
// [
func (*TapDeleteReply) GetMessageName() string {
return "tap_delete_reply"
}
-func (*TapDeleteReply) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*TapDeleteReply) GetCrcString() string {
return "e8d4e804"
}
+func (*TapDeleteReply) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewTapDeleteReply() api.Message {
return &TapDeleteReply{}
}
// SwInterfaceTapDump represents the VPP binary API message 'sw_interface_tap_dump'.
-// Generated from '../../bin_api/tap.api.json', line 228:
+// Generated from 'tap.api.json', line 203:
//
// "sw_interface_tap_dump",
// [
// "crc": "0x51077d14"
// }
//
-type SwInterfaceTapDump struct {
-}
+type SwInterfaceTapDump struct{}
func (*SwInterfaceTapDump) GetMessageName() string {
return "sw_interface_tap_dump"
}
-func (*SwInterfaceTapDump) GetMessageType() api.MessageType {
- return api.RequestMessage
-}
func (*SwInterfaceTapDump) GetCrcString() string {
return "51077d14"
}
+func (*SwInterfaceTapDump) GetMessageType() api.MessageType {
+ return api.RequestMessage
+}
func NewSwInterfaceTapDump() api.Message {
return &SwInterfaceTapDump{}
}
// SwInterfaceTapDetails represents the VPP binary API message 'sw_interface_tap_details'.
-// Generated from '../../bin_api/tap.api.json', line 246:
+// Generated from 'tap.api.json', line 221:
//
// "sw_interface_tap_details",
// [
func (*SwInterfaceTapDetails) GetMessageName() string {
return "sw_interface_tap_details"
}
-func (*SwInterfaceTapDetails) GetMessageType() api.MessageType {
- return api.ReplyMessage
-}
func (*SwInterfaceTapDetails) GetCrcString() string {
return "76229a57"
}
+func (*SwInterfaceTapDetails) GetMessageType() api.MessageType {
+ return api.ReplyMessage
+}
func NewSwInterfaceTapDetails() api.Message {
return &SwInterfaceTapDetails{}
}
+
+/* Services */
+
+type Services interface {
+ DumpSwInterfaceTap(*SwInterfaceTapDump) (*SwInterfaceTapDetails, error)
+ TapConnect(*TapConnect) (*TapConnectReply, error)
+ TapDelete(*TapDelete) (*TapDeleteReply, error)
+ TapModify(*TapModify) (*TapModifyReply, error)
+}
+
+func init() {
+ api.RegisterMessage((*TapConnect)(nil), "tap.TapConnect")
+ api.RegisterMessage((*TapConnectReply)(nil), "tap.TapConnectReply")
+ api.RegisterMessage((*TapModify)(nil), "tap.TapModify")
+ api.RegisterMessage((*TapModifyReply)(nil), "tap.TapModifyReply")
+ api.RegisterMessage((*TapDelete)(nil), "tap.TapDelete")
+ api.RegisterMessage((*TapDeleteReply)(nil), "tap.TapDeleteReply")
+ api.RegisterMessage((*SwInterfaceTapDump)(nil), "tap.SwInterfaceTapDump")
+ api.RegisterMessage((*SwInterfaceTapDetails)(nil), "tap.SwInterfaceTapDetails")
+}
// See the License for the specific language governing permissions and
// limitations under the License.
-// Binary simple-client is an example VPP management application that exercises the
+// simple-client is an example VPP management application that exercises the
// govpp API on real-world use-cases.
package main
-// Generates Go bindings for all VPP APIs located in the json directory.
-//go:generate binapi-generator --input-dir=../../bin_api --output-dir=../../bin_api
-
import (
"fmt"
"net"
"os"
+ "strings"
"git.fd.io/govpp.git"
"git.fd.io/govpp.git/api"
"git.fd.io/govpp.git/examples/bin_api/acl"
"git.fd.io/govpp.git/examples/bin_api/interfaces"
- "git.fd.io/govpp.git/examples/bin_api/tap"
+ "git.fd.io/govpp.git/examples/bin_api/ip"
)
func main() {
}
defer ch.Close()
- // check whether the VPP supports our version of some messages
- compatibilityCheck(ch)
-
// individual examples
aclVersion(ch)
aclConfig(ch)
aclDump(ch)
- tapConnect(ch)
-
interfaceDump(ch)
- interfaceNotifications(ch)
-}
+ ipAddressDump(ch)
-// compatibilityCheck shows how an management application can check whether generated API messages are
-// compatible with the version of VPP which the library is connected to.
-func compatibilityCheck(ch api.Channel) {
- err := ch.CheckMessageCompatibility(
- &interfaces.SwInterfaceDump{},
- &interfaces.SwInterfaceDetails{},
- )
- if err != nil {
- fmt.Println(err)
- os.Exit(1)
- }
+ setIpUnnumbered(ch)
+ ipUnnumberedDump(ch)
+
+ interfaceNotifications(ch)
}
// aclVersion is the simplest API example - one empty request message and one reply message.
if err != nil {
fmt.Println("Error:", err)
- } else {
- fmt.Printf("%+v\n", reply)
+ return
}
+ if reply.Retval != 0 {
+ fmt.Println("Retval:", reply.Retval)
+ return
+ }
+
+ fmt.Printf("%+v\n", reply)
+
}
// aclDump shows an example where SendRequest and ReceiveReply are not chained together.
req := &acl.ACLDump{}
reply := &acl.ACLDetails{}
- reqCtx := ch.SendRequest(req)
- err := reqCtx.ReceiveReply(reply)
-
- if err != nil {
+ if err := ch.SendRequest(req).ReceiveReply(reply); err != nil {
fmt.Println("Error:", err)
} else {
fmt.Printf("%+v\n", reply)
}
}
-// tapConnect example shows how the Go channels in the API channel can be accessed directly instead
-// of using SendRequest and ReceiveReply wrappers.
-func tapConnect(ch api.Channel) {
- req := &tap.TapConnect{
- TapName: []byte("testtap"),
- UseRandomMac: 1,
+// interfaceDump shows an example of multipart request (multiple replies are expected).
+func interfaceDump(ch api.Channel) {
+ fmt.Println("Dumping interfaces")
+
+ req := &interfaces.SwInterfaceDump{}
+ reqCtx := ch.SendMultiRequest(req)
+
+ for {
+ msg := &interfaces.SwInterfaceDetails{}
+ stop, err := reqCtx.ReceiveReply(msg)
+ if stop {
+ break // break out of the loop
+ }
+ if err != nil {
+ fmt.Println("ERROR:", err)
+ }
+ ifaceName := strings.TrimFunc(string(msg.InterfaceName), func(r rune) bool {
+ return r == 0x00
+ })
+ fmt.Printf("Interface: %q %+v\n", ifaceName, msg)
}
+}
- // send the request to the request go channel
- ch.GetRequestChannel() <- &api.VppRequest{Message: req}
+func ipAddressDump(ch api.Channel) {
+ fmt.Println("Dumping IP addresses")
- // receive a reply from the reply go channel
- vppReply := <-ch.GetReplyChannel()
- if vppReply.Error != nil {
- fmt.Println("Error:", vppReply.Error)
- return
+ req := &ip.IPAddressDump{
+ SwIfIndex: 1, //^uint32(0),
}
+ reqCtx := ch.SendMultiRequest(req)
- // decode the message
- reply := &tap.TapConnectReply{}
- err := ch.GetMessageDecoder().DecodeMsg(vppReply.Data, reply)
+ for {
+ msg := &ip.IPAddressDetails{}
+ stop, err := reqCtx.ReceiveReply(msg)
+ if stop {
+ break // break out of the loop
+ }
+ if err != nil {
+ fmt.Println("ERROR:", err)
+ }
+ fmt.Printf("ip address: %d %+v\n", msg.SwIfIndex, msg)
+ }
+}
- if err != nil {
+// aclDump shows an example where SendRequest and ReceiveReply are not chained together.
+func setIpUnnumbered(ch api.Channel) {
+ req := &interfaces.SwInterfaceSetUnnumbered{
+ SwIfIndex: 1,
+ UnnumberedSwIfIndex: 2,
+ IsAdd: 1,
+ }
+ reply := &interfaces.SwInterfaceSetUnnumberedReply{}
+
+ if err := ch.SendRequest(req).ReceiveReply(reply); err != nil {
fmt.Println("Error:", err)
} else {
fmt.Printf("%+v\n", reply)
}
}
-// interfaceDump shows an example of multipart request (multiple replies are expected).
-func interfaceDump(ch api.Channel) {
- req := &interfaces.SwInterfaceDump{}
+func ipUnnumberedDump(ch api.Channel) {
+ fmt.Println("Dumping IP unnumbered")
+
+ req := &ip.IPUnnumberedDump{
+ SwIfIndex: ^uint32(0),
+ }
reqCtx := ch.SendMultiRequest(req)
for {
- msg := &interfaces.SwInterfaceDetails{}
+ msg := &ip.IPUnnumberedDetails{}
stop, err := reqCtx.ReceiveReply(msg)
if stop {
break // break out of the loop
}
if err != nil {
- fmt.Println("Error:", err)
+ fmt.Println("ERROR:", err)
}
- fmt.Printf("%+v\n", msg)
+ fmt.Printf("ip unnumbered: %+v\n", msg)
}
}
func interfaceNotifications(ch api.Channel) {
// subscribe for specific notification message
notifChan := make(chan api.Message, 100)
- subs, _ := ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceSetFlags)
+ subs, err := ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceEvent)
+ if err != nil {
+ panic(err)
+ }
// enable interface events in VPP
- ch.SendRequest(&interfaces.WantInterfaceEvents{
- Pid: uint32(os.Getpid()),
+ err = ch.SendRequest(&interfaces.WantInterfaceEvents{
+ PID: uint32(os.Getpid()),
EnableDisable: 1,
}).ReceiveReply(&interfaces.WantInterfaceEventsReply{})
+ if err != nil {
+ panic(err)
+ }
// generate some events in VPP
- ch.SendRequest(&interfaces.SwInterfaceSetFlags{
+ err = ch.SendRequest(&interfaces.SwInterfaceSetFlags{
SwIfIndex: 0,
AdminUpDown: 0,
}).ReceiveReply(&interfaces.SwInterfaceSetFlagsReply{})
- ch.SendRequest(&interfaces.SwInterfaceSetFlags{
+ if err != nil {
+ panic(err)
+ }
+ err = ch.SendRequest(&interfaces.SwInterfaceSetFlags{
SwIfIndex: 0,
AdminUpDown: 1,
}).ReceiveReply(&interfaces.SwInterfaceSetFlagsReply{})
+ if err != nil {
+ panic(err)
+ }
// receive one notification
- notif := (<-notifChan).(*interfaces.SwInterfaceSetFlags)
- fmt.Printf("%+v\n", notif)
+ notif := (<-notifChan).(*interfaces.SwInterfaceEvent)
+ fmt.Printf("NOTIF: %+v\n", notif)
+
+ // disable interface events in VPP
+ err = ch.SendRequest(&interfaces.WantInterfaceEvents{
+ PID: uint32(os.Getpid()),
+ EnableDisable: 0,
+ }).ReceiveReply(&interfaces.WantInterfaceEventsReply{})
+ if err != nil {
+ panic(err)
+ }
// unsubscribe from delivery of the notifications
- ch.UnsubscribeNotification(subs)
+ err = ch.UnsubscribeNotification(subs)
+ if err != nil {
+ panic(err)
+ }
}
// govpp API for interface counters together with asynchronous connection to VPP.
package main
-// Generates Go bindings for all VPP APIs located in the json directory.
-//go:generate binapi-generator --input-dir=../../bin_api --output-dir=../../bin_api
-
import (
"fmt"
"os"
"git.fd.io/govpp.git"
"git.fd.io/govpp.git/api"
"git.fd.io/govpp.git/core"
- "git.fd.io/govpp.git/examples/bin_api/interfaces"
"git.fd.io/govpp.git/examples/bin_api/stats"
)
fmt.Println("Error:", err)
os.Exit(1)
}
+ defer fmt.Println("calling close")
defer ch.Close()
// create channel for Interrupt signal
case msg := <-notifChan:
switch notif := msg.(type) {
- case *interfaces.VnetInterfaceSimpleCounters:
+ case *stats.VnetInterfaceSimpleCounters:
// simple counter notification received
processSimpleCounters(notif)
- case *interfaces.VnetInterfaceCombinedCounters:
+ case *stats.VnetInterfaceCombinedCounters:
// combined counter notification received
processCombinedCounters(notif)
default:
// subscribeNotifications subscribes for interface counters notifications.
func subscribeNotifications(ch api.Channel) (*api.NotifSubscription, *api.NotifSubscription, chan api.Message) {
-
notifChan := make(chan api.Message, 100)
- simpleCountersSubs, _ := ch.SubscribeNotification(notifChan, interfaces.NewVnetInterfaceSimpleCounters)
- combinedCountersSubs, _ := ch.SubscribeNotification(notifChan, interfaces.NewVnetInterfaceCombinedCounters)
+
+ simpleCountersSubs, err := ch.SubscribeNotification(notifChan, stats.NewVnetInterfaceSimpleCounters)
+ if err != nil {
+ panic(err)
+ }
+ combinedCountersSubs, err := ch.SubscribeNotification(notifChan, stats.NewVnetInterfaceCombinedCounters)
+ if err != nil {
+ panic(err)
+ }
return simpleCountersSubs, combinedCountersSubs, notifChan
}
// requestStatistics requests interface counters notifications from VPP.
func requestStatistics(ch api.Channel) {
- ch.SendRequest(&stats.WantStats{
- Pid: uint32(os.Getpid()),
+ if err := ch.SendRequest(&stats.WantStats{
+ PID: uint32(os.Getpid()),
EnableDisable: 1,
- }).ReceiveReply(&stats.WantStatsReply{})
+ }).ReceiveReply(&stats.WantStatsReply{}); err != nil {
+ panic(err)
+ }
}
// processSimpleCounters processes simple counters received from VPP.
-func processSimpleCounters(counters *interfaces.VnetInterfaceSimpleCounters) {
- fmt.Printf("%+v\n", counters)
-
- counterNames := []string{"Drop", "Punt", "IPv4", "IPv6", "RxNoBuf", "RxMiss", "RxError", "TxError", "MPLS"}
+func processSimpleCounters(counters *stats.VnetInterfaceSimpleCounters) {
+ fmt.Printf("SimpleCounters: %+v\n", counters)
+
+ counterNames := []string{
+ "Drop", "Punt",
+ "IPv4", "IPv6",
+ "RxNoBuf", "RxMiss",
+ "RxError", "TxError",
+ "MPLS",
+ }
for i := uint32(0); i < counters.Count; i++ {
fmt.Printf("Interface '%d': %s = %d\n",
}
// processCombinedCounters processes combined counters received from VPP.
-func processCombinedCounters(counters *interfaces.VnetInterfaceCombinedCounters) {
- fmt.Printf("%+v\n", counters)
+func processCombinedCounters(counters *stats.VnetInterfaceCombinedCounters) {
+ fmt.Printf("CombinedCounters: %+v\n", counters)
counterNames := []string{"Rx", "Tx"}
for i := uint32(0); i < counters.Count; i++ {
+ if len(counterNames) <= int(counters.VnetCounterType) {
+ continue
+ }
fmt.Printf("Interface '%d': %s packets = %d, %s bytes = %d\n",
- counters.FirstSwIfIndex+i, counterNames[counters.VnetCounterType], counters.Data[i].Packets,
+ counters.FirstSwIfIndex+i,
+ counterNames[counters.VnetCounterType], counters.Data[i].Packets,
counterNames[counters.VnetCounterType], counters.Data[i].Bytes)
}
}
--- /dev/null
+// Copyright (c) 2018 Cisco and/or its affiliates.
+//
+// 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.
+
+// union-example is an example to show how to use unions in VPP binary API.
+package main
+
+import (
+ "bytes"
+ "log"
+
+ "git.fd.io/govpp.git/examples/bin_api/ip"
+ "github.com/lunixbochs/struc"
+)
+
+func main() {
+ // create union with IPv4 address
+ var unionIP4 ip.AddressUnion
+ unionIP4.SetIP4(ip.IP4Address{Address: []byte{192, 168, 1, 10}})
+
+ // use it in the Address type
+ addr := &ip.Address{
+ Af: ip.ADDRESS_IP4,
+ Un: unionIP4,
+ }
+ log.Printf("encoding union IPv4: %v", addr.Un.GetIP4())
+
+ // encode the address with union
+ data := encode(addr)
+ // decode the address with union
+ addr2 := decode(data)
+
+ log.Printf("decoded union IPv4: %v", addr2.Un.GetIP4())
+}
+
+func encode(addr *ip.Address) []byte {
+ log.Printf("encoding address: %#v", addr)
+ buf := new(bytes.Buffer)
+ if err := struc.Pack(buf, addr); err != nil {
+ panic(err)
+ }
+ return buf.Bytes()
+}
+
+func decode(data []byte) *ip.Address {
+ addr := new(ip.Address)
+ buf := bytes.NewReader(data)
+ if err := struc.Unpack(buf, addr); err != nil {
+ panic(err)
+ }
+ log.Printf("decoded address: %#v", addr)
+ return addr
+}
Code Review / govpp.git / commitdiff