slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/client.go

@@ -20,6 +20,8 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
+	"go.mau.fi/util/exhttp"
+	"go.mau.fi/util/exsync"
 	"go.mau.fi/util/random"
 	"golang.org/x/net/proxy"
 
@@ -38,12 +40,13 @@ import (
 
 // EventHandler is a function that can handle events from WhatsApp.
 type EventHandler func(evt any)
+type EventHandlerWithSuccessStatus func(evt any) bool
 type nodeHandler func(node *waBinary.Node)
 
 var nextHandlerID uint32
 
 type wrappedEventHandler struct {
-	fn EventHandler
+	fn EventHandlerWithSuccessStatus
 	id uint32
 }
 
@@ -65,15 +68,18 @@ type Client struct {
 	wsDialer   *websocket.Dialer
 
 	isLoggedIn            atomic.Bool
-	expectedDisconnect    atomic.Bool
+	expectedDisconnect    *exsync.Event
 	EnableAutoReconnect   bool
+	InitialAutoReconnect  bool
 	LastSuccessfulConnect time.Time
 	AutoReconnectErrors   int
 	// AutoReconnectHook is called when auto-reconnection fails. If the function returns false,
 	// the client will not attempt to reconnect. The number of retries can be read from AutoReconnectErrors.
 	AutoReconnectHook func(error) bool
 	// If SynchronousAck is set, acks for messages will only be sent after all event handlers return.
-	SynchronousAck bool
+	SynchronousAck             bool
+	EnableDecryptedEventBuffer bool
+	lastDecryptedBufferClear   time.Time
 
 	DisableLoginAutoReconnect bool
 
@@ -92,6 +98,7 @@ type Client struct {
 
 	historySyncNotifications  chan *waE2E.HistorySyncNotification
 	historySyncHandlerStarted atomic.Bool
+	ManualHistorySyncDownload bool
 
 	uploadPreKeysLock sync.Mutex
 	lastPreKeyUpload  time.Time
@@ -120,10 +127,10 @@ type Client struct {
 
 	privacySettingsCache atomic.Value
 
-	groupParticipantsCache     map[types.JID][]types.JID
-	groupParticipantsCacheLock sync.Mutex
-	userDevicesCache           map[types.JID]deviceCache
-	userDevicesCacheLock       sync.Mutex
+	groupCache           map[types.JID]*groupMetaCache
+	groupCacheLock       sync.Mutex
+	userDevicesCache     map[types.JID]deviceCache
+	userDevicesCacheLock sync.Mutex
 
 	recentMessagesMap  map[recentMessageKey]RecentMessage
 	recentMessagesList [recentMessagesSize]recentMessageKey
@@ -155,6 +162,10 @@ type Client struct {
 	// Should SubscribePresence return an error if no privacy token is stored for the user?
 	ErrorOnSubscribePresenceWithoutToken bool
 
+	SendReportingTokens bool
+
+	BackgroundEventCtx context.Context
+
 	phoneLinkingCache *phoneLinkingCache
 
 	uniqueID  string
@@ -171,7 +182,13 @@ type Client struct {
 	// separate library for all the non-e2ee-related stuff like logging in.
 	// The library is currently embedded in mautrix-meta (https://github.com/mautrix/meta), but may be separated later.
 	MessengerConfig *MessengerConfig
-	RefreshCAT      func() error
+	RefreshCAT      func(context.Context) error
+}
+
+type groupMetaCache struct {
+	AddressingMode             types.AddressingMode
+	CommunityAnnouncementGroup bool
+	Members                    []types.JID
 }
 
 type MessengerConfig struct {
@@ -209,25 +226,26 @@ func NewClient(deviceStore *store.Device, log waLog.Logger) *Client {
 		http: &http.Client{
 			Transport: (http.DefaultTransport.(*http.Transport)).Clone(),
 		},
-		proxy:           http.ProxyFromEnvironment,
-		Store:           deviceStore,
-		Log:             log,
-		recvLog:         log.Sub("Recv"),
-		sendLog:         log.Sub("Send"),
-		uniqueID:        fmt.Sprintf("%d.%d-", uniqueIDPrefix[0], uniqueIDPrefix[1]),
-		responseWaiters: make(map[string]chan<- *waBinary.Node),
-		eventHandlers:   make([]wrappedEventHandler, 0, 1),
-		messageRetries:  make(map[string]int),
-		handlerQueue:    make(chan *waBinary.Node, handlerQueueSize),
-		appStateProc:    appstate.NewProcessor(deviceStore, log.Sub("AppState")),
-		socketWait:      make(chan struct{}),
+		proxy:              http.ProxyFromEnvironment,
+		Store:              deviceStore,
+		Log:                log,
+		recvLog:            log.Sub("Recv"),
+		sendLog:            log.Sub("Send"),
+		uniqueID:           fmt.Sprintf("%d.%d-", uniqueIDPrefix[0], uniqueIDPrefix[1]),
+		responseWaiters:    make(map[string]chan<- *waBinary.Node),
+		eventHandlers:      make([]wrappedEventHandler, 0, 1),
+		messageRetries:     make(map[string]int),
+		handlerQueue:       make(chan *waBinary.Node, handlerQueueSize),
+		appStateProc:       appstate.NewProcessor(deviceStore, log.Sub("AppState")),
+		socketWait:         make(chan struct{}),
+		expectedDisconnect: exsync.NewEvent(),
 
 		incomingRetryRequestCounter: make(map[incomingRetryKey]int),
 
 		historySyncNotifications: make(chan *waE2E.HistorySyncNotification, 32),
 
-		groupParticipantsCache: make(map[types.JID][]types.JID),
-		userDevicesCache:       make(map[types.JID]deviceCache),
+		groupCache:       make(map[types.JID]*groupMetaCache),
+		userDevicesCache: make(map[types.JID]deviceCache),
 
 		recentMessagesMap:      make(map[recentMessageKey]RecentMessage, recentMessagesSize),
 		sessionRecreateHistory: make(map[types.JID]time.Time),
@@ -238,6 +256,8 @@ func NewClient(deviceStore *store.Device, log waLog.Logger) *Client {
 
 		EnableAutoReconnect: true,
 		AutoTrustIdentity:   true,
+
+		BackgroundEventCtx: context.Background(),
 	}
 	cli.nodeHandlers = map[string]nodeHandler{
 		"message":      cli.handleEncryptedMessage,
@@ -378,11 +398,14 @@ func (cli *Client) getOwnID() types.JID {
 	if cli == nil {
 		return types.EmptyJID
 	}
-	id := cli.Store.ID
-	if id == nil {
+	return cli.Store.GetJID()
+}
+
+func (cli *Client) getOwnLID() types.JID {
+	if cli == nil {
 		return types.EmptyJID
 	}
-	return *id
+	return cli.Store.GetLID()
 }
 
 func (cli *Client) WaitForConnection(timeout time.Duration) bool {
@@ -398,6 +421,8 @@ func (cli *Client) WaitForConnection(timeout time.Duration) bool {
 		case <-ch:
 		case <-timeoutChan:
 			return false
+		case <-cli.expectedDisconnect.GetChan():
+			return false
 		}
 		cli.socketLock.RLock()
 	}
@@ -415,8 +440,28 @@ func (cli *Client) Connect() error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
+
+	cli.socketLock.Lock()
+	defer cli.socketLock.Unlock()
+
+	err := cli.unlockedConnect()
+	if exhttp.IsNetworkError(err) && cli.InitialAutoReconnect && cli.EnableAutoReconnect {
+		cli.Log.Errorf("Initial connection failed but reconnecting in background (%v)", err)
+		go cli.dispatchEvent(&events.Disconnected{})
+		go cli.autoReconnect()
+		return nil
+	}
+	return err
+}
+
+func (cli *Client) connect() error {
 	cli.socketLock.Lock()
 	defer cli.socketLock.Unlock()
+
+	return cli.unlockedConnect()
+}
+
+func (cli *Client) unlockedConnect() error {
 	if cli.socket != nil {
 		if !cli.socket.IsConnected() {
 			cli.unlockedDisconnect()
@@ -490,15 +535,15 @@ func (cli *Client) onDisconnect(ns *socket.NoiseSocket, remote bool) {
 }
 
 func (cli *Client) expectDisconnect() {
-	cli.expectedDisconnect.Store(true)
+	cli.expectedDisconnect.Set()
 }
 
 func (cli *Client) resetExpectedDisconnect() {
-	cli.expectedDisconnect.Store(false)
+	cli.expectedDisconnect.Clear()
 }
 
 func (cli *Client) isExpectedDisconnect() bool {
-	return cli.expectedDisconnect.Load()
+	return cli.expectedDisconnect.IsSet()
 }
 
 func (cli *Client) autoReconnect() {
@@ -509,12 +554,17 @@ func (cli *Client) autoReconnect() {
 		autoReconnectDelay := time.Duration(cli.AutoReconnectErrors) * 2 * time.Second
 		cli.Log.Debugf("Automatically reconnecting after %v", autoReconnectDelay)
 		cli.AutoReconnectErrors++
-		time.Sleep(autoReconnectDelay)
-		err := cli.Connect()
+		if cli.expectedDisconnect.WaitTimeout(autoReconnectDelay) {
+			return
+		}
+		err := cli.connect()
 		if errors.Is(err, ErrAlreadyConnected) {
 			cli.Log.Debugf("Connect() said we're already connected after autoreconnect sleep")
 			return
 		} else if err != nil {
+			if cli.expectedDisconnect.IsSet() {
+				return
+			}
 			cli.Log.Errorf("Error reconnecting after autoreconnect sleep: %v", err)
 			if cli.AutoReconnectHook != nil && !cli.AutoReconnectHook(err) {
 				cli.Log.Debugf("AutoReconnectHook returned false, not reconnecting")
@@ -543,10 +593,11 @@ func (cli *Client) IsConnected() bool {
 // This will not emit any events, the Disconnected event is only used when the
 // connection is closed by the server or a network error.
 func (cli *Client) Disconnect() {
-	if cli == nil || cli.socket == nil {
+	if cli == nil {
 		return
 	}
 	cli.socketLock.Lock()
+	cli.expectDisconnect()
 	cli.unlockedDisconnect()
 	cli.socketLock.Unlock()
 	cli.clearDelayedMessageRequests()
@@ -568,7 +619,7 @@ func (cli *Client) unlockedDisconnect() {
 //
 // Note that this will not emit any events. The LoggedOut event is only used for external logouts
 // (triggered by the user from the main device or by WhatsApp servers).
-func (cli *Client) Logout() error {
+func (cli *Client) Logout(ctx context.Context) error {
 	if cli == nil {
 		return ErrClientIsNil
 	} else if cli.MessengerConfig != nil {
@@ -594,7 +645,7 @@ func (cli *Client) Logout() error {
 		return fmt.Errorf("error sending logout request: %w", err)
 	}
 	cli.Disconnect()
-	err = cli.Store.Delete()
+	err = cli.Store.Delete(ctx)
 	if err != nil {
 		return fmt.Errorf("error deleting data from store: %w", err)
 	}
@@ -633,6 +684,13 @@ func (cli *Client) Logout() error {
 //		// Handle event and access mycli.WAClient
 //	}
 func (cli *Client) AddEventHandler(handler EventHandler) uint32 {
+	return cli.AddEventHandlerWithSuccessStatus(func(evt any) bool {
+		handler(evt)
+		return true
+	})
+}
+
+func (cli *Client) AddEventHandlerWithSuccessStatus(handler EventHandlerWithSuccessStatus) uint32 {
 	nextID := atomic.AddUint32(&nextHandlerID, 1)
 	cli.eventHandlersLock.Lock()
 	cli.eventHandlers = append(cli.eventHandlers, wrappedEventHandler{handler, nextID})
@@ -779,7 +837,7 @@ func (cli *Client) sendNode(node waBinary.Node) error {
 	return err
 }
 
-func (cli *Client) dispatchEvent(evt any) {
+func (cli *Client) dispatchEvent(evt any) (handlerFailed bool) {
 	cli.eventHandlersLock.RLock()
 	defer func() {
 		cli.eventHandlersLock.RUnlock()
@@ -789,8 +847,11 @@ func (cli *Client) dispatchEvent(evt any) {
 		}
 	}()
 	for _, handler := range cli.eventHandlers {
-		handler.fn(evt)
+		if !handler.fn(evt) {
+			return true
+		}
 	}
+	return false
 }
 
 // ParseWebMessage parses a WebMessageInfo object into *events.Message to match what real-time messages have.
@@ -816,7 +877,7 @@ func (cli *Client) ParseWebMessage(chatJID types.JID, webMsg *waWeb.WebMessageIn
 			IsFromMe: webMsg.GetKey().GetFromMe(),
 			IsGroup:  chatJID.Server == types.GroupServer,
 		},
-		ID:        webMsg.GetKey().GetId(),
+		ID:        webMsg.GetKey().GetID(),
 		PushName:  webMsg.GetPushName(),
 		Timestamp: time.Unix(int64(webMsg.GetMessageTimestamp()), 0),
 	}
@@ -825,7 +886,7 @@ func (cli *Client) ParseWebMessage(chatJID types.JID, webMsg *waWeb.WebMessageIn
 		if info.Sender.IsEmpty() {
 			return nil, ErrNotLoggedIn
 		}
-	} else if chatJID.Server == types.DefaultUserServer || chatJID.Server == types.NewsletterServer {
+	} else if chatJID.Server == types.DefaultUserServer || chatJID.Server == types.HiddenUserServer || chatJID.Server == types.NewsletterServer {
 		info.Sender = chatJID
 	} else if webMsg.GetParticipant() != "" {
 		info.Sender, err = types.ParseJID(webMsg.GetParticipant())
@@ -837,6 +898,10 @@ func (cli *Client) ParseWebMessage(chatJID types.JID, webMsg *waWeb.WebMessageIn
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse sender of message %s: %v", info.ID, err)
 	}
+	if pk := webMsg.GetCommentMetadata().GetCommentParentKey(); pk != nil {
+		info.MsgMetaInfo.ThreadMessageID = pk.GetID()
+		info.MsgMetaInfo.ThreadMessageSenderJID, _ = types.ParseJID(pk.GetParticipant())
+	}
 	evt := &events.Message{
 		RawMessage:   webMsg.GetMessage(),
 		SourceWebMsg: webMsg,
@@ -849,3 +914,20 @@ func (cli *Client) ParseWebMessage(chatJID types.JID, webMsg *waWeb.WebMessageIn
 	}
 	return evt, nil
 }
+
+func (cli *Client) StoreLIDPNMapping(ctx context.Context, first, second types.JID) {
+	var lid, pn types.JID
+	if first.Server == types.HiddenUserServer && second.Server == types.DefaultUserServer {
+		lid = first
+		pn = second
+	} else if first.Server == types.DefaultUserServer && second.Server == types.HiddenUserServer {
+		lid = second
+		pn = first
+	} else {
+		return
+	}
+	err := cli.Store.LIDs.PutLIDMapping(ctx, lid, pn)
+	if err != nil {
+		cli.Log.Errorf("Failed to store LID-PN mapping for %s -> %s: %v", lid, pn, err)
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/connectionevents.go

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"time"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
@@ -16,6 +17,7 @@ import (
 )
 
 func (cli *Client) handleStreamError(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
 	cli.isLoggedIn.Store(false)
 	cli.clearResponseWaiters(node)
 	code, _ := node.Attrs["code"].(string)
@@ -31,7 +33,7 @@ func (cli *Client) handleStreamError(node *waBinary.Node) {
 		cli.Log.Infof("Got 515 code, reconnecting...")
 		go func() {
 			cli.Disconnect()
-			err := cli.Connect()
+			err := cli.connect()
 			if err != nil {
 				cli.Log.Errorf("Failed to reconnect after 515 code: %v", err)
 			}
@@ -40,7 +42,7 @@ func (cli *Client) handleStreamError(node *waBinary.Node) {
 		cli.expectDisconnect()
 		cli.Log.Infof("Got device removed stream error, sending LoggedOut event and deleting session")
 		go cli.dispatchEvent(&events.LoggedOut{OnConnect: false, Reason: events.ConnectFailureLoggedOut})
-		err := cli.Store.Delete()
+		err := cli.Store.Delete(ctx)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete store after device_removed error: %v", err)
 		}
@@ -56,7 +58,7 @@ func (cli *Client) handleStreamError(node *waBinary.Node) {
 		cli.Log.Infof("Got %s stream error, refreshing CAT before reconnecting...", code)
 		cli.socketLock.RLock()
 		defer cli.socketLock.RUnlock()
-		err := cli.RefreshCAT()
+		err := cli.RefreshCAT(ctx)
 		if err != nil {
 			cli.Log.Errorf("Failed to refresh CAT: %v", err)
 			cli.expectDisconnect()
@@ -92,6 +94,7 @@ func (cli *Client) handleIB(node *waBinary.Node) {
 }
 
 func (cli *Client) handleConnectFailure(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
 	ag := node.AttrGetter()
 	reason := events.ConnectFailureReason(ag.Int("reason"))
 	message := ag.OptionalString("message")
@@ -118,7 +121,7 @@ func (cli *Client) handleConnectFailure(node *waBinary.Node) {
 	if reason.IsLoggedOut() {
 		cli.Log.Infof("Got %s connect failure, sending LoggedOut event and deleting session", reason)
 		go cli.dispatchEvent(&events.LoggedOut{OnConnect: true, Reason: reason})
-		err := cli.Store.Delete()
+		err := cli.Store.Delete(ctx)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete store after %d failure: %v", int(reason), err)
 		}
@@ -133,7 +136,7 @@ func (cli *Client) handleConnectFailure(node *waBinary.Node) {
 		go cli.dispatchEvent(&events.ClientOutdated{})
 	} else if reason == events.ConnectFailureCATInvalid || reason == events.ConnectFailureCATExpired {
 		cli.Log.Infof("Got %d/%s connect failure, refreshing CAT before reconnecting...", int(reason), message)
-		err := cli.RefreshCAT()
+		err := cli.RefreshCAT(ctx)
 		if err != nil {
 			cli.Log.Errorf("Failed to refresh CAT: %v", err)
 			cli.expectDisconnect()
@@ -148,24 +151,38 @@ func (cli *Client) handleConnectFailure(node *waBinary.Node) {
 }
 
 func (cli *Client) handleConnectSuccess(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
 	cli.Log.Infof("Successfully authenticated")
 	cli.LastSuccessfulConnect = time.Now()
 	cli.AutoReconnectErrors = 0
 	cli.isLoggedIn.Store(true)
+	nodeLID := node.AttrGetter().JID("lid")
+	if cli.Store.LID.IsEmpty() && !nodeLID.IsEmpty() {
+		cli.Store.LID = nodeLID
+		err := cli.Store.Save(ctx)
+		if err != nil {
+			cli.Log.Warnf("Failed to save device after updating LID: %v", err)
+		} else {
+			cli.Log.Infof("Updated LID to %s", cli.Store.LID)
+		}
+	}
+	// Some users are missing their own LID-PN mapping even though it's already in the device table,
+	// so do this unconditionally for a few months to ensure everyone gets the row.
+	cli.StoreLIDPNMapping(ctx, cli.Store.GetLID(), cli.Store.GetJID())
 	go func() {
-		if dbCount, err := cli.Store.PreKeys.UploadedPreKeyCount(); err != nil {
+		if dbCount, err := cli.Store.PreKeys.UploadedPreKeyCount(ctx); err != nil {
 			cli.Log.Errorf("Failed to get number of prekeys in database: %v", err)
-		} else if serverCount, err := cli.getServerPreKeyCount(); err != nil {
+		} else if serverCount, err := cli.getServerPreKeyCount(ctx); err != nil {
 			cli.Log.Warnf("Failed to get number of prekeys on server: %v", err)
 		} else {
 			cli.Log.Debugf("Database has %d prekeys, server says we have %d", dbCount, serverCount)
 			if serverCount < MinPreKeyCount || dbCount < MinPreKeyCount {
-				cli.uploadPreKeys()
-				sc, _ := cli.getServerPreKeyCount()
+				cli.uploadPreKeys(ctx)
+				sc, _ := cli.getServerPreKeyCount(ctx)
 				cli.Log.Debugf("Prekey count after upload: %d", sc)
 			}
 		}
-		err := cli.SetPassive(false)
+		err := cli.SetPassive(ctx, false)
 		if err != nil {
 			cli.Log.Warnf("Failed to send post-connect passive IQ: %v", err)
 		}
@@ -178,7 +195,7 @@ func (cli *Client) handleConnectSuccess(node *waBinary.Node) {
 //
 // This seems to mostly affect whether the device receives certain events.
 // By default, whatsmeow will automatically do SetPassive(false) after connecting.
-func (cli *Client) SetPassive(passive bool) error {
+func (cli *Client) SetPassive(ctx context.Context, passive bool) error {
 	tag := "active"
 	if passive {
 		tag = "passive"
@@ -187,6 +204,7 @@ func (cli *Client) SetPassive(passive bool) error {
 		Namespace: "passive",
 		Type:      "set",
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content:   []waBinary.Node{{Tag: tag}},
 	})
 	if err != nil {

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/download-to-file.go

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -37,7 +38,7 @@ type File interface {
 // DownloadToFile downloads the attachment from the given protobuf message.
 //
 // This is otherwise identical to [Download], but writes the attachment to a file instead of returning it as a byte slice.
-func (cli *Client) DownloadToFile(msg DownloadableMessage, file File) error {
+func (cli *Client) DownloadToFile(ctx context.Context, msg DownloadableMessage, file File) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -53,9 +54,9 @@ func (cli *Client) DownloadToFile(msg DownloadableMessage, file File) error {
 		isWebWhatsappNetURL = strings.HasPrefix(url, "https://web.whatsapp.net")
 	}
 	if len(url) > 0 && !isWebWhatsappNetURL {
-		return cli.downloadAndDecryptToFile(url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256(), file)
+		return cli.downloadAndDecryptToFile(ctx, url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256(), file)
 	} else if len(msg.GetDirectPath()) > 0 {
-		return cli.DownloadMediaWithPathToFile(msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType], file)
+		return cli.DownloadMediaWithPathToFile(ctx, msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType], file)
 	} else {
 		if isWebWhatsappNetURL {
 			cli.Log.Warnf("Got a media message with a web.whatsapp.net URL (%s) and no direct path", url)
@@ -64,12 +65,25 @@ func (cli *Client) DownloadToFile(msg DownloadableMessage, file File) error {
 	}
 }
 
-func (cli *Client) DownloadFBToFile(transport *waMediaTransport.WAMediaTransport_Integral, mediaType MediaType, file File) error {
-	return cli.DownloadMediaWithPathToFile(transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType], file)
+func (cli *Client) DownloadFBToFile(
+	ctx context.Context,
+	transport *waMediaTransport.WAMediaTransport_Integral,
+	mediaType MediaType,
+	file File,
+) error {
+	return cli.DownloadMediaWithPathToFile(ctx, transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType], file)
 }
 
-func (cli *Client) DownloadMediaWithPathToFile(directPath string, encFileHash, fileHash, mediaKey []byte, fileLength int, mediaType MediaType, mmsType string, file File) error {
-	mediaConn, err := cli.refreshMediaConn(false)
+func (cli *Client) DownloadMediaWithPathToFile(
+	ctx context.Context,
+	directPath string,
+	encFileHash, fileHash, mediaKey []byte,
+	fileLength int,
+	mediaType MediaType,
+	mmsType string,
+	file File,
+) error {
+	mediaConn, err := cli.refreshMediaConn(ctx, false)
 	if err != nil {
 		return fmt.Errorf("failed to refresh media connections: %w", err)
 	}
@@ -79,9 +93,14 @@ func (cli *Client) DownloadMediaWithPathToFile(directPath string, encFileHash, f
 	for i, host := range mediaConn.Hosts {
 		// TODO omit hash for unencrypted media?
 		mediaURL := fmt.Sprintf("https://%s%s&hash=%s&mms-type=%s&__wa-mms=", host.Hostname, directPath, base64.URLEncoding.EncodeToString(encFileHash), mmsType)
-		err = cli.downloadAndDecryptToFile(mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash, file)
-		if err == nil || errors.Is(err, ErrFileLengthMismatch) || errors.Is(err, ErrInvalidMediaSHA256) ||
-			errors.Is(err, ErrMediaDownloadFailedWith403) || errors.Is(err, ErrMediaDownloadFailedWith404) || errors.Is(err, ErrMediaDownloadFailedWith410) {
+		err = cli.downloadAndDecryptToFile(ctx, mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash, file)
+		if err == nil ||
+			errors.Is(err, ErrFileLengthMismatch) ||
+			errors.Is(err, ErrInvalidMediaSHA256) ||
+			errors.Is(err, ErrMediaDownloadFailedWith403) ||
+			errors.Is(err, ErrMediaDownloadFailedWith404) ||
+			errors.Is(err, ErrMediaDownloadFailedWith410) ||
+			errors.Is(err, context.Canceled) {
 			return err
 		} else if i >= len(mediaConn.Hosts)-1 {
 			return fmt.Errorf("failed to download media from last host: %w", err)
@@ -91,10 +110,18 @@ func (cli *Client) DownloadMediaWithPathToFile(directPath string, encFileHash, f
 	return err
 }
 
-func (cli *Client) downloadAndDecryptToFile(url string, mediaKey []byte, appInfo MediaType, fileLength int, fileEncSHA256, fileSHA256 []byte, file File) error {
+func (cli *Client) downloadAndDecryptToFile(
+	ctx context.Context,
+	url string,
+	mediaKey []byte,
+	appInfo MediaType,
+	fileLength int,
+	fileEncSHA256, fileSHA256 []byte,
+	file File,
+) error {
 	iv, cipherKey, macKey, _ := getMediaKeys(mediaKey, appInfo)
 	hasher := sha256.New()
-	if mac, err := cli.downloadPossiblyEncryptedMediaWithRetriesToFile(url, fileEncSHA256, file); err != nil {
+	if mac, err := cli.downloadPossiblyEncryptedMediaWithRetriesToFile(ctx, url, fileEncSHA256, file); err != nil {
 		return err
 	} else if mediaKey == nil && fileEncSHA256 == nil && mac == nil {
 		// Unencrypted media, just return the downloaded data
@@ -105,26 +132,28 @@ func (cli *Client) downloadAndDecryptToFile(url string, mediaKey []byte, appInfo
 		return fmt.Errorf("failed to seek to start of file after validating mac: %w", err)
 	} else if err = cbcutil.DecryptFile(cipherKey, iv, file); err != nil {
 		return fmt.Errorf("failed to decrypt file: %w", err)
-	} else if info, err := file.Stat(); err != nil {
-		return fmt.Errorf("failed to stat file: %w", err)
-	} else if info.Size() != int64(fileLength) {
-		return fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, info.Size())
-	} else if _, err = file.Seek(0, io.SeekStart); err != nil {
-		return fmt.Errorf("failed to seek to start of file after decrypting: %w", err)
-	} else if _, err = io.Copy(hasher, file); err != nil {
-		return fmt.Errorf("failed to hash file: %w", err)
-	} else if !hmac.Equal(fileSHA256, hasher.Sum(nil)) {
-		return ErrInvalidMediaSHA256
+	} else if ReturnDownloadWarnings {
+		if info, err := file.Stat(); err != nil {
+			return fmt.Errorf("failed to stat file: %w", err)
+		} else if fileLength >= 0 && info.Size() != int64(fileLength) {
+			return fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, info.Size())
+		} else if _, err = file.Seek(0, io.SeekStart); err != nil {
+			return fmt.Errorf("failed to seek to start of file after decrypting: %w", err)
+		} else if _, err = io.Copy(hasher, file); err != nil {
+			return fmt.Errorf("failed to hash file: %w", err)
+		} else if !hmac.Equal(fileSHA256, hasher.Sum(nil)) {
+			return ErrInvalidMediaSHA256
+		}
 	}
 	return nil
 }
 
-func (cli *Client) downloadPossiblyEncryptedMediaWithRetriesToFile(url string, checksum []byte, file File) (mac []byte, err error) {
+func (cli *Client) downloadPossiblyEncryptedMediaWithRetriesToFile(ctx context.Context, url string, checksum []byte, file File) (mac []byte, err error) {
 	for retryNum := 0; retryNum < 5; retryNum++ {
 		if checksum == nil {
-			_, _, err = cli.downloadMediaToFile(url, file)
+			_, _, err = cli.downloadMediaToFile(ctx, url, file)
 		} else {
-			mac, err = cli.downloadEncryptedMediaToFile(url, checksum, file)
+			mac, err = cli.downloadEncryptedMediaToFile(ctx, url, checksum, file)
 		}
 		if err == nil || !shouldRetryMediaDownload(err) {
 			return
@@ -139,13 +168,17 @@ func (cli *Client) downloadPossiblyEncryptedMediaWithRetriesToFile(url string, c
 		if err != nil {
 			return nil, fmt.Errorf("failed to seek to start of file to retry download: %w", err)
 		}
-		time.Sleep(retryDuration)
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		case <-time.After(retryDuration):
+		}
 	}
 	return
 }
 
-func (cli *Client) downloadMediaToFile(url string, file io.Writer) (int64, []byte, error) {
-	resp, err := cli.doMediaDownloadRequest(url)
+func (cli *Client) downloadMediaToFile(ctx context.Context, url string, file io.Writer) (int64, []byte, error) {
+	resp, err := cli.doMediaDownloadRequest(ctx, url)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -162,8 +195,8 @@ func (cli *Client) downloadMediaToFile(url string, file io.Writer) (int64, []byt
 	return n, hasher.Sum(nil), err
 }
 
-func (cli *Client) downloadEncryptedMediaToFile(url string, checksum []byte, file File) ([]byte, error) {
-	size, hash, err := cli.downloadMediaToFile(url, file)
+func (cli *Client) downloadEncryptedMediaToFile(ctx context.Context, url string, checksum []byte, file File) ([]byte, error) {
+	size, hash, err := cli.downloadMediaToFile(ctx, url, file)
 	if err != nil {
 		return nil, err
 	} else if size <= mediaHMACLength {