client: github.com/katzenpost/client Index | Files | Directories

package client

import "github.com/katzenpost/client"

Package client provides a Katzenpost client library.

Index

Package Files

client.go events.go message.go queue.go send.go session.go timer_queue.go worker.go

Variables

var ErrQueueEmpty = errors.New("queue is empty")

ErrQueueEmpty is the error issued when the queue is empty.

var ErrQueueFull = errors.New("queue is full")

ErrQueueFull is the error issued when the queue is full.

var ErrReplyTimeout = errors.New("failure waiting for reply, timeout reached")

func AutoRegisterRandomClient Uses

func AutoRegisterRandomClient(cfg *config.Config) (*config.Config, *ecdh.PrivateKey)

func RegisterClient Uses

func RegisterClient(cfg *config.Config, linkKey *ecdh.PublicKey) error

type Client Uses

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

Client handles sending and receiving messages over the mix network

func New Uses

func New(cfg *config.Config) (*Client, error)

New creates a new Client with the provided configuration.

func (*Client) GetBackendLog Uses

func (c *Client) GetBackendLog() *log.Backend

func (*Client) GetLogger Uses

func (c *Client) GetLogger(name string) *logging.Logger

GetLogger returns a new logger with the given name.

func (*Client) NewSession Uses

func (c *Client) NewSession(linkKey *ecdh.PrivateKey) (*Session, error)

NewSession creates and returns a new session or an error.

func (*Client) Provider Uses

func (c *Client) Provider() string

func (*Client) Shutdown Uses

func (c *Client) Shutdown()

Shutdown cleanly shuts down a given Client instance.

func (*Client) Wait Uses

func (c *Client) Wait()

Wait waits till the Client is terminated for any reason.

type ConnectionStatusEvent Uses

type ConnectionStatusEvent struct {
    // IsConnected is true iff the account is connected to the provider.
    IsConnected bool

    // Err is the error encountered when connecting or by the connection if any.
    Err error
}

ConnectionStatusEvent is the event sent when an account's connection status changes.

func (*ConnectionStatusEvent) String Uses

func (e *ConnectionStatusEvent) String() string

String returns a string representation of the ConnectionStatusEvent.

type EgressQueue Uses

type EgressQueue interface {

    // Peek returns the next queue item without modifying the queue.
    Peek() (Item, error)

    // Pop pops the next item off the queue.
    Pop() (Item, error)

    // Push pushes the item onto the queue.
    Push(Item) error
}

EgressQueue is the egress queue interface.

type Event Uses

type Event interface {
    // String returns a string representation of the Event.
    String() string
}

Event is the generic event sent over the event listener channel.

type Item Uses

type Item interface {
    Priority() uint64
}

type Message Uses

type Message struct {
    // ID is the message identifier
    ID  MessageID

    // Recipient is the message recipient
    Recipient string

    // Provider is the recipient Provider
    Provider string

    // Payload is the message payload
    Payload []byte

    // SentAt contains the time the message was sent.
    SentAt time.Time

    // ReplyETA is the expected round trip time to receive a response.
    ReplyETA time.Duration

    // IsBlocking indicates whether or not the client is blocking on the
    // sending of the query and the receiving of it's reply.
    IsBlocking bool

    // SURBID is the SURB identifier.
    SURBID *[sConstants.SURBIDLength]byte

    // Key is the SURB decryption keys
    Key []byte

    // Reply is the SURB reply
    Reply []byte

    // WithSURB specified if a SURB should be bundled with the forward payload.
    WithSURB bool

    // Specifies if this message is a decoy.
    IsDecoy bool

    // Priority controls the dwell time in the current AQM.
    QueuePriority uint64
}

Message is a message reference which is used to match future received SURB replies.

func (*Message) Priority Uses

func (m *Message) Priority() uint64

type MessageID Uses

type MessageID *[cConstants.MessageIDLength]byte

MessageID is a message identity byte array.

type MessageIDGarbageCollected Uses

type MessageIDGarbageCollected struct {
    // MessageID is the local unique identifier for the message.
    MessageID *[cConstants.MessageIDLength]byte
}

MessageIDGarbageCollected is the event used to signal when a given message ID has been garbage collected.

func (*MessageIDGarbageCollected) String Uses

func (e *MessageIDGarbageCollected) String() string

String returns a string representation of a MessageIDGarbageCollected.

type MessageReplyEvent Uses

type MessageReplyEvent struct {
    // MessageID is the unique identifier for the request associated with the
    // reply.
    MessageID *[cConstants.MessageIDLength]byte

    // Payload is the reply payload if any.
    Payload []byte

    // Err is the error encountered when servicing the request if any.
    Err error
}

MessageReplyEvent is the event sent when a new message is received.

func (*MessageReplyEvent) String Uses

func (e *MessageReplyEvent) String() string

String returns a string representation of the MessageReplyEvent.

type MessageSentEvent Uses

type MessageSentEvent struct {
    // MessageID is the local unique identifier for the message, generated
    // when the message was enqueued.
    MessageID *[cConstants.MessageIDLength]byte

    // SentAt contains the time the message was sent.
    SentAt time.Time

    // ReplyETA is the expected round trip time to receive a response.
    ReplyETA time.Duration

    // Err is the error encountered when sending the message if any.
    Err error
}

MessageSentEvent is the event sent when a message has been fully transmitted.

func (*MessageSentEvent) String Uses

func (e *MessageSentEvent) String() string

String returns a string representation of a MessageSentEvent.

type NewDocumentEvent Uses

type NewDocumentEvent struct {
    Document *pki.Document
}

NewDocumentEvent is the new document event, signaling that we have received a new document from the PKI.

func (*NewDocumentEvent) String Uses

func (e *NewDocumentEvent) String() string

String returns a string representation of a NewDocumentEvent.

type Queue Uses

type Queue struct {
    sync.Mutex
    // contains filtered or unexported fields
}

Queue is our in-memory queue implementation used as our egress FIFO queue for messages sent by the client.

func (*Queue) Peek Uses

func (q *Queue) Peek() (Item, error)

Peek returns the next message ref from the queue without modifying the queue.

func (*Queue) Pop Uses

func (q *Queue) Pop() (Item, error)

Pop pops the next message ref off the queue and returns nil upon success, otherwise an error is returned.

func (*Queue) Push Uses

func (q *Queue) Push(e Item) error

Push pushes the given message ref onto the queue and returns nil on success, otherwise an error is returned.

type Session Uses

type Session struct {
    worker.Worker

    EventSink chan Event
    // contains filtered or unexported fields
}

Session is the struct type that keeps state for a given session.

func NewSession Uses

func NewSession(
    ctx context.Context,
    fatalErrCh chan error,
    logBackend *log.Backend,
    cfg *config.Config,
    linkKey *ecdh.PrivateKey) (*Session, error)

New establishes a session with provider using key. This method will block until session is connected to the Provider.

func (*Session) BlockingSendUnreliableMessage Uses

func (s *Session) BlockingSendUnreliableMessage(recipient, provider string, message []byte) ([]byte, error)

func (*Session) CurrentDocument Uses

func (s *Session) CurrentDocument() *pki.Document

func (*Session) GetPandaConfig Uses

func (s *Session) GetPandaConfig() *config.Panda

func (*Session) GetService Uses

func (s *Session) GetService(serviceName string) (*utils.ServiceDescriptor, error)

GetService returns a randomly selected service matching the specified service name

func (*Session) SendUnreliableMessage Uses

func (s *Session) SendUnreliableMessage(recipient, provider string, message []byte) (MessageID, error)

SendUnreliableMessage asynchronously sends message without any automatic retransmissions.

func (*Session) Shutdown Uses

func (s *Session) Shutdown()

type TimerQueue Uses

type TimerQueue struct {
    sync.Mutex
    sync.Cond
    worker.Worker
    // contains filtered or unexported fields
}

TimerQueue is a queue that delays messages before forwarding to another queue

func NewTimerQueue Uses

func NewTimerQueue(nextQueue nqueue) *TimerQueue

NewTimerQueue intantiates a new TimerQueue and starts the worker routine

func (*TimerQueue) Push Uses

func (a *TimerQueue) Push(i Item)

Push adds a message to the TimerQueue

func (*TimerQueue) Remove Uses

func (a *TimerQueue) Remove(i Item) error

Remove removes a Message from the TimerQueue

Directories

PathSynopsis
configPackage config implements the configuration for the Katzenpost client.
constants
internal/pkiclientPackage pkiclient implements a caching wrapper around core/pki.Client.
internal/proxyPackage proxy implements the support for an upstream (outgoing) proxy.
session
utils

Package client imports 32 packages (graph) and is imported by 9 packages. Updated 2019-10-19. Refresh now. Tools for package owners.