twamp

package module
v0.0.0-...-c7d560e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 7, 2022 License: MIT Imports: 15 Imported by: 1

README

twamp

TWAMP client for go

Client Library Synopsis

	c := twamp.NewClient()
	connection, err := c.Connect("10.1.1.200:862")
	if err != nil {
		log.Fatal(err)
	}

	session, err := connection.CreateSession(
		twamp.TwampSessionConfig{
			ReceiverPort: 6666,
			SenderPort:   6666,
			Timeout:      1,
			Padding:      100,
			TOS:          twamp.EF,
			IPVersion:    4
		},
	)
	if err != nil {
		log.Fatal(err)
	}

	test, err := session.CreateTest()
	if err != nil {
		log.Fatal(err)
	}

	count := 2000
	results := test.RunX(count, func(result *twamp.TwampResults) {
		fmt.Printf("%.2f  \r", float64(result.SenderSeqNum)/float64(count)*100.0)
	})
	if err != nil {
		log.Fatal("%v", err)
	}

	log.Printf("Stat: %+v\n", *results.Stat)
	session.Stop()
	connection.Close()

TWAMP ping command line utility

CLI Usage Message
sigsegv:twamp tcaine$ ./twamp --help
Usage of ./twamp:
  -count int
    	Number of requests to send (1..2000000000 packets) (default 5)
  -interval int
    	Delay between TWAMP-test requests (seconds) (default 1)
  -mode string
    	Mode of operation (ping, json) (default "ping")
  -port int
    	UDP port to send request packets (default 6666)
  -rapid
    	Send requests rapidly (default count of 5)
  -size int
    	Size of request packets (0..65468 bytes) (default 42)
  -tos int
    	IP type-of-service value (0..255)
  -wait int
    	Maximum wait time after sending final packet (seconds) (default 1)
