chat

package

Go to main page

Versions in this module

v1

v1.0.22

May 1, 2017

Changes in this version

+ var ErrChatServerTimeout = errors.New("timeout calling chat server")

+ func IdentifyModeCtx(ctx context.Context, mode keybase1.TLFIdentifyBehavior, ...) context.Context

+ type FetchRetrier struct

+ func NewFetchRetrier(g *globals.Context) *FetchRetrier

+ func (f *FetchRetrier) Connected(ctx context.Context)

+ func (f *FetchRetrier) Disconnected(ctx context.Context)

+ func (f *FetchRetrier) Failure(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (err error)

+ func (f *FetchRetrier) Force(ctx context.Context)

+ func (f *FetchRetrier) IsOffline() bool

+ func (f *FetchRetrier) SetClock(clock clockwork.Clock)

+ func (f *FetchRetrier) Start(ctx context.Context, uid gregor1.UID)

+ func (f *FetchRetrier) Stop(ctx context.Context) chan struct{}

+ func (f *FetchRetrier) Success(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (err error)

+ type RemoteClient struct

+ func NewRemoteClient(g *globals.Context, cli rpc.GenericClient) *RemoteClient

+ func (c *RemoteClient) Call(ctx context.Context, method string, arg interface{}, res interface{}) (err error)

+ func (c *RemoteClient) Notify(ctx context.Context, method string, arg interface{}) (err error)

+ type Server struct

+ func NewServer(g *globals.Context, store *AttachmentStore, serverConn ServerConnection, ...) *Server

+ func (h *Server) CancelPost(ctx context.Context, outboxID chat1.OutboxID) (err error)

+ func (h *Server) DownloadAttachmentLocal(ctx context.Context, arg chat1.DownloadAttachmentLocalArg) (res chat1.DownloadAttachmentLocalRes, err error)

+ func (h *Server) DownloadFileAttachmentLocal(ctx context.Context, arg chat1.DownloadFileAttachmentLocalArg) (res chat1.DownloadAttachmentLocalRes, err error)

+ func (h *Server) FindConversationsLocal(ctx context.Context, arg chat1.FindConversationsLocalArg) (res chat1.FindConversationsLocalRes, err error)

+ func (h *Server) GetCachedThread(ctx context.Context, arg chat1.GetCachedThreadArg) (res chat1.GetThreadLocalRes, err error)

+ func (h *Server) GetConversationForCLILocal(ctx context.Context, arg chat1.GetConversationForCLILocalQuery) (res chat1.GetConversationForCLILocalRes, err error)

+ func (h *Server) GetInboxAndUnboxLocal(ctx context.Context, arg chat1.GetInboxAndUnboxLocalArg) (res chat1.GetInboxAndUnboxLocalRes, err error)

+ func (h *Server) GetInboxNonblockLocal(ctx context.Context, arg chat1.GetInboxNonblockLocalArg) (res chat1.NonblockFetchRes, err error)

+ func (h *Server) GetInboxSummaryForCLILocal(ctx context.Context, arg chat1.GetInboxSummaryForCLILocalQuery) (res chat1.GetInboxSummaryForCLILocalRes, err error)

+ func (h *Server) GetMessagesLocal(ctx context.Context, arg chat1.GetMessagesLocalArg) (res chat1.GetMessagesLocalRes, err error)

+ func (h *Server) GetThreadLocal(ctx context.Context, arg chat1.GetThreadLocalArg) (res chat1.GetThreadLocalRes, err error)

+ func (h *Server) GetThreadNonblock(ctx context.Context, arg chat1.GetThreadNonblockArg) (res chat1.NonblockFetchRes, fullErr error)

+ func (h *Server) MakePreview(ctx context.Context, arg chat1.MakePreviewArg) (res chat1.MakePreviewRes, err error)

+ func (h *Server) MarkAsReadLocal(ctx context.Context, arg chat1.MarkAsReadLocalArg) (res chat1.MarkAsReadLocalRes, err error)

+ func (h *Server) NewConversationLocal(ctx context.Context, arg chat1.NewConversationLocalArg) (res chat1.NewConversationLocalRes, reserr error)

+ func (h *Server) PostAttachmentLocal(ctx context.Context, arg chat1.PostAttachmentLocalArg) (res chat1.PostLocalRes, err error)

+ func (h *Server) PostDeleteNonblock(ctx context.Context, arg chat1.PostDeleteNonblockArg) (chat1.PostLocalNonblockRes, error)

+ func (h *Server) PostEditNonblock(ctx context.Context, arg chat1.PostEditNonblockArg) (chat1.PostLocalNonblockRes, error)

+ func (h *Server) PostFileAttachmentLocal(ctx context.Context, arg chat1.PostFileAttachmentLocalArg) (res chat1.PostLocalRes, err error)

+ func (h *Server) PostLocal(ctx context.Context, arg chat1.PostLocalArg) (res chat1.PostLocalRes, err error)

+ func (h *Server) PostLocalNonblock(ctx context.Context, arg chat1.PostLocalNonblockArg) (res chat1.PostLocalNonblockRes, err error)

+ func (h *Server) PostTextNonblock(ctx context.Context, arg chat1.PostTextNonblockArg) (chat1.PostLocalNonblockRes, error)

+ func (h *Server) RetryPost(ctx context.Context, outboxID chat1.OutboxID) (err error)

+ func (h *Server) SetConversationStatusLocal(ctx context.Context, arg chat1.SetConversationStatusLocalArg) (res chat1.SetConversationStatusLocalRes, err error)

+ func (h *Server) Sign(payload []byte) ([]byte, error)

+ type ServerConnection interface

+ GetClient func() rpc.GenericClient

+ Reconnect func(context.Context) error

+ type UISource interface

+ GetChatUI func(sessionID int) libkb.ChatUI

+ GetStreamUICli func() *keybase1.StreamUiClient

v1.0.21

Apr 13, 2017

Changes in this version

type Boxer

+ func (b *Boxer) CompareTlfNames(ctx context.Context, tlfName1, tlfName2 string, tlfPublic bool) (bool, error)

type BufferSource

+ func (b *BufferSource) Bytes() []byte

type HybridConversationSource

+ func (s HybridConversationSource) SetTLFInfoSource(tlfInfoSource types.TLFInfoSource)

type HybridInboxSource

+ func (b HybridInboxSource) SetTLFInfoSource(tlfInfoSource types.TLFInfoSource)

+ type KBFSTLFInfoSource struct

+ func NewKBFSTLFInfoSource(g *libkb.GlobalContext) *KBFSTLFInfoSource

+ func (t *KBFSTLFInfoSource) CompleteAndCanonicalizePrivateTlfName(ctx context.Context, tlfName string) (res keybase1.CanonicalTLFNameAndIDWithBreaks, err error)

+ func (t *KBFSTLFInfoSource) CryptKeys(ctx context.Context, tlfName string) (res keybase1.GetTLFCryptKeysRes, ferr error)

+ func (t *KBFSTLFInfoSource) Lookup(ctx context.Context, tlfName string, visibility chat1.TLFVisibility) (*types.TLFInfo, error)

+ func (t *KBFSTLFInfoSource) PublicCanonicalTLFNameAndID(ctx context.Context, tlfName string) (res keybase1.CanonicalTLFNameAndIDWithBreaks, ferr error)

type RemoteConversationSource

+ func (s RemoteConversationSource) SetTLFInfoSource(tlfInfoSource types.TLFInfoSource)

type RemoteInboxSource

+ func (b RemoteInboxSource) SetTLFInfoSource(tlfInfoSource types.TLFInfoSource)

type Syncer

+ func (s *Syncer) AddStaleConversation(ctx context.Context, uid gregor1.UID, convID chat1.ConversationID)

+ func (s *Syncer) IsConnected(ctx context.Context) bool

+ func (s *Syncer) SetClock(clock clockwork.Clock)

+ func (s *Syncer) Shutdown()

+ func (s *Syncer) Sync(ctx context.Context, cli chat1.RemoteInterface, uid gregor1.UID, ...) (err error)

v1.0.20

Mar 9, 2017

v1.0.19

Mar 9, 2017

Changes in this version

+ var ErrAbortOnPartMismatch = errors.New("local part mismatch, aborting upload")

+ var ErrPartNotFound = errors.New("part does not exist in stash")

+ func BackgroundContext(sourceCtx context.Context) context.Context

+ func Context(ctx context.Context, mode keybase1.TLFIdentifyBehavior, ...) context.Context

+ func CtxAddLogTags(ctx context.Context) context.Context

+ func IdentifyMode(ctx context.Context) (ib keybase1.TLFIdentifyBehavior, breaks *[]keybase1.TLFIdentifyFailure, ...)

+ func NewInboxSource(g *libkb.GlobalContext, typ string, ri func() chat1.RemoteInterface, ...) interfaces.InboxSource

+ type AttachmentInfo struct

+ EncKey signencrypt.SecretboxKey

+ ObjectKey string

+ Parts map[int]string

+ SignKey signencrypt.SignKey

+ StartedAt time.Time

+ VerifyKey signencrypt.VerifyKey

+ type AttachmentStash interface

+ Finish func(key StashKey) error

+ Lookup func(key StashKey) (AttachmentInfo, bool, error)

+ RecordPart func(key StashKey, partNumber int, hash string) error

+ Start func(key StashKey, info AttachmentInfo) error

+ type AttachmentStore struct

+ func NewAttachmentStore(log logger.Logger, runtimeDir string) *AttachmentStore

+ func (a *AttachmentStore) DeleteAsset(ctx context.Context, params chat1.S3Params, signer s3.Signer, ...) error

+ func (a *AttachmentStore) DeleteAssets(ctx context.Context, params chat1.S3Params, signer s3.Signer, ...) error

+ func (a *AttachmentStore) DownloadAsset(ctx context.Context, params chat1.S3Params, asset chat1.Asset, w io.Writer, ...) error

+ func (a *AttachmentStore) PutS3(ctx context.Context, r io.Reader, size int64, task *UploadTask, ...) (*PutS3Result, error)

+ func (a *AttachmentStore) UploadAsset(ctx context.Context, task *UploadTask) (chat1.Asset, error)

+ type BlockingLocalizer struct

+ func NewBlockingLocalizer(g *libkb.GlobalContext, getTlfInterface func() keybase1.TlfInterface) *BlockingLocalizer

+ func (b *BlockingLocalizer) Localize(ctx context.Context, uid gregor1.UID, inbox chat1.Inbox) (res []chat1.ConversationLocal, err error)

+ func (b *BlockingLocalizer) Name() string

+ func (b *BlockingLocalizer) SetOffline()

+ type BlockingSender struct

+ func NewBlockingSender(g *libkb.GlobalContext, boxer *Boxer, store *AttachmentStore, ...) *BlockingSender

+ func (s *BlockingSender) Prepare(ctx context.Context, plaintext chat1.MessagePlaintext, ...) (*chat1.MessageBoxed, []chat1.Asset, error)

+ func (s *BlockingSender) Send(ctx context.Context, convID chat1.ConversationID, msg chat1.MessagePlaintext, ...) (chat1.OutboxID, chat1.MessageID, *chat1.RateLimit, error)

+ func (s *BlockingSender) Sign(payload []byte) ([]byte, error)

+ type BodyHashInvalid struct

+ func (e BodyHashInvalid) Error() string

type Boxer

+ func (b *Boxer) ValidSenderKey(ctx context.Context, sender gregor1.UID, key []byte, ctime gregor1.Time) (found, validAtCTime bool, revoked *gregor1.Time, unboxErr UnboxingError)

+ type BoxingCryptKeysError struct

+ Err error

+ func NewBoxingCryptKeysError(err error) BoxingCryptKeysError

+ func (e BoxingCryptKeysError) Error() string

+ func (e BoxingCryptKeysError) Inner() error

+ func (e BoxingCryptKeysError) IsImmediateFail() (chat1.OutboxErrorType, bool)

+ type BoxingError struct

+ Msg string

+ Perm bool

+ func NewBoxingError(msg string, perm bool) BoxingError

+ func (e BoxingError) Error() string

+ func (e BoxingError) IsImmediateFail() (chat1.OutboxErrorType, bool)

+ type BufferSource struct

+ func (b *BufferSource) Basename() string

+ func (b *BufferSource) Close() error

+ func (b *BufferSource) FileSize() int

+ func (b *BufferSource) Open(sessionID int, cli *keybase1.StreamUiClient) (ReadResetter, error)

+ type ByMsgID []chat1.MessageUnboxed

+ func (m ByMsgID) Len() int

+ func (m ByMsgID) Less(i, j int) bool

+ func (m ByMsgID) Swap(i, j int)

+ type ChatThreadConsistencyError interface

+ Code func() ConsistencyErrorCode

+ func NewChatThreadConsistencyError(code ConsistencyErrorCode, msg string, formatArgs ...interface{}) ChatThreadConsistencyError

+ type ConsistencyErrorCode int

+ const DuplicateID

+ const InconsistentHash

+ const IncorrectHash

+ const OutOfOrderID

type Decrypter

+ DecryptWithNonce func(ciphertext io.Reader, nonce signencrypt.Nonce, encKey, verifyKey []byte) (plaintext io.Reader)

+ type Deliverer struct

+ func NewDeliverer(g *libkb.GlobalContext, sender Sender) *Deliverer

+ func (s *Deliverer) Connected(ctx context.Context)

+ func (s *Deliverer) Disconnected(ctx context.Context)

+ func (s *Deliverer) ForceDeliverLoop(ctx context.Context)

+ func (s *Deliverer) IsOffline() bool

+ func (s *Deliverer) Queue(ctx context.Context, convID chat1.ConversationID, msg chat1.MessagePlaintext, ...) (chat1.OutboxRecord, error)

+ func (s *Deliverer) SetClock(clock clockwork.Clock)

+ func (s *Deliverer) SetSender(sender Sender)

+ func (s *Deliverer) Start(ctx context.Context, uid gregor1.UID)

+ func (s *Deliverer) Stop(ctx context.Context) chan struct{}

+ type DelivererInfoError interface

+ IsImmediateFail func() (chat1.OutboxErrorType, bool)

+ type DelivererSecretUI struct

+ func (d DelivererSecretUI) GetPassphrase(pinentry keybase1.GUIEntryArg, terminal *keybase1.SecretEntryArg) (keybase1.GetPassphraseRes, error)

type Encrypter

+ EncryptResume func(r io.Reader, nonce signencrypt.Nonce, encKey signencrypt.SecretboxKey, ...) (io.Reader, error)

+ EncryptWithNonce func(plaintext io.Reader, nonce signencrypt.Nonce) (ciphertext io.Reader, err error)

+ type ErrorWrapper struct

+ func NewErrorWrapper(prefix string, err error) *ErrorWrapper

+ func (e *ErrorWrapper) Details() string

+ func (e *ErrorWrapper) Error() string

+ type FileStash struct

+ func NewFileStash(dir string) *FileStash

+ func (f *FileStash) Finish(key StashKey) error

+ func (f *FileStash) Lookup(key StashKey) (AttachmentInfo, bool, error)

+ func (f *FileStash) RecordPart(key StashKey, partNumber int, hash string) error

+ func (f *FileStash) Start(key StashKey, info AttachmentInfo) error

+ type HeaderMismatchError struct

+ Field string

+ func NewHeaderMismatchError(field string) HeaderMismatchError

+ func (e HeaderMismatchError) Error() string

type HybridConversationSource

+ func (s *HybridConversationSource) GetMessages(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ func (s *HybridConversationSource) GetMessagesWithRemotes(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ func (s *HybridConversationSource) PullLocalOnly(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.ThreadView, error)

+ func (s HybridConversationSource) Connected(ctx context.Context)

+ func (s HybridConversationSource) Disconnected(ctx context.Context)

+ func (s HybridConversationSource) IsOffline() bool

+ func (s HybridConversationSource) SetRemoteInterface(ri func() chat1.RemoteInterface)

+ func (s HybridConversationSource) SetTlfInterface(ti func() keybase1.TlfInterface)

+ func (s HybridConversationSource) TransformSupersedes(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ type HybridInboxSource struct

+ func NewHybridInboxSource(g *libkb.GlobalContext, getTlfInterface func() keybase1.TlfInterface, ...) *HybridInboxSource

+ func (b HybridInboxSource) Connected(ctx context.Context)

+ func (b HybridInboxSource) Disconnected(ctx context.Context)

+ func (b HybridInboxSource) IsOffline() bool

+ func (b HybridInboxSource) SetRemoteInterface(ri func() chat1.RemoteInterface)

+ func (b HybridInboxSource) SetTlfInterface(ti func() keybase1.TlfInterface)

+ func (s *HybridInboxSource) NewConversation(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (err error)

+ func (s *HybridInboxSource) NewMessage(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (conv *chat1.ConversationLocal, err error)

+ func (s *HybridInboxSource) Read(ctx context.Context, uid gregor1.UID, localizer interfaces.ChatLocalizer, ...) (inbox chat1.Inbox, rl *chat1.RateLimit, err error)

+ func (s *HybridInboxSource) ReadMessage(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (conv *chat1.ConversationLocal, err error)

+ func (s *HybridInboxSource) ReadUnverified(ctx context.Context, uid gregor1.UID, useLocalData bool, ...) (res chat1.Inbox, rl *chat1.RateLimit, err error)

+ func (s *HybridInboxSource) SetStatus(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (conv *chat1.ConversationLocal, err error)

+ func (s *HybridInboxSource) TlfFinalize(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (convs []chat1.ConversationLocal, err error)

+ type IdentifyChangedHandler struct

+ func NewIdentifyChangedHandler(g *libkb.GlobalContext, tlf func() keybase1.TlfInterface) *IdentifyChangedHandler

+ func (h *IdentifyChangedHandler) BackgroundIdentifyChanged(ctx context.Context, job engine.IdentifyJob)

+ func (h *IdentifyChangedHandler) HandleUserChanged(uid keybase1.UID) (err error)

+ type IdentifyNotifier struct

+ func CtxIdentifyNotifier(ctx context.Context) *IdentifyNotifier

+ func NewIdentifyNotifier(g *libkb.GlobalContext) *IdentifyNotifier

+ func (i *IdentifyNotifier) Send(update keybase1.CanonicalTLFNameAndIDWithBreaks)

type KeyFinder

+ func CtxKeyFinder(ctx context.Context) KeyFinder

+ type NonblockInboxResult struct

+ ConvID chat1.ConversationID

+ ConvRes *chat1.ConversationLocal

+ Err *chat1.ConversationErrorLocal

+ InboxRes *chat1.Inbox

+ type NonblockingLocalizer struct

+ func NewNonblockingLocalizer(g *libkb.GlobalContext, localizeCb chan NonblockInboxResult, ...) *NonblockingLocalizer

+ func (b *NonblockingLocalizer) Localize(ctx context.Context, uid gregor1.UID, inbox chat1.Inbox) (res []chat1.ConversationLocal, err error)

+ func (b *NonblockingLocalizer) Name() string

+ func (b *NonblockingLocalizer) SetOffline()

+ type NonblockingSender struct

+ func NewNonblockingSender(g *libkb.GlobalContext, sender Sender) *NonblockingSender

+ func (s *NonblockingSender) Prepare(ctx context.Context, plaintext chat1.MessagePlaintext, ...) (*chat1.MessageBoxed, []chat1.Asset, error)

+ func (s *NonblockingSender) Send(ctx context.Context, convID chat1.ConversationID, msg chat1.MessagePlaintext, ...) (chat1.OutboxID, chat1.MessageID, *chat1.RateLimit, error)

+ type OfflineError struct

+ func (e OfflineError) Error() string

+ type PermanentUnboxingError struct

+ func (e PermanentUnboxingError) Error() string

+ func (e PermanentUnboxingError) ExportType() chat1.MessageUnboxedErrorType

+ func (e PermanentUnboxingError) Inner() error

+ func (e PermanentUnboxingError) IsPermanent() bool

+ type PreviewRes struct

+ BaseDurationMs int

+ BaseHeight int

+ BaseWidth int

+ ContentType string

+ PreviewDurationMs int

+ PreviewHeight int

+ PreviewWidth int

+ Source *BufferSource

+ func Preview(ctx context.Context, log logger.Logger, src io.Reader, ...) (*PreviewRes, error)

+ type PushHandler struct

+ func NewPushHandler(g *libkb.GlobalContext) *PushHandler

+ func (g *PushHandler) Activity(ctx context.Context, m gregor.OutOfBandMessage, badger *badges.Badger) error

+ func (g *PushHandler) TlfFinalize(ctx context.Context, m gregor.OutOfBandMessage) error

+ func (g *PushHandler) TlfResolve(ctx context.Context, m gregor.OutOfBandMessage) error

+ type ReadResetter interface

+ Reset func() error

type RemoteConversationSource

+ func (s *RemoteConversationSource) GetMessages(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ func (s *RemoteConversationSource) GetMessagesWithRemotes(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ func (s *RemoteConversationSource) PullLocalOnly(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.ThreadView, error)

+ func (s RemoteConversationSource) Connected(ctx context.Context)

+ func (s RemoteConversationSource) Disconnected(ctx context.Context)

+ func (s RemoteConversationSource) IsOffline() bool

+ func (s RemoteConversationSource) SetRemoteInterface(ri func() chat1.RemoteInterface)

+ func (s RemoteConversationSource) SetTlfInterface(ti func() keybase1.TlfInterface)

+ func (s RemoteConversationSource) TransformSupersedes(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) ([]chat1.MessageUnboxed, error)

+ type RemoteInboxSource struct

+ func NewRemoteInboxSource(g *libkb.GlobalContext, ri func() chat1.RemoteInterface, ...) *RemoteInboxSource

+ func (b RemoteInboxSource) Connected(ctx context.Context)

+ func (b RemoteInboxSource) Disconnected(ctx context.Context)

+ func (b RemoteInboxSource) IsOffline() bool

+ func (b RemoteInboxSource) SetRemoteInterface(ri func() chat1.RemoteInterface)

+ func (b RemoteInboxSource) SetTlfInterface(ti func() keybase1.TlfInterface)

+ func (s *RemoteInboxSource) NewConversation(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) error

+ func (s *RemoteInboxSource) NewMessage(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (*chat1.ConversationLocal, error)

+ func (s *RemoteInboxSource) Read(ctx context.Context, uid gregor1.UID, localizer interfaces.ChatLocalizer, ...) (chat1.Inbox, *chat1.RateLimit, error)

+ func (s *RemoteInboxSource) ReadMessage(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (*chat1.ConversationLocal, error)

+ func (s *RemoteInboxSource) ReadUnverified(ctx context.Context, uid gregor1.UID, useLocalData bool, ...) (chat1.Inbox, *chat1.RateLimit, error)

+ func (s *RemoteInboxSource) SetStatus(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) (*chat1.ConversationLocal, error)

+ func (s *RemoteInboxSource) TlfFinalize(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers, ...) ([]chat1.ConversationLocal, error)

+ type Sender interface

+ Prepare func(ctx context.Context, msg chat1.MessagePlaintext, convID *chat1.ConversationID) (*chat1.MessageBoxed, []chat1.Asset, error)

+ Send func(ctx context.Context, convID chat1.ConversationID, msg chat1.MessagePlaintext, ...) (chat1.OutboxID, chat1.MessageID, *chat1.RateLimit, error)

type SignDecrypter

+ func (s *SignDecrypter) DecryptWithNonce(r io.Reader, nonce signencrypt.Nonce, encKey, verifyKey []byte) (plaintext io.Reader)

type SignEncrypter

+ func (s *SignEncrypter) EncryptResume(r io.Reader, nonce signencrypt.Nonce, encKey signencrypt.SecretboxKey, ...) (io.Reader, error)

+ func (s *SignEncrypter) EncryptWithNonce(r io.Reader, nonce signencrypt.Nonce) (io.Reader, error)

+ func (s *SignEncrypter) SignKey() []byte

+ type StashKey struct

+ ConversationID chat1.ConversationID

+ PlaintextHash []byte

+ UserID keybase1.UID

+ func NewStashKey(plaintextHash []byte, cid chat1.ConversationID, uid keybase1.UID) StashKey

+ func (s StashKey) String() string

+ type Syncer struct

+ func NewSyncer(g *libkb.GlobalContext) *Syncer

+ func (s *Syncer) Connected(ctx context.Context, cli chat1.RemoteInterface, uid gregor1.UID) error

+ func (s *Syncer) Disconnected(ctx context.Context)

+ func (s *Syncer) RegisterOfflinable(offlinable interfaces.Offlinable)

+ func (s *Syncer) SendChatStaleNotifications(uid gregor1.UID)

+ type TLFInfo struct

+ CanonicalName string

+ ID chat1.TLFID

+ IdentifyFailures []keybase1.TLFIdentifyFailure

+ func GetInboxQueryTLFInfo(ctx context.Context, tlfInterface keybase1.TlfInterface, ...) (*TLFInfo, error)

+ func LookupTLF(ctx context.Context, tlfcli keybase1.TlfInterface, tlfName string, ...) (*TLFInfo, error)

+ type TransientUnboxingError struct

+ func (e TransientUnboxingError) Error() string

+ func (e TransientUnboxingError) ExportType() chat1.MessageUnboxedErrorType

+ func (e TransientUnboxingError) Inner() error

+ func (e TransientUnboxingError) IsPermanent() bool

+ type UnboxingError interface

+ Error func() string

+ ExportType func() chat1.MessageUnboxedErrorType

+ Inner func() error

+ IsPermanent func() bool

+ func NewPermanentUnboxingError(inner error) UnboxingError

+ func NewTransientUnboxingError(inner error) UnboxingError

+ type UploadTask struct

+ ConversationID chat1.ConversationID

+ FileSize int

+ Filename string

+ Plaintext ReadResetter

+ Progress ProgressReporter

+ S3Params chat1.S3Params

+ S3Signer s3.Signer

+ UserID keybase1.UID

+ func (u *UploadTask) Nonce() signencrypt.Nonce

+ type VersionError struct

+ Critical bool

+ Kind string

+ Version int

+ func NewBodyVersionError(version chat1.BodyPlaintextVersion, defaultBody chat1.BodyPlaintextUnsupported) VersionError

+ func NewHeaderVersionError(version chat1.HeaderPlaintextVersion, ...) VersionError

+ func NewMessageBoxedVersionError(version chat1.MessageBoxedVersion) VersionError

+ func (e VersionError) Error() string

+ func (e VersionError) ExportType() chat1.MessageUnboxedErrorType

v1.0.18

Oct 26, 2016

Changes in this version

+ func CheckPrevPointersAndGetUnpreved(thread *chat1.ThreadView) ([]chat1.MessagePreviousPointer, libkb.ChatThreadConsistencyError)

+ func DownloadAsset(ctx context.Context, log logger.Logger, params chat1.S3Params, ...) error

+ func NewConversationSource(g *libkb.GlobalContext, typ string, boxer *Boxer, storage *storage.Storage, ...) libkb.ConversationSource

+ type Boxer struct

+ func NewBoxer(kbCtx utils.KeybaseContext, tlf keybase1.TlfInterface, ...) *Boxer

+ func (b *Boxer) BoxMessage(ctx context.Context, msg chat1.MessagePlaintext, ...) (*chat1.MessageBoxed, error)

+ func (b *Boxer) UnboxMessage(ctx context.Context, finder KeyFinder, boxed chat1.MessageBoxed) (chat1.MessageUnboxed, libkb.ChatUnboxingError)

+ func (b *Boxer) UnboxMessages(ctx context.Context, boxed []chat1.MessageBoxed) (unboxed []chat1.MessageUnboxed, err error)

+ func (b *Boxer) UnboxThread(ctx context.Context, boxed chat1.ThreadViewBoxed, convID chat1.ConversationID) (thread chat1.ThreadView, err error)

+ type Decrypter interface

+ Decrypt func(ciphertext io.Reader, encKey, verifyKey []byte) (plaintext io.Reader)

+ type Encrypter interface

+ Encrypt func(plaintext io.Reader) (ciphertext io.Reader, err error)

+ EncryptKey func() []byte

+ EncryptedLen func(size int) int

+ VerifyKey func() []byte

+ type HybridConversationSource struct

+ func NewHybridConversationSource(g *libkb.GlobalContext, b *Boxer, storage *storage.Storage, ...) *HybridConversationSource

+ func (s *HybridConversationSource) Clear(convID chat1.ConversationID, uid gregor1.UID) error

+ func (s *HybridConversationSource) Pull(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.ThreadView, []*chat1.RateLimit, error)

+ func (s *HybridConversationSource) Push(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.MessageUnboxed, error)

+ type KeyFinder interface

+ Find func(ctx context.Context, tlf keybase1.TlfInterface, tlfName string, tlfPublic bool) (keybase1.GetTLFCryptKeysRes, error)

+ func NewKeyFinder() KeyFinder

+ type KeyFinderImpl struct

+ func (k *KeyFinderImpl) Find(ctx context.Context, tlf keybase1.TlfInterface, tlfName string, tlfPublic bool) (keybase1.GetTLFCryptKeysRes, error)

+ type ProgressReporter func(bytesCompleted, bytesTotal int)

+ type PutS3Result struct

+ Bucket string

+ Endpoint string

+ Path string

+ Region string

+ Size int64

+ func PutS3(ctx context.Context, log logger.Logger, r io.Reader, size int64, ...) (*PutS3Result, error)

+ type RemoteConversationSource struct

+ func NewRemoteConversationSource(g *libkb.GlobalContext, b *Boxer, ri chat1.RemoteInterface) *RemoteConversationSource

+ func (s *RemoteConversationSource) Clear(convID chat1.ConversationID, uid gregor1.UID) error

+ func (s *RemoteConversationSource) Pull(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.ThreadView, []*chat1.RateLimit, error)

+ func (s *RemoteConversationSource) Push(ctx context.Context, convID chat1.ConversationID, uid gregor1.UID, ...) (chat1.MessageUnboxed, error)

+ type SignDecrypter struct

+ func NewSignDecrypter() *SignDecrypter

+ func (s *SignDecrypter) Decrypt(r io.Reader, encKey, verifyKey []byte) io.Reader

+ type SignEncrypter struct

+ func NewSignEncrypter() *SignEncrypter

+ func (s *SignEncrypter) Encrypt(r io.Reader) (io.Reader, error)

+ func (s *SignEncrypter) EncryptKey() []byte

+ func (s *SignEncrypter) EncryptedLen(size int) int

+ func (s *SignEncrypter) VerifyKey() []byte

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL