packet

Documentation

Overview

Package packet provides network messaging protocol and serialization layer.

Packet can be created with shortcut:

senderAddr, _ := host.NewAddress("127.0.0.1:1337")
receiverAddr, _ := host.NewAddress("127.0.0.1:1338")

sender := host.NewHost(senderAddr)
receiver := host.NewHost(receiverAddr)

msg := packet.NewPingPacket(sender, receiver)

// do something with packet

Or with builder:

builder := packet.NewBuilder()

senderAddr, _ := host.NewAddress("127.0.0.1:1337")
receiverAddr, _ := host.NewAddress("127.0.0.1:1338")

sender := host.NewHost(senderAddr)
receiver := host.NewHost(receiverAddr)

msg := builder.
	Sender(sender).
	Receiver(receiver).
	Type(packet.TypeFindHost).
	Request(&packet.RequestDataFindHost{}).
	Build()

// do something with packet

Packet may be serialized:

msg := &packet.Packet{}
serialized, err := packet.SerializePacket(msg)

if err != nil {
	panic(err.Error())
}

fmt.Println(serialized)

And deserialized therefore:

var buffer bytes.Buffer

// Fill buffer somewhere

msg, err := packet.DeserializePacket(buffer)

if err != nil {
	panic(err.Error())
}

// do something with packet

Index

• Constants
• func SerializePacket(q *Packet) ([]byte, error)
• type Builder
  • func NewBuilder() Builder
  • func (cb Builder) Build() (packet *Packet)
  • func (cb Builder) Error(err error) Builder
  • func (cb Builder) Receiver(host *host.Host) Builder
  • func (cb Builder) Request(request interface{}) Builder
  • func (cb Builder) Response(response interface{}) Builder
  • func (cb Builder) Sender(host *host.Host) Builder
  • func (cb Builder) Type(packetType packetType) Builder
• type CommandType
• type Packet
  • func DeserializePacket(conn io.Reader) (*Packet, error)
  • func NewAuthPacket(command CommandType, sender, receiver *host.Host) *Packet
  • func NewCheckOriginPacket(sender, receiver *host.Host) *Packet
  • func NewKnownOuterHostsPacket(sender, receiver *host.Host, hosts int) *Packet
  • func NewObtainIPPacket(sender, receiver *host.Host) *Packet
  • func NewPingPacket(sender, receiver *host.Host) *Packet
  • func NewRelayOwnershipPacket(sender, receiver *host.Host, ready bool) *Packet
  • func NewRelayPacket(command CommandType, sender, receiver *host.Host) *Packet
  • func (m *Packet) IsForMe(origin host.Origin) bool
  • func (m *Packet) IsValid() (valid bool)
• type RequestAuth
• type RequestCheckOrigin
• type RequestDataFindHost
• type RequestDataFindValue
• type RequestDataRPC
• type RequestDataStore
• type RequestID
• type RequestKnownOuterHosts
• type RequestObtainIP
• type RequestRelay
• type RequestRelayOwnership
• type ResponseAuth
• type ResponseCheckOrigin
• type ResponseDataFindHost
• type ResponseDataFindValue
• type ResponseDataRPC
• type ResponseDataStore
• type ResponseKnownOuterHosts
• type ResponseObtainIP
• type ResponseRelay
• type ResponseRelayOwnership

Constants

const (
	// TypePing is packet type for ping method.
	TypePing = packetType(iota + 1)
	// TypeStore is packet type for store method.
	TypeStore
	// TypeFindHost is packet type for FindHost method.
	TypeFindHost
	// TypeFindValue is packet type for FindValue method.
	TypeFindValue
	// TypeRPC is packet type for RPC method.
	TypeRPC
	// TypeRelay is packet type for request target to be a relay.
	TypeRelay
	// TypeAuth is packet type for authentication between hosts.
	TypeAuth
	// TypeCheckOrigin is packet to check originality of some host.
	TypeCheckOrigin
	// TypeObtainIP is packet to get itself IP from another host.
	TypeObtainIP
	// TypeRelayOwnership is packet to say all other hosts that current host have a static IP.
	TypeRelayOwnership
	// TypeKnownOuterHosts is packet to say how much outer hosts current host know.
	TypeKnownOuterHosts
)

const (
	// Unknown - unknown command.
	Unknown = CommandType(iota + 1)
	// StartRelay - command start relay.
	StartRelay
	// StopRelay - command stop relay.
	StopRelay
	// BeginAuth - begin authentication.
	BeginAuth
	// RevokeAuth - revoke authentication.
	RevokeAuth
)

Functions

func SerializePacket

func SerializePacket(q *Packet) ([]byte, error)

SerializePacket converts packet to byte slice.

Types

type Builder

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

Builder allows lazy building of packets. Each operation returns new copy of a builder.

func NewBuilder

func NewBuilder() Builder

NewBuilder returns empty packet builder.

func (Builder) Build

func (cb Builder) Build() (packet *Packet)

Build returns configured packet.

func (Builder) Error

func (cb Builder) Error(err error) Builder

Error adds error description to packet.

func (Builder) Receiver

func (cb Builder) Receiver(host *host.Host) Builder

Receiver sets packet receiver.

func (Builder) Request

func (cb Builder) Request(request interface{}) Builder

Request adds request data to packet.

func (Builder) Response

func (cb Builder) Response(response interface{}) Builder