Twamp Ping
sigsegv:twamp tcaine$ ./twamp 10.1.1.200
TWAMP PING 10.1.1.200: 56 data bytes
56 bytes from 10.1.1.200: twamp_seq=0 ttl=250 time=45.252 ms
56 bytes from 10.1.1.200: twamp_seq=1 ttl=250 time=484.722 ms
56 bytes from 10.1.1.200: twamp_seq=2 ttl=250 time=134.527 ms
56 bytes from 10.1.1.200: twamp_seq=3 ttl=250 time=41.005 ms
56 bytes from 10.1.1.200: twamp_seq=4 ttl=250 time=46.791 ms
--- 10.1.1.200 twamp ping statistics ---
5 packets transmitted, 5 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 41.005/150.459/484.722/190.907 ms
Twamp Rapid Ping
sigsegv:twamp tcaine$ ./twamp --count=100 --rapid 10.1.1.200 
TWAMP PING 10.1.1.200: 56 data bytes
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
--- 10.1.1.200 twamp ping statistics ---
100 packets transmitted, 100 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 27.456/81.008/924.369/115.346 ms
Twamp Ping JSON
sigsegv:twamp tcaine$ ./twamp --count=5 --mode=json 10.1.1.200 | json_pp
{
   "stats" : {
      "tx" : 5,
      "stddev" : 61171928,
      "rx" : 5,
      "avg" : 104719892,
      "min" : 29052824,
      "loss" : 0,
      "max" : 155204310
   },
   "results" : [
      {
         "senderTimestamp" : "2016-12-12T21:12:13.475143032-08:00",
         "finishedTimestamp" : "2016-12-12T21:12:13.523426063-08:00",
         "seqnum" : 0,
         "receiveTimestamp" : "2016-12-12T21:12:14.982226191-08:00",
         "senderTTL" : 250,
         "errorEstimate" : 1,
         "timestamp" : "2016-12-12T21:12:14.982780242-08:00",
         "senderSeqnum" : 0,
         "senderErrorEstimate" : 257,
         "senderSize" : 56
      },
      {
         "senderTimestamp" : "2016-12-12T21:12:13.523434427-08:00",
         "finishedTimestamp" : "2016-12-12T21:12:13.678393972-08:00",
         "seqnum" : 1,
         "receiveTimestamp" : "2016-12-12T21:12:15.662510356-08:00",
         "senderTTL" : 250,
         "errorEstimate" : 1,
         "timestamp" : "2016-12-12T21:12:15.662776644-08:00",
         "senderSeqnum" : 1,
         "senderErrorEstimate" : 257,
         "senderSize" : 56
      },
      {
         "senderTimestamp" : "2016-12-12T21:12:13.678401499-08:00",
         "finishedTimestamp" : "2016-12-12T21:12:13.833605809-08:00",
         "seqnum" : 2,
         "receiveTimestamp" : "2016-12-12T21:12:15.774115081-08:00",
         "senderTTL" : 250,
         "errorEstimate" : 1,
         "timestamp" : "2016-12-12T21:12:15.774321239-08:00",
         "senderSeqnum" : 2,
         "senderErrorEstimate" : 257,
         "senderSize" : 56
      },
      {
         "senderTimestamp" : "2016-12-12T21:12:13.833613447-08:00",
         "finishedTimestamp" : "2016-12-12T21:12:13.862666271-08:00",
         "seqnum" : 3,
         "receiveTimestamp" : "2016-12-12T21:12:16.454055649-08:00",
         "senderTTL" : 250,
         "errorEstimate" : 1,
         "timestamp" : "2016-12-12T21:12:16.454300462-08:00",
         "senderSeqnum" : 3,
         "senderErrorEstimate" : 257,
         "senderSize" : 56
      },
      {
         "senderTimestamp" : "2016-12-12T21:12:13.862672913-08:00",
         "finishedTimestamp" : "2016-12-12T21:12:13.998772663-08:00",
         "seqnum" : 4,
         "receiveTimestamp" : "2016-12-12T21:12:16.580967637-08:00",
         "senderTTL" : 250,
         "errorEstimate" : 1,
         "timestamp" : "2016-12-12T21:12:16.581173796-08:00",
         "senderSeqnum" : 4,
         "senderErrorEstimate" : 257,
         "senderSize" : 56
      }
   ]
}
sigsegv:twamp tcaine$

Documentation

Index

Constants

View Source 
const (
	ModeUnspecified     = 0
	ModeUnauthenticated = 1
	ModeAuthenticated   = 2
	ModeEncypted        = 4
)

Security modes for TWAMP session.

View Source 
const (
	OK                          = 0
	Failed                      = 1
	InternalError               = 2
	NotSupported                = 3
	PermanentResourceLimitation = 4
	TemporaryResourceLimitation = 5
)

TWAMP Accept Field Status Code

View Source 
const (
	BE   = 0x00
	CS1  = 0x20
	AF11 = 0x28
	AF12 = 0x30
	AF13 = 0x38
	CS2  = 0x40
	AF21 = 0x48
	AF22 = 0x50
	AF23 = 0x58
	CS3  = 0x60
	AF31 = 0x68
	AF32 = 0x70
	AF33 = 0x78
	CS4  = 0x80
	AF41 = 0x88
	AF42 = 0x90
	AF43 = 0x98
	CS5  = 0xA0
	EF   = 0xB8
	CS6  = 0xC0
	CS7  = 0xE0
)
View Source 
const TwampControlPort int = 862

Default TCP port for remote TWAMP server.

Variables

This section is empty.

Functions

func NewTimestamp 

func NewTimestamp(twampTimestamp TwampTimestamp) time.Time

Types

type MeasurementPacket 

type MeasurementPacket struct {
	Sequence            uint32
	Timestamp           TwampTimestamp
	ErrorEstimate       uint16
	MBZ                 uint16
	ReceiveTimeStamp    TwampTimestamp
	SenderSequence      uint32
	SenderTimeStamp     TwampTimestamp
	SenderErrorEstimate uint16
	Mbz                 uint16
	SenderTtl           byte
}

