channelsFileTransfer

type Cmix interface {
	GetMaxMessageLength() int
	SendMany(messages []cmix.TargetedCmixMessage, p cmix.CMIXParams) (
		rounds.Round, []ephemeral.Id, error)
	AddIdentity(id *id.ID, validUntil time.Time, persistent bool,
		fallthroughProcessor message.Processor)
	RemoveIdentity(id *id.ID)
	AddFingerprint(identity *id.ID, fingerprint format.Fingerprint,
		mp message.Processor) error
	DeleteFingerprint(identity *id.ID, fingerprint format.Fingerprint)
	DeleteClientFingerprints(identity *id.ID)
	CheckInProgressMessages()
	IsHealthy() bool
	AddHealthCallback(f func(bool)) uint64
	RemoveHealthCallback(uint64)
	GetRoundResults(timeout time.Duration,
		roundCallback cmix.RoundEventCallback, roundList ...id.Round)
}

type DelayedTimer struct {
	C *<-chan time.Time
	// contains filtered or unexported fields
}

type EventModel interface {
	// ReceiveFile is called when a file upload or download beings.
	//
	// fileLink and fileData are nillable and may be updated based upon the UUID
	// or file ID later.
	//
	// fileID is always unique to the fileData. fileLink is the JSON of
	// FileLink.
	//
	// Returns any fatal errors.
	ReceiveFile(fileID ftCrypto.ID, fileLink, fileData []byte,
		timestamp time.Time, status Status) error

	// UpdateFile is called when a file upload or download completes or changes.
	//
	// fileLink, fileData, timestamp, and status are all nillable and may be
	// updated based upon the file ID at a later date. If a nil value is passed,
	// then make no update.
	//
	// Returns an error if the file cannot be updated. It must return
	// channels.NoMessageErr if the file does not exist.
	UpdateFile(fileID ftCrypto.ID, fileLink, fileData []byte,
		timestamp *time.Time, status *Status) error

	// GetFile returns the ModelFile containing the file data and download link
	// for the given file ID.
	//
	// Returns an error if the file cannot be retrieved. It must return
	// channels.NoMessageErr if the file does not exist.
	GetFile(fileID ftCrypto.ID) (ModelFile, error)

	// DeleteFile deletes the file with the given file ID.
	//
	// Returns fatal errors. It must return channels.NoMessageErr if the file
	// does not exist.
	DeleteFile(fileID ftCrypto.ID) error

	channels.EventModel
}

type FileInfo struct {
	// Name is the name of the file.
	Name string `json:"name"`

	// Type indicates what type of file is being transferred.
	Type string `json:"type"`

	// Preview contains a preview of the file.
	Preview []byte `json:"preview"`

	FileLink
}

type FileLink struct {
	// FileID is the file's ID.
	FileID ftCrypto.ID `json:"fileID"`

	// RecipientID is the ID to listen on to receive file.
	RecipientID *id.ID `json:"recipientID"`

	// SentTimestamp is the time when the file was first queued to send.
	SentTimestamp time.Time `json:"sentTimestamp"`

	// Key is the 256-bit encryption key.
	Key ftCrypto.TransferKey `json:"key"`

	// Mac is the transfer MAC (Message Authentication Code) for this file.
	Mac []byte `json:"mac"`

	// Size is the file size in bytes.
	Size uint32 `json:"size"`

	// NumParts is the number of file parts being transferred.
	NumParts uint16 `json:"numParts"`

	// Retry determines number of resends allowed on failure.
	Retry float32 `json:"retry"`
}

type FilePartTracker interface {
	// GetPartStatus returns the status of the file part with the given part
	// number. The possible values for the status are:
	//  0 < Part does not exist
	//  0 = unsent
	//  1 = arrived (sender has sent a part, and it has arrived)
	//  2 = received (receiver has received a part)
	GetPartStatus(partNum uint16) FpStatus

	// GetNumParts returns the total number of file parts in the transfer.
	GetNumParts() uint16
}

type FileTransfer interface {

	// StartProcesses starts the sending threads that wait for file transfers to
	// send. Adheres to the xxdk.Service type.
	StartProcesses() (stoppable.Stoppable, error)

	// MaxFileNameLen returns the max number of bytes allowed for a file name.
	MaxFileNameLen() int

	// MaxFileTypeLen returns the max number of bytes allowed for a file type.
	MaxFileTypeLen() int

	// MaxFileSize returns the max number of bytes allowed for a file.
	MaxFileSize() int

	// MaxPreviewSize returns the max number of bytes allowed for a file
	// preview.
	MaxPreviewSize() int

	// Upload starts uploading the file to a new ID that can be sent to the
	// specified channel when complete. To get progress information about the
	// upload, a SentProgressCallback must be registered. All errors returned on
	// the callback are fatal and the user must take action to either
	// RetryUpload or CloseSend.
	//
	// The file is added to the event model at the returned file ID with the
	// status Uploading. Once the upload is complete, the file link is added to
	// the event model with the status Complete.
	//
	// The SentProgressCallback only indicates the progress of the file upload,
	// not the status of the file in the event model. You must rely on updates
	// from the event model to know when it can be retrieved.
	//
	// Parameters:
	//   - fileData - File contents. Max size defined by MaxFileSize.
	//   - retry - The number of sending retries allowed on send failure (e.g.
	//     a retry of 2.0 with 6 parts means 12 total possible sends).
	//   - progressCB - A callback that reports the progress of the file upload.
	//     The callback is called once on initialization, on every progress
	//     update (or less if restricted by the period), or on fatal error.
	//   - period - A progress callback will be limited from triggering only
	//     once per period.
	//
	// Returns:
	//   - A file ID that uniquely identifies this file.
	Upload(fileData []byte, retry float32, progressCB SentProgressCallback,
		period time.Duration) (ftCrypto.ID, error)

	// Send sends the specified file info to the channel. Once a file is
	// uploaded via Upload, its file link (found in the event model) can be sent
	// to any channel.
	//
	// Parameters:
	//   - channelID - The ID of the channel to send the file to.
	//   - fileLink - JSON of FileLink stored in the event model.
	//   - fileName - Human-readable file name. Max length defined by
	//     MaxFileNameLen.
	//   - fileType - Shorthand that identifies the type of file. Max length
	//     defined by MaxFileTypeLen.
	//   - preview - A preview of the file data (e.g. a thumbnail). Max size
	//     defined by MaxPreviewSize.
	//   - validUntil - The duration that the file is available in the channel.
	//     For the maximum amount of time, use channels.ValidForever.
	//   - params - The xxdk.CMIXParams to send this.
	//   - pings - A list of Ed25519 public keys that will receive notifications
	//     for this message. They must be in the channel and have notifications
	//     enabled.
	Send(channelID *id.ID, fileLink []byte, fileName, fileType string,
		preview []byte, validUntil time.Duration, params xxdk.CMIXParams,
		pings []ed25519.PublicKey) (message.ID, rounds.Round, ephemeral.Id, error)

	// RegisterSentProgressCallback allows for the registration of a callback to
	// track the progress of an individual file upload. A SentProgressCallback
	// is auto-registered on Send; this function should be called when resuming
	// clients or registering extra callbacks.
	//
	// The callback will be called immediately when added to report the current
	// progress of the transfer. It will then call every time a file part
	// arrives, the transfer completes, or a fatal error occurs. It is called at
	// most once every period regardless of the number of progress updates.
	//
	// In the event that the client is closed and resumed, this function must be
	// used to re-register any callbacks previously registered with this
	// function or Send.
	//
	// The SentProgressCallback only indicates the progress of the file upload,
	// not the status of the file in the event model. You must rely on updates
	// from the event model to know when it can be retrieved.
	//
	// Parameters:
	//   - fileID - The unique ID of the file.
	//   - progressCB - A callback that reports the progress of the file upload.
	//     The callback is called once on initialization, on every progress
	//     update (or less if restricted by the period), or on fatal error.
	//   - period - A progress callback will be limited from triggering only
	//     once per period.
	RegisterSentProgressCallback(fileID ftCrypto.ID,
		progressCB SentProgressCallback, period time.Duration) error

	// RetryUpload retries uploading a failed file upload. Returns an error if
	// the transfer has not failed.
	//
	// This function should be called once a transfer errors out (as reported by
	// the progress callback).
	//
	// A new progress callback must be registered on retry. Any previously
	// registered callbacks are defunct when the upload fails.
	RetryUpload(fileID ftCrypto.ID,
		progressCB SentProgressCallback, period time.Duration) error

	// CloseSend deletes a file from the internal storage once a transfer has
	// completed or reached the retry limit. If neither of those condition are
	// met, an error is returned.
	//
	// This function should be called once a transfer completes or errors out
	// (as reported by the progress callback).
	CloseSend(fileID ftCrypto.ID) error

	// Download begins the download of the file described in the marshalled
	// FileInfo. The progress of the download is reported on the
	// ReceivedProgressCallback.
	//
	// Once the download completes, the file will be stored in the event model
	// with the given file ID and with the status
	// channels.ReceptionProcessingComplete.
	//
	// The ReceivedProgressCallback only indicates the progress of the file
	// download, not the status of the file in the event model. You must rely on
	// updates from the event model to know when it can be retrieved.
	//
	// Parameters:
	//   - fileInfo - The JSON of FileInfo received on a channel.
	//   - progressCB - A callback that reports the progress of the file
	//     download. The callback is called once on initialization, on every
	//     progress update (or less if restricted by the period), or on fatal
	//     error.
	//   - period - A progress callback will be limited from triggering only
	//     once per period.
	//
	// Returns:
	//   - A file ID that uniquely identifies this file.
	Download(fileInfo []byte, progressCB ReceivedProgressCallback,
		period time.Duration) (ftCrypto.ID, error)

	// RegisterReceivedProgressCallback allows for the registration of a
	// callback to track the progress of an individual file download.
	//
	// The callback will be called immediately when added to report the current
	// progress of the transfer. It will then call every time a file part is
	// received, the transfer completes, or a fatal error occurs. It is called
	// at most once every period regardless of the number of progress updates.
	//
	// In the event that the client is closed and resumed, this function must be
	// used to re-register any callbacks previously registered.
	//
	// Once the download completes, the file will be stored in the event model
	// with the given file ID and with the status Complete.
	//
	// The ReceivedProgressCallback only indicates the progress of the file
	// download, not the status of the file in the event model. You must rely on
	// updates from the event model to know when it can be retrieved.
	//
	// Parameters:
	//   - fileID - The unique ID of the file.
	//   - progressCB - A callback that reports the progress of the file upload.
	//     The callback is called once on initialization, on every progress
	//     update (or less if restricted by the period), or on fatal error.
	//   - period - A progress callback will be limited from triggering only
	//     once per period.
	RegisterReceivedProgressCallback(fileID ftCrypto.ID,
		progressCB ReceivedProgressCallback, period time.Duration) error
}

