slidge-whatsapp 0.2.5__cp313-cp313-manylinux_2_36_aarch64.whl → 0.2.6__cp313-cp313-manylinux_2_36_aarch64.whl

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

@@ -20,6 +20,7 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
+	"go.mau.fi/util/exhttp"
 	"go.mau.fi/util/random"
 	"golang.org/x/net/proxy"
 
@@ -67,13 +68,16 @@ type Client struct {
 	isLoggedIn            atomic.Bool
 	expectedDisconnect    atomic.Bool
 	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
 
@@ -120,10 +124,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
@@ -174,6 +178,12 @@ type Client struct {
 	RefreshCAT      func() error
 }
 
+type groupMetaCache struct {
+	AddressingMode             types.AddressingMode
+	CommunityAnnouncementGroup bool
+	Members                    []types.JID
+}
+
 type MessengerConfig struct {
 	UserAgent    string
 	BaseURL      string
@@ -226,8 +236,8 @@ func NewClient(deviceStore *store.Device, log waLog.Logger) *Client {
 
 		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),
@@ -378,11 +388,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 {
@@ -412,6 +425,17 @@ func (cli *Client) SetWSDialer(dialer *websocket.Dialer) {
 // Connect connects the client to the WhatsApp web websocket. After connection, it will either
 // authenticate if there's data in the device store, or emit a QREvent to set up a new link.
 func (cli *Client) Connect() error {
+	err := cli.connect()
+	if exhttp.IsNetworkError(err) && cli.InitialAutoReconnect && cli.EnableAutoReconnect {
+		cli.Log.Errorf("Initial connection failed but reconnecting in background")
+		go cli.dispatchEvent(&events.Disconnected{})
+		go cli.autoReconnect()
+		return nil
+	}
+	return err
+}
+
+func (cli *Client) connect() error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -510,7 +534,7 @@ func (cli *Client) autoReconnect() {
 		cli.Log.Debugf("Automatically reconnecting after %v", autoReconnectDelay)
 		cli.AutoReconnectErrors++
 		time.Sleep(autoReconnectDelay)
-		err := cli.Connect()
+		err := cli.connect()
 		if errors.Is(err, ErrAlreadyConnected) {
 			cli.Log.Debugf("Connect() said we're already connected after autoreconnect sleep")
 			return
@@ -568,7 +592,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 +618,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)
 	}
@@ -816,7 +840,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 +849,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 +861,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 +877,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 := context.TODO()
 	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)
 		}
@@ -92,6 +94,7 @@ func (cli *Client) handleIB(node *waBinary.Node) {
 }
 
 func (cli *Client) handleConnectFailure(node *waBinary.Node) {
+	ctx := context.TODO()
 	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)
 		}
@@ -148,24 +151,36 @@ func (cli *Client) handleConnectFailure(node *waBinary.Node) {
 }
 
 func (cli *Client) handleConnectSuccess(node *waBinary.Node) {
+	ctx := context.TODO()
 	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)
+		}
+		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 +193,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 +202,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,7 +93,7 @@ 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)
+		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) {
 			return err
@@ -91,10 +105,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
@@ -107,7 +129,7 @@ func (cli *Client) downloadAndDecryptToFile(url string, mediaKey []byte, appInfo
 		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) {
+	} 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)
@@ -119,12 +141,12 @@ func (cli *Client) downloadAndDecryptToFile(url string, mediaKey []byte, appInfo
 	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 +161,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 +188,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 {

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -129,21 +130,21 @@ var mediaTypeToMMSType = map[MediaType]string{
 }
 
 // DownloadAny loops through the downloadable parts of the given message and downloads the first non-nil item.
-func (cli *Client) DownloadAny(msg *waE2E.Message) (data []byte, err error) {
+func (cli *Client) DownloadAny(ctx context.Context, msg *waE2E.Message) (data []byte, err error) {
 	if msg == nil {
 		return nil, ErrNothingDownloadableFound
 	}
 	switch {
 	case msg.ImageMessage != nil:
-		return cli.Download(msg.ImageMessage)
+		return cli.Download(ctx, msg.ImageMessage)
 	case msg.VideoMessage != nil:
-		return cli.Download(msg.VideoMessage)
+		return cli.Download(ctx, msg.VideoMessage)
 	case msg.AudioMessage != nil:
-		return cli.Download(msg.AudioMessage)
+		return cli.Download(ctx, msg.AudioMessage)
 	case msg.DocumentMessage != nil:
-		return cli.Download(msg.DocumentMessage)
+		return cli.Download(ctx, msg.DocumentMessage)
 	case msg.StickerMessage != nil:
-		return cli.Download(msg.StickerMessage)
+		return cli.Download(ctx, msg.StickerMessage)
 	default:
 		return nil, ErrNothingDownloadableFound
 	}
@@ -167,12 +168,12 @@ func getSize(msg DownloadableMessage) int {
 //	var msg *waE2E.Message
 //	...
 //	thumbnailImageBytes, err := cli.DownloadThumbnail(msg.GetExtendedTextMessage())
-func (cli *Client) DownloadThumbnail(msg DownloadableThumbnail) ([]byte, error) {
+func (cli *Client) DownloadThumbnail(ctx context.Context, msg DownloadableThumbnail) ([]byte, error) {
 	mediaType, ok := classToThumbnailMediaType[msg.ProtoReflect().Descriptor().Name()]
 	if !ok {
 		return nil, fmt.Errorf("%w '%s'", ErrUnknownMediaType, string(msg.ProtoReflect().Descriptor().Name()))
 	} else if len(msg.GetThumbnailDirectPath()) > 0 {
-		return cli.DownloadMediaWithPath(msg.GetThumbnailDirectPath(), msg.GetThumbnailEncSHA256(), msg.GetThumbnailSHA256(), msg.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+		return cli.DownloadMediaWithPath(ctx, msg.GetThumbnailDirectPath(), msg.GetThumbnailEncSHA256(), msg.GetThumbnailSHA256(), msg.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
 	} else {
 		return nil, ErrNoURLPresent
 	}
@@ -200,7 +201,7 @@ func GetMediaType(msg DownloadableMessage) MediaType {
 //	imageData, err := cli.Download(msg.GetImageMessage())
 //
 // You can also use DownloadAny to download the first non-nil sub-message.
-func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
+func (cli *Client) Download(ctx context.Context, msg DownloadableMessage) ([]byte, error) {
 	if cli == nil {
 		return nil, ErrClientIsNil
 	}
@@ -216,9 +217,9 @@ func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
 		isWebWhatsappNetURL = strings.HasPrefix(url, "https://web.whatsapp.net")
 	}
 	if len(url) > 0 && !isWebWhatsappNetURL {
-		return cli.downloadAndDecrypt(url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256())
+		return cli.downloadAndDecrypt(ctx, url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256())
 	} else if len(msg.GetDirectPath()) > 0 {
-		return cli.DownloadMediaWithPath(msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType])
+		return cli.DownloadMediaWithPath(ctx, msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType])
 	} else {
 		if isWebWhatsappNetURL {
 			cli.Log.Warnf("Got a media message with a web.whatsapp.net URL (%s) and no direct path", url)
@@ -227,14 +228,25 @@ func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
 	}
 }
 
-func (cli *Client) DownloadFB(transport *waMediaTransport.WAMediaTransport_Integral, mediaType MediaType) ([]byte, error) {
-	return cli.DownloadMediaWithPath(transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+func (cli *Client) DownloadFB(
+	ctx context.Context,
+	transport *waMediaTransport.WAMediaTransport_Integral,
+	mediaType MediaType,
+) ([]byte, error) {
+	return cli.DownloadMediaWithPath(ctx, transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
 }
 
 // DownloadMediaWithPath downloads an attachment by manually specifying the path and encryption details.
-func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHash, mediaKey []byte, fileLength int, mediaType MediaType, mmsType string) (data []byte, err error) {
+func (cli *Client) DownloadMediaWithPath(
+	ctx context.Context,
+	directPath string,
+	encFileHash, fileHash, mediaKey []byte,
+	fileLength int,
+	mediaType MediaType,
+	mmsType string,
+) (data []byte, err error) {
 	var mediaConn *MediaConn
-	mediaConn, err = cli.refreshMediaConn(false)
+	mediaConn, err = cli.refreshMediaConn(ctx, false)
 	if err != nil {
 		return nil, fmt.Errorf("failed to refresh media connections: %w", err)
 	}
@@ -244,7 +256,7 @@ func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHas
 	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)
-		data, err = cli.downloadAndDecrypt(mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash)
+		data, err = cli.downloadAndDecrypt(ctx, mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash)
 		if err == nil || errors.Is(err, ErrFileLengthMismatch) || errors.Is(err, ErrInvalidMediaSHA256) ||
 			errors.Is(err, ErrMediaDownloadFailedWith403) || errors.Is(err, ErrMediaDownloadFailedWith404) || errors.Is(err, ErrMediaDownloadFailedWith410) {
 			return
@@ -256,10 +268,18 @@ func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHas
 	return
 }
 
-func (cli *Client) downloadAndDecrypt(url string, mediaKey []byte, appInfo MediaType, fileLength int, fileEncSHA256, fileSHA256 []byte) (data []byte, err error) {
+func (cli *Client) downloadAndDecrypt(
+	ctx context.Context,
+	url string,
+	mediaKey []byte,
+	appInfo MediaType,
+	fileLength int,
+	fileEncSHA256,
+	fileSHA256 []byte,
+) (data []byte, err error) {
 	iv, cipherKey, macKey, _ := getMediaKeys(mediaKey, appInfo)
 	var ciphertext, mac []byte
-	if ciphertext, mac, err = cli.downloadPossiblyEncryptedMediaWithRetries(url, fileEncSHA256); err != nil {
+	if ciphertext, mac, err = cli.downloadPossiblyEncryptedMediaWithRetries(ctx, url, fileEncSHA256); err != nil {
 
 	} else if mediaKey == nil && fileEncSHA256 == nil && mac == nil {
 		// Unencrypted media, just return the downloaded data
@@ -289,12 +309,12 @@ func shouldRetryMediaDownload(err error) bool {
 		(errors.As(err, &httpErr) && retryafter.Should(httpErr.StatusCode, true))
 }
 
-func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(url string, checksum []byte) (file, mac []byte, err error) {
+func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(ctx context.Context, url string, checksum []byte) (file, mac []byte, err error) {
 	for retryNum := 0; retryNum < 5; retryNum++ {
 		if checksum == nil {
-			file, err = cli.downloadMedia(url)
+			file, err = cli.downloadMedia(ctx, url)
 		} else {
-			file, mac, err = cli.downloadEncryptedMedia(url, checksum)
+			file, mac, err = cli.downloadEncryptedMedia(ctx, url, checksum)
 		}
 		if err == nil || !shouldRetryMediaDownload(err) {
 			return
@@ -305,13 +325,17 @@ func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(url string, checksu
 			retryDuration = retryafter.Parse(httpErr.Response.Header.Get("Retry-After"), retryDuration)
 		}
 		cli.Log.Warnf("Failed to download media due to network error: %v, retrying in %s...", err, retryDuration)
-		time.Sleep(retryDuration)
+		select {
+		case <-ctx.Done():
+			return nil, nil, ctx.Err()
+		case <-time.After(retryDuration):
+		}
 	}
 	return
 }
 
-func (cli *Client) doMediaDownloadRequest(url string) (*http.Response, error) {
-	req, err := http.NewRequest(http.MethodGet, url, nil)
+func (cli *Client) doMediaDownloadRequest(ctx context.Context, url string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to prepare request: %w", err)
 	}
@@ -332,8 +356,8 @@ func (cli *Client) doMediaDownloadRequest(url string) (*http.Response, error) {
 	return resp, nil
 }
 
-func (cli *Client) downloadMedia(url string) ([]byte, error) {
-	resp, err := cli.doMediaDownloadRequest(url)
+func (cli *Client) downloadMedia(ctx context.Context, url string) ([]byte, error) {
+	resp, err := cli.doMediaDownloadRequest(ctx, url)
 	if err != nil {
 		return nil, err
 	}
@@ -344,8 +368,8 @@ func (cli *Client) downloadMedia(url string) ([]byte, error) {
 
 const mediaHMACLength = 10
 
-func (cli *Client) downloadEncryptedMedia(url string, checksum []byte) (file, mac []byte, err error) {
-	data, err := cli.downloadMedia(url)
+func (cli *Client) downloadEncryptedMedia(ctx context.Context, url string, checksum []byte) (file, mac []byte, err error) {
+	data, err := cli.downloadMedia(ctx, url)
 	if err != nil {
 		return
 	} else if len(data) <= mediaHMACLength {

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

@@ -141,6 +141,7 @@ var (
 var (
 	ErrOriginalMessageSecretNotFound = errors.New("original message secret key not found")
 	ErrNotEncryptedReactionMessage   = errors.New("given message isn't an encrypted reaction message")
+	ErrNotEncryptedCommentMessage    = errors.New("given message isn't an encrypted comment message")
 	ErrNotPollUpdateMessage          = errors.New("given message isn't a poll update message")
 )