type PingResultStats 

type PingResultStats struct {
	Min         time.Duration `json:"min"`
	Max         time.Duration `json:"max"`
	Avg         time.Duration `json:"avg"`
	StdDev      time.Duration `json:"stddev"`
	Transmitted int           `json:"tx"`
	Received    int           `json:"rx"`
	Loss        float64       `json:"loss"`
}

type PingResults 

type PingResults struct {
	Results []*TwampResults  `json:"results"`
	Stat    *PingResultStats `json:"stats"`
}

type RequestTwSession 

type RequestTwSession []byte

func (RequestTwSession) Encode 

func (b RequestTwSession) Encode(c TwampSessionConfig)

type TwampAcceptSession 

type TwampAcceptSession struct {
	// contains filtered or unexported fields
}

func NewTwampAcceptSession 

func NewTwampAcceptSession(buf bytes.Buffer) *TwampAcceptSession

type TwampClient 

type TwampClient struct{}

func NewClient 

func NewClient() *TwampClient

func (*TwampClient) Connect 

func (c *TwampClient) Connect(hostname string) (*TwampConnection, error)

type TwampClientSetUpResponse 

type TwampClientSetUpResponse struct {
	Mode     uint32
	KeyID    [80]byte
	Token    [64]byte
	ClientIV [16]byte
}

TWAMP client session negotiation message.

type TwampConnection 

type TwampConnection struct {
	// contains filtered or unexported fields
}

func NewTwampConnection 

func NewTwampConnection(conn net.Conn) *TwampConnection

func (*TwampConnection) Close 

func (c *TwampConnection) Close()

func (*TwampConnection) CreateSession 

func (c *TwampConnection) CreateSession(config TwampSessionConfig) (*TwampSession, error)

func (*TwampConnection) GetConnection 

func (c *TwampConnection) GetConnection() net.Conn

func (*TwampConnection) LocalAddr 

func (c *TwampConnection) LocalAddr() net.Addr

func (*TwampConnection) RemoteAddr 

func (c *TwampConnection) RemoteAddr() net.Addr

type TwampResults 

type TwampResults struct {
	SeqNum              uint32    `json:"seqnum"`
	Timestamp           time.Time `json:"timestamp"`
	ErrorEstimate       uint16    `json:"errorEstimate"`
	ReceiveTimestamp    time.Time `json:"receiveTimestamp"`
	SenderSeqNum        uint32    `json:"senderSeqnum"`
	SenderTimestamp     time.Time `json:"senderTimestamp"`
	SenderErrorEstimate uint16    `json:"senderErrorEstimate"`
	SenderTTL           byte      `json:"senderTTL"`
	FinishedTimestamp   time.Time `json:"finishedTimestamp"`
	SenderSize          int       `json:"senderSize"`
}

TWAMP test result timestamps have been normalized to UNIX epoch time.

func (*TwampResults) GetRTT 

func (r *TwampResults) GetRTT() time.Duration

func (*TwampResults) GetWait 

func (r *TwampResults) GetWait() time.Duration

func (*TwampResults) PrintResults 

func (r *TwampResults) PrintResults()

type TwampServerGreeting 

type TwampServerGreeting struct {
	Mode      uint32   // modes (4 bytes)
	Challenge [16]byte // challenge (16 bytes)
	Salt      [16]byte // salt (16 bytes)
	Count     uint32   // count (4 bytes)
}

TWAMP server greeting message.

type TwampServerStart 

type TwampServerStart struct {
	Accept    byte
	ServerIV  [16]byte
	StartTime TwampTimestamp
}

type TwampSession 

type TwampSession struct {
	// contains filtered or unexported fields
}

func (*TwampSession) CreateTest 

func (s *TwampSession) CreateTest() (*TwampTest, error)

func (*TwampSession) GetConfig 