type FpStatus int

type FtE2e interface {
	GetStorage() storage.Session
	GetReceptionIdentity() xxdk.ReceptionIdentity
	GetCmix() cmix.Client
	GetRng() *fastRNG.StreamGenerator
	GetE2E() e2e.Handler
}

type ModelFile struct {
	// ID is the unique identifier of this file.
	ID ftCrypto.ID `json:"id"`

	// Link contains all the information needed to download the file data.
	// It is the JSON of [FileLink].
	Link []byte `json:"link"`

	// Data is the contents of the file.
	Data []byte `json:"fileData"`

	// Timestamp is the last time the file data, link, or status was modified.
	Timestamp time.Time `json:"timestamp"`

	// The current status of the file in the event model.
	Status Status `json:"status"`
}

type Params struct {
	// MaxThroughput is the maximum data transfer speed to send file parts (in
	// bytes per second). If set to 0, rate limiting will be disabled.
	MaxThroughput int `json:"maxThroughput"`

	// SendTimeout is the duration, in nanoseconds, before sending on a round
	// times out. It is recommended that SendTimeout is not changed from its
	// default.
	SendTimeout time.Duration `json:"sendTimeout"`

	// ResendWait is the duration, in nanoseconds, to wait to receive a file
	// part before resending it.
	ResendWait time.Duration `json:"resendWait"`

	// Cmix are the parameters used when sending a cMix message.
	Cmix cmix.CMIXParams `json:"cmix"`
}

type ReceivedProgressCallback func(completed bool, received, total uint16,
	rt ReceivedTransfer, fpt FilePartTracker, err error)

type ReceivedTransfer interface {
	Transfer
}

type SentProgressCallback func(completed bool, sent, received, total uint16,
	st SentTransfer, fpt FilePartTracker, err error)

type SentTransfer interface {
	GetRecipient() *id.ID
	Transfer
}

type Status uint8

type Transfer interface {
	GetFileID() ftCrypto.ID
	GetFileSize() uint32
	GetNumParts() uint16
}

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