Response adds response data to packet

func (Builder) Sender

func (cb Builder) Sender(host *host.Host) Builder

Sender sets packet sender.

func (Builder) Type

func (cb Builder) Type(packetType packetType) Builder

Type sets packet type.

type CommandType

type CommandType int

CommandType - type for commands.

type Packet

type Packet struct {
	Sender        *host.Host
	Receiver      *host.Host
	Type          packetType
	RequestID     RequestID
	RemoteAddress string

	Data       interface{}
	Error      error
	IsResponse bool
}

Packet is DHT packet object.

func DeserializePacket

func DeserializePacket(conn io.Reader) (*Packet, error)

DeserializePacket reads packet from io.Reader.

func NewAuthPacket

func NewAuthPacket(command CommandType, sender, receiver *host.Host) *Packet

NewAuthPacket uses for starting authentication.

func NewCheckOriginPacket

func NewCheckOriginPacket(sender, receiver *host.Host) *Packet

NewCheckOriginPacket uses for check originality.

func NewKnownOuterHostsPacket

func NewKnownOuterHostsPacket(sender, receiver *host.Host, hosts int) *Packet

NewKnownOuterHostsPacket uses to notify all hosts in home subnet about known outer hosts.

func NewObtainIPPacket

func NewObtainIPPacket(sender, receiver *host.Host) *Packet

NewObtainIPPacket uses for get self IP.

func NewPingPacket

func NewPingPacket(sender, receiver *host.Host) *Packet

NewPingPacket can be used as a shortcut for creating ping packets instead of packet Builder.

func NewRelayOwnershipPacket

func NewRelayOwnershipPacket(sender, receiver *host.Host, ready bool) *Packet

NewRelayOwnershipPacket uses for relay ownership request.

func NewRelayPacket

func NewRelayPacket(command CommandType, sender, receiver *host.Host) *Packet

NewRelayPacket uses for send a command to target host to make it as relay.

func (*Packet) IsForMe

func (m *Packet) IsForMe(origin host.Origin) bool

IsForMe checks if packet is addressed to our host.

func (*Packet) IsValid

func (m *Packet) IsValid() (valid bool)

IsValid checks if packet data is a valid structure for current packet type.

type RequestAuth

type RequestAuth struct {
	Command CommandType
}

RequestAuth is data for authentication.

type RequestCheckOrigin

type RequestCheckOrigin struct {
}

RequestCheckOrigin is data to check originality.

type RequestDataFindHost

type RequestDataFindHost struct {
	Target []byte
}

RequestDataFindHost is data for FindHost request.

type RequestDataFindValue

type RequestDataFindValue struct {
	Target []byte
}

RequestDataFindValue is data for FindValue request.

type RequestDataRPC

type RequestDataRPC struct {
	Method string
	Args   [][]byte
}

RequestDataRPC is data for RPC request.

type RequestDataStore

type RequestDataStore struct {
	Data       []byte
	Publishing bool // Whether or not we are the original publisher.
}

RequestDataStore is data for Store request.

type RequestID

type RequestID uint64

RequestID is 64 bit unsigned int request id.

type RequestKnownOuterHosts

type RequestKnownOuterHosts struct {
	ID         string // origin ID
	OuterHosts int    // number of known outer hosts
}

RequestKnownOuterHosts is data to notify home subnet about known outer hosts.

type RequestObtainIP

type RequestObtainIP struct {
}

RequestObtainIP is data to obtain a self IP.

type RequestRelay

type RequestRelay struct {
	Command CommandType
}

RequestRelay is data for relay request (commands: start/stop relay).

type RequestRelayOwnership

type RequestRelayOwnership struct {
	Ready bool
}

RequestRelayOwnership is data to notify that current host can be a relay.

type ResponseAuth

type ResponseAuth struct {
	Success       bool
	AuthUniqueKey []byte
}

ResponseAuth is data for authentication request response.

type ResponseCheckOrigin

type ResponseCheckOrigin struct {
	AuthUniqueKey []byte
}

ResponseCheckOrigin is data for check originality request response.

type ResponseDataFindHost

type ResponseDataFindHost struct {
	Closest []*host.Host
}

ResponseDataFindHost is data for FindHost response.

type ResponseDataFindValue

type ResponseDataFindValue struct {
	Closest []*host.Host
	Value   []byte
}

ResponseDataFindValue is data for FindValue response.

type ResponseDataRPC

type ResponseDataRPC struct {
	Success bool
	Result  []byte
	Error   string
}

ResponseDataRPC is data for RPC response.

type ResponseDataStore

type ResponseDataStore struct {
	Success bool
}

ResponseDataStore is data for Store response.

type ResponseKnownOuterHosts

type ResponseKnownOuterHosts struct {
	ID         string //	id of host in which more known outer hosts
	OuterHosts int    // number of known outer hosts
}

ResponseKnownOuterHosts is data to answer if origin host know more outer hosts.

type ResponseObtainIP

type ResponseObtainIP struct {
	IP string
}

ResponseObtainIP is data for get a IP of requesting host.

type ResponseRelay

type ResponseRelay struct {
	State relay.State
}

ResponseRelay is data for relay request response.

type ResponseRelayOwnership

type ResponseRelayOwnership struct {
	Accepted bool
}

ResponseRelayOwnership is data to response to relay ownership request.