slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl

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 {

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -44,6 +45,7 @@ const (
 	MediaHistory  MediaType = "WhatsApp History Keys"
 	MediaAppState MediaType = "WhatsApp App State Keys"
 
+	MediaStickerPack   MediaType = "WhatsApp Sticker Pack Keys"
 	MediaLinkThumbnail MediaType = "WhatsApp Link Thumbnail Keys"
 )
 
@@ -80,6 +82,7 @@ var (
 	_ DownloadableMessage   = (*waE2E.VideoMessage)(nil)
 	_ DownloadableMessage   = (*waE2E.DocumentMessage)(nil)
 	_ DownloadableMessage   = (*waE2E.StickerMessage)(nil)
+	_ DownloadableMessage   = (*waE2E.StickerPackMessage)(nil)
 	_ DownloadableMessage   = (*waHistorySync.StickerMetadata)(nil)
 	_ DownloadableMessage   = (*waE2E.HistorySyncNotification)(nil)
 	_ DownloadableMessage   = (*waServerSync.ExternalBlobReference)(nil)
@@ -109,6 +112,7 @@ var classToMediaType = map[protoreflect.Name]MediaType{
 	"StickerMessage":  MediaImage,
 	"StickerMetadata": MediaImage,
 
+	"StickerPackMessage":      MediaStickerPack,
 	"HistorySyncNotification": MediaHistory,
 	"ExternalBlobReference":   MediaAppState,
 }
@@ -125,25 +129,28 @@ var mediaTypeToMMSType = map[MediaType]string{
 	MediaHistory:  "md-msg-hist",
 	MediaAppState: "md-app-state",
 
+	MediaStickerPack:   "sticker-pack",
 	MediaLinkThumbnail: "thumbnail-link",
 }
 
 // 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) {
+//
+// Deprecated: it's recommended to find the specific message type you want to download manually and use the Download method instead.
+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
 	}
@@ -160,6 +167,10 @@ func getSize(msg DownloadableMessage) int {
 	}
 }
 
+// ReturnDownloadWarnings controls whether the Download function returns non-fatal validation warnings.
+// Currently, these include [ErrFileLengthMismatch] and [ErrInvalidMediaSHA256].
+var ReturnDownloadWarnings = true
+
 // DownloadThumbnail downloads a thumbnail from a message.
 //
 // This is primarily intended for downloading link preview thumbnails, which are in ExtendedTextMessage:
@@ -167,12 +178,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 +211,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 +227,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 +238,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,9 +266,14 @@ 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)
-		if err == nil || errors.Is(err, ErrFileLengthMismatch) || errors.Is(err, ErrInvalidMediaSHA256) ||
-			errors.Is(err, ErrMediaDownloadFailedWith403) || errors.Is(err, ErrMediaDownloadFailedWith404) || errors.Is(err, ErrMediaDownloadFailedWith410) {
+		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) ||
+			errors.Is(err, context.Canceled) {
 			return
 		} else if i >= len(mediaConn.Hosts)-1 {
 			return nil, fmt.Errorf("failed to download media from last host: %w", err)
@@ -256,10 +283,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
@@ -268,10 +303,12 @@ func (cli *Client) downloadAndDecrypt(url string, mediaKey []byte, appInfo Media
 
 	} else if data, err = cbcutil.Decrypt(cipherKey, iv, ciphertext); err != nil {
 		err = fmt.Errorf("failed to decrypt file: %w", err)
-	} else if fileLength >= 0 && len(data) != fileLength {
-		err = fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, len(data))
-	} else if len(fileSHA256) == 32 && sha256.Sum256(data) != *(*[32]byte)(fileSHA256) {
-		err = ErrInvalidMediaSHA256
+	} else if ReturnDownloadWarnings {
+		if fileLength >= 0 && len(data) != fileLength {
+			err = fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, len(data))
+		} else if len(fileSHA256) == 32 && sha256.Sum256(data) != *(*[32]byte)(fileSHA256) {
+			err = ErrInvalidMediaSHA256
+		}
 	}
 	return
 }
@@ -282,6 +319,9 @@ func getMediaKeys(mediaKey []byte, appInfo MediaType) (iv, cipherKey, macKey, re
 }
 
 func shouldRetryMediaDownload(err error) bool {
+	if errors.Is(err, context.Canceled) {
+		return false
+	}
 	var netErr net.Error
 	var httpErr DownloadHTTPError
 	return errors.As(err, &netErr) ||
@@ -289,12 +329,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 +345,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 +376,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 +388,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

@@ -25,6 +25,9 @@ var (
 
 	ErrAlreadyConnected = errors.New("websocket is already connected")
 
+	ErrPhoneNumberTooShort           = errors.New("phone number too short")
+	ErrPhoneNumberIsNotInternational = errors.New("international phone number required (must not start with 0)")
+
 	ErrQRAlreadyConnected = errors.New("GetQRChannel must be called before connecting")
 	ErrQRStoreContainsID  = errors.New("GetQRChannel can only be called when there's no user ID in the client's Store")
 
@@ -141,6 +144,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")
 )