func (s *TwampSession) GetConfig() TwampSessionConfig

func (*TwampSession) GetConnection 

func (s *TwampSession) GetConnection() net.Conn

func (*TwampSession) Stop 

func (s *TwampSession) Stop()

func (*TwampSession) Write 

func (s *TwampSession) Write(buf []byte)

type TwampSessionConfig 

type TwampSessionConfig struct {
	// According to RFC 4656, if Conf-Receiver is not set, Receiver Port
	// is the UDP port OWAMP-Test to which packets are
	// requested to be sent.
	ReceiverPort int
	// According to RFC 4656, if Conf-Sender is not set, Sender Port is the
	// UDP port from which OWAMP-Test packets will be sent.
	SenderPort int
	// According to RFC 4656, Padding length is the number of octets to be
	// appended to the normal OWAMP-Test packet (see more on
	// padding in discussion of OWAMP-Test).
	Padding int
	// According to RFC 4656, Timeout (or a loss threshold) is an interval of time
	// (expressed as a timestamp). A packet belonging to the test session
	// that is being set up by the current Request-Session command will
	// be considered lost if it is not received during Timeout seconds
	// after it is sent.
	Timeout   int
	TOS       int
	IPVersion int
}

type TwampTest 

type TwampTest struct {
	// contains filtered or unexported fields
}

TWAMP test connection used for running TWAMP tests.

func (*TwampTest) FormatJSON 

func (t *TwampTest) FormatJSON(r *PingResults)

func (*TwampTest) GetConnection 

func (t *TwampTest) GetConnection() *net.UDPConn

Get TWAMP Test UDP connection.

func (*TwampTest) GetLocalTestHost 

func (t *TwampTest) GetLocalTestHost() string

Get the local IP address for the TWAMP control session.

func (*TwampTest) GetRemoteTestHost 

func (t *TwampTest) GetRemoteTestHost() string

Get the remote IP address for the TWAMP control session.

func (*TwampTest) GetRemoteTestPort 

func (t *TwampTest) GetRemoteTestPort() uint16

Get the remote TWAMP UDP port number.

func (*TwampTest) GetSession 

func (t *TwampTest) GetSession() *TwampSession

Get the underlying TWAMP control session for the TWAMP test.

func (*TwampTest) LocalAddr 

func (t *TwampTest) LocalAddr() (*net.UDPAddr, error)

Get the local TWAMP IP/UDP address.

func (*TwampTest) Ping 

func (t *TwampTest) Ping(count int, isRapid bool, interval int) *PingResults

func (*TwampTest) RemoteAddr 

func (t *TwampTest) RemoteAddr() (*net.UDPAddr, error)

Get the remote TWAMP IP/UDP address.

func (*TwampTest) ReturnJSON 

func (t *TwampTest) ReturnJSON(r *PingResults) string

func (*TwampTest) Run 

func (t *TwampTest) Run() (*TwampResults, error)

Run a TWAMP test and return a pointer to the TwampResults.

func (*TwampTest) RunX 

func (t *TwampTest) RunX(count int, callback TwampTestCallbackFunction) *PingResults

func (*TwampTest) SetConnection 

func (t *TwampTest) SetConnection(conn *net.UDPConn)

type TwampTestCallbackFunction 

type TwampTestCallbackFunction func(result *TwampResults)

Function header called when a test package arrived back. Can be used to show some progress

type TwampTimestamp 

type TwampTimestamp struct {
	Integer  uint32
	Fraction uint32
}

func NewTwampTimestamp 

func NewTwampTimestamp(t time.Time) *TwampTimestamp

Converts a UNIX epoch time time.Time object into an RFC 1305 compliant time.

func (*TwampTimestamp) GetTime 

func (t *TwampTimestamp) GetTime() time.Time

Return a time.Time object representing Unix Epoch time since January 1st, 1970.

func (*TwampTimestamp) String 

func (t *TwampTimestamp) String() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.