slidge-whatsapp 0.3.7__cp312-cp312-manylinux_2_41_aarch64.whl → 0.3.8__cp312-cp312-manylinux_2_41_aarch64.whl

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

@@ -68,7 +68,7 @@ func (cli *Client) cancelResponse(reqID string, ch chan *waBinary.Node) {
 	cli.responseWaitersLock.Unlock()
 }
 
-func (cli *Client) receiveResponse(data *waBinary.Node) bool {
+func (cli *Client) receiveResponse(ctx context.Context, data *waBinary.Node) bool {
 	id, ok := data.Attrs["id"].(string)
 	if !ok || (data.Tag != "iq" && data.Tag != "ack") {
 		return false
@@ -81,7 +81,10 @@ func (cli *Client) receiveResponse(data *waBinary.Node) bool {
 	}
 	delete(cli.responseWaiters, id)
 	cli.responseWaitersLock.Unlock()
-	waiter <- data
+	select {
+	case waiter <- data:
+	case <-ctx.Done():
+	}
 	return true
 }
 
@@ -103,10 +106,9 @@ type infoQuery struct {
 
 	Timeout time.Duration
 	NoRetry bool
-	Context context.Context
 }
 
-func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Node, []byte, error) {
+func (cli *Client) sendIQAsyncAndGetData(ctx context.Context, query *infoQuery) (<-chan *waBinary.Node, []byte, error) {
 	if cli == nil {
 		return nil, nil, ErrClientIsNil
 	}
@@ -128,7 +130,7 @@ func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Nod
 	if !query.Target.IsEmpty() {
 		attrs["target"] = query.Target
 	}
-	data, err := cli.sendNodeAndGetData(waBinary.Node{
+	data, err := cli.sendNodeAndGetData(ctx, waBinary.Node{
 		Tag:     "iq",
 		Attrs:   attrs,
 		Content: query.Content,
@@ -140,23 +142,20 @@ func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Nod
 	return waiter, data, nil
 }
 
-func (cli *Client) sendIQAsync(query infoQuery) (<-chan *waBinary.Node, error) {
-	ch, _, err := cli.sendIQAsyncAndGetData(&query)
+func (cli *Client) sendIQAsync(ctx context.Context, query infoQuery) (<-chan *waBinary.Node, error) {
+	ch, _, err := cli.sendIQAsyncAndGetData(ctx, &query)
 	return ch, err
 }
 
 const defaultRequestTimeout = 75 * time.Second
 
-func (cli *Client) sendIQ(query infoQuery) (*waBinary.Node, error) {
-	resChan, data, err := cli.sendIQAsyncAndGetData(&query)
-	if err != nil {
-		return nil, err
-	}
+func (cli *Client) sendIQ(ctx context.Context, query infoQuery) (*waBinary.Node, error) {
 	if query.Timeout == 0 {
 		query.Timeout = defaultRequestTimeout
 	}
-	if query.Context == nil {
-		query.Context = context.Background()
+	resChan, data, err := cli.sendIQAsyncAndGetData(ctx, &query)
+	if err != nil {
+		return nil, err
 	}
 	select {
 	case res := <-resChan:
@@ -164,7 +163,7 @@ func (cli *Client) sendIQ(query infoQuery) (*waBinary.Node, error) {
 			if query.NoRetry {
 				return nil, &DisconnectedError{Action: "info query", Node: res}
 			}
-			res, err = cli.retryFrame("info query", query.ID, data, res, query.Context, query.Timeout)
+			res, err = cli.retryFrame(ctx, "info query", query.ID, data, res, query.Timeout)
 			if err != nil {
 				return nil, err
 			}
@@ -176,14 +175,21 @@ func (cli *Client) sendIQ(query infoQuery) (*waBinary.Node, error) {
 			return res, parseIQError(res)
 		}
 		return res, nil
-	case <-query.Context.Done():
-		return nil, query.Context.Err()
+	case <-ctx.Done():
+		return nil, ctx.Err()
 	case <-time.After(query.Timeout):
 		return nil, ErrIQTimedOut
 	}
 }
 
-func (cli *Client) retryFrame(reqType, id string, data []byte, origResp *waBinary.Node, ctx context.Context, timeout time.Duration) (*waBinary.Node, error) {
+func (cli *Client) retryFrame(
+	ctx context.Context,
+	reqType,
+	id string,
+	data []byte,
+	origResp *waBinary.Node,
+	timeout time.Duration,
+) (*waBinary.Node, error) {
 	if isAuthErrorDisconnect(origResp) {
 		cli.Log.Debugf("%s (%s) was interrupted by websocket disconnection (%s), not retrying as it looks like an auth error", id, reqType, origResp.XMLString())
 		return nil, &DisconnectedError{Action: reqType, Node: origResp}
@@ -203,7 +209,7 @@ func (cli *Client) retryFrame(reqType, id string, data []byte, origResp *waBinar
 	}
 
 	respChan := cli.waitResponse(id)
-	err := sock.SendFrame(data)
+	err := sock.SendFrame(ctx, data)
 	if err != nil {
 		cli.cancelResponse(id, respChan)
 		return nil, err

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

@@ -295,7 +295,7 @@ func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Recei
 			{Tag: "franking", Content: []waBinary.Node{{Tag: "franking_tag", Content: frankingTag}}},
 		}
 	}
-	err = cli.sendNode(waBinary.Node{
+	err = cli.sendNode(ctx, waBinary.Node{
 		Tag:     "message",
 		Attrs:   attrs,
 		Content: content,
@@ -444,7 +444,7 @@ func (cli *Client) sendRetryReceipt(ctx context.Context, node *waBinary.Node, in
 			})
 		}
 	}
-	err := cli.sendNode(payload)
+	err := cli.sendNode(ctx, payload)
 	if err != nil {
 		cli.Log.Errorf("Failed to send retry receipt for %s: %v", id, err)
 	}

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

@@ -331,7 +331,7 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 			return
 		} else if toLID.IsEmpty() {
 			var info map[types.JID]types.UserInfo
-			info, err = cli.GetUserInfo([]types.JID{to})
+			info, err = cli.GetUserInfo(ctx, []types.JID{to})
 			if err != nil {
 				err = fmt.Errorf("failed to get user info for %s to fill LID cache: %w", to, err)
 				return
@@ -396,10 +396,10 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 		if req.Peer {
 			data, err = cli.sendPeerMessage(ctx, to, req.ID, message, &resp.DebugTimings)
 		} else {
-			data, err = cli.sendDM(ctx, ownID, to, req.ID, message, &resp.DebugTimings, extraParams)
+			phash, data, err = cli.sendDM(ctx, ownID, to, req.ID, message, &resp.DebugTimings, extraParams)
 		}
 	case types.NewsletterServer:
-		data, err = cli.sendNewsletter(to, req.ID, message, req.MediaHandle, &resp.DebugTimings)
+		data, err = cli.sendNewsletter(ctx, to, req.ID, message, req.MediaHandle, &resp.DebugTimings)
 	default:
 		err = fmt.Errorf("%w %s", ErrUnknownServer, to.Server)
 	}
@@ -429,7 +429,7 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 	resp.DebugTimings.Resp = time.Since(start)
 	if isDisconnectNode(respNode) {
 		start = time.Now()
-		respNode, err = cli.retryFrame("message send", req.ID, data, respNode, ctx, 0)
+		respNode, err = cli.retryFrame(ctx, "message send", req.ID, data, respNode, 0)
 		resp.DebugTimings.Retry = time.Since(start)
 		if err != nil {
 			return
@@ -443,11 +443,20 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 	}
 	expectedPHash := ag.OptionalString("phash")
 	if len(expectedPHash) > 0 && phash != expectedPHash {
-		cli.Log.Warnf("Server returned different participant list hash when sending to %s. Some devices may not have received the message.", to)
-		// TODO also invalidate device list caches
-		cli.groupCacheLock.Lock()
-		delete(cli.groupCache, to)
-		cli.groupCacheLock.Unlock()
+		cli.Log.Warnf("Server returned different participant list hash (%s != %s) when sending to %s. Some devices may not have received the message.", phash, expectedPHash, to)
+		switch to.Server {
+		case types.GroupServer:
+			// TODO also invalidate device list caches
+			cli.groupCacheLock.Lock()
+			delete(cli.groupCache, to)
+			cli.groupCacheLock.Unlock()
+		case types.BroadcastServer:
+			// TODO do something
+		case types.DefaultUserServer, types.HiddenUserServer, types.BotServer, types.HostedServer, types.HostedLIDServer:
+			cli.userDevicesCacheLock.Lock()
+			delete(cli.userDevicesCache, to)
+			cli.userDevicesCacheLock.Unlock()
+		}
 	}
 	return
 }
@@ -458,8 +467,8 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 // The return value is the timestamp of the message from the server.
 //
 // Deprecated: This method is deprecated in favor of BuildRevoke
-func (cli *Client) RevokeMessage(chat types.JID, id types.MessageID) (SendResponse, error) {
-	return cli.SendMessage(context.TODO(), chat, cli.BuildRevoke(chat, types.EmptyJID, id))
+func (cli *Client) RevokeMessage(ctx context.Context, chat types.JID, id types.MessageID) (SendResponse, error) {
+	return cli.SendMessage(ctx, chat, cli.BuildRevoke(chat, types.EmptyJID, id))
 }
 
 // BuildMessageKey builds a MessageKey object, which is used to refer to previous messages
@@ -618,13 +627,13 @@ func ParseDisappearingTimerString(val string) (time.Duration, bool) {
 // and in groups the server will just reject the change. You can use the DisappearingTimer<Duration> constants for convenience.
 //
 // In groups, the server will echo the change as a notification, so it'll show up as a *events.GroupInfo update.
-func (cli *Client) SetDisappearingTimer(chat types.JID, timer time.Duration, settingTS time.Time) (err error) {
+func (cli *Client) SetDisappearingTimer(ctx context.Context, chat types.JID, timer time.Duration, settingTS time.Time) (err error) {
 	switch chat.Server {
 	case types.DefaultUserServer, types.HiddenUserServer:
 		if settingTS.IsZero() {
 			settingTS = time.Now()
 		}
-		_, err = cli.SendMessage(context.TODO(), chat, &waE2E.Message{
+		_, err = cli.SendMessage(ctx, chat, &waE2E.Message{
 			ProtocolMessage: &waE2E.ProtocolMessage{
 				Type:                      waE2E.ProtocolMessage_EPHEMERAL_SETTING.Enum(),
 				EphemeralExpiration:       proto.Uint32(uint32(timer.Seconds())),
@@ -633,9 +642,9 @@ func (cli *Client) SetDisappearingTimer(chat types.JID, timer time.Duration, set
 		})
 	case types.GroupServer:
 		if timer == 0 {
-			_, err = cli.sendGroupIQ(context.TODO(), iqSet, chat, waBinary.Node{Tag: "not_ephemeral"})
+			_, err = cli.sendGroupIQ(ctx, iqSet, chat, waBinary.Node{Tag: "not_ephemeral"})
 		} else {
-			_, err = cli.sendGroupIQ(context.TODO(), iqSet, chat, waBinary.Node{
+			_, err = cli.sendGroupIQ(ctx, iqSet, chat, waBinary.Node{
 				Tag: "ephemeral",
 				Attrs: waBinary.Attrs{
 					"expiration": strconv.Itoa(int(timer.Seconds())),
@@ -663,6 +672,7 @@ func participantListHashV2(participants []types.JID) string {
 }
 
 func (cli *Client) sendNewsletter(
+	ctx context.Context,
 	to types.JID,
 	id types.MessageID,
 	message *waE2E.Message,
@@ -706,7 +716,7 @@ func (cli *Client) sendNewsletter(
 		Content: []waBinary.Node{plaintextNode},
 	}
 	start = time.Now()
-	data, err := cli.sendNodeAndGetData(node)
+	data, err := cli.sendNodeAndGetData(ctx, node)
 	timings.Send = time.Since(start)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send message node: %w", err)
@@ -787,7 +797,7 @@ func (cli *Client) sendGroup(
 	}
 
 	start = time.Now()
-	data, err := cli.sendNodeAndGetData(*node)
+	data, err := cli.sendNodeAndGetData(ctx, *node)
 	timings.Send = time.Since(start)
 	if err != nil {
 		return "", nil, fmt.Errorf("failed to send message node: %w", err)
@@ -807,7 +817,7 @@ func (cli *Client) sendPeerMessage(
 		return nil, err
 	}
 	start := time.Now()
-	data, err := cli.sendNodeAndGetData(*node)
+	data, err := cli.sendNodeAndGetData(ctx, *node)
 	timings.Send = time.Since(start)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send message node: %w", err)
@@ -823,21 +833,22 @@ func (cli *Client) sendDM(
 	message *waE2E.Message,
 	timings *MessageDebugTimings,
 	extraParams nodeExtraParams,
-) ([]byte, error) {
+) (string, []byte, error) {
 	start := time.Now()
 	messagePlaintext, deviceSentMessagePlaintext, err := marshalMessage(to, message)
 	timings.Marshal = time.Since(start)
 	if err != nil {
-		return nil, err
+		return "", nil, err
 	}
 
-	node, _, err := cli.prepareMessageNode(
+	node, allDevices, err := cli.prepareMessageNode(
 		ctx, to, id, message, []types.JID{to, ownID.ToNonAD()},
 		messagePlaintext, deviceSentMessagePlaintext, timings, extraParams,
 	)
 	if err != nil {
-		return nil, err
+		return "", nil, err
 	}
+	phash := participantListHashV2(allDevices)
 
 	if cli.shouldIncludeReportingToken(message) && message.GetMessageContextInfo().GetMessageSecret() != nil {
 		node.Content = append(node.GetChildren(), cli.getMessageReportingToken(messagePlaintext, message, ownID, to, id))
@@ -853,12 +864,12 @@ func (cli *Client) sendDM(
 	}
 
 	start = time.Now()
-	data, err := cli.sendNodeAndGetData(*node)
+	data, err := cli.sendNodeAndGetData(ctx, *node)
 	timings.Send = time.Since(start)
 	if err != nil {
-		return nil, fmt.Errorf("failed to send message node: %w", err)
+		return "", nil, fmt.Errorf("failed to send message node: %w", err)
 	}
-	return data, nil
+	return phash, data, nil
 }
 
 func getTypeFromMessage(msg *waE2E.Message) string {
@@ -1049,7 +1060,12 @@ func (cli *Client) preparePeerMessageNode(
 	if err != nil {
 		return nil, fmt.Errorf("failed to encrypt peer message for %s: %v", to, err)
 	}
-	content := []waBinary.Node{*encrypted}
+	content := []waBinary.Node{{
+		Tag: "meta",
+		Attrs: waBinary.Attrs{
+			"appdata": "default",
+		},
+	}, *encrypted}
 	if isPreKey && cli.MessengerConfig == nil {
 		content = append(content, cli.makeDeviceIdentityNode())
 	}
@@ -1117,7 +1133,7 @@ func (cli *Client) prepareMessageNode(
 	extraParams nodeExtraParams,
 ) (*waBinary.Node, []types.JID, error) {
 	start := time.Now()
-	allDevices, err := cli.GetUserDevicesContext(ctx, participants)
+	allDevices, err := cli.GetUserDevices(ctx, participants)
 	timings.GetDevices = time.Since(start)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to get device list: %w", err)

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

@@ -182,7 +182,7 @@ func (cli *Client) SendFBMessage(
 	resp.DebugTimings.Resp = time.Since(start)
 	if isDisconnectNode(respNode) {
 		start = time.Now()
-		respNode, err = cli.retryFrame("message send", req.ID, data, respNode, ctx, 0)
+		respNode, err = cli.retryFrame(ctx, "message send", req.ID, data, respNode, 0)
 		resp.DebugTimings.Retry = time.Since(start)
 		if err != nil {
 			return
@@ -293,7 +293,7 @@ func (cli *Client) sendGroupV3(
 	node.Content = append(node.GetChildren(), skMsg)
 
 	start = time.Now()
-	data, err := cli.sendNodeAndGetData(*node)
+	data, err := cli.sendNodeAndGetData(ctx, *node)
 	timings.Send = time.Since(start)
 	if err != nil {
 		return "", nil, fmt.Errorf("failed to send message node: %w", err)
@@ -324,7 +324,7 @@ func (cli *Client) sendDMV3(
 		return nil, "", err
 	}
 	start := time.Now()
-	data, err := cli.sendNodeAndGetData(*node)
+	data, err := cli.sendNodeAndGetData(ctx, *node)
 	timings.Send = time.Since(start)
 	if err != nil {
 		return nil, "", fmt.Errorf("failed to send message node: %w", err)
@@ -439,7 +439,7 @@ func (cli *Client) prepareMessageNodeV3(
 	timings *MessageDebugTimings,
 ) (*waBinary.Node, []types.JID, error) {
 	start := time.Now()
-	allDevices, err := cli.GetUserDevicesContext(ctx, participants)
+	allDevices, err := cli.GetUserDevices(ctx, participants)
 	timings.GetDevices = time.Since(start)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to get device list: %w", err)

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/socket/constants.go

@@ -32,7 +32,7 @@ const (
 var WAConnHeader = []byte{'W', 'A', WAMagicValue, token.DictVersion}
 
 const (
-	FrameMaxSize    = 2 << 23
+	FrameMaxSize    = 1 << 24
 	FrameLengthSize = 3
 )
 

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/socket/framesocket.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Tulir Asokan
+// Copyright (c) 2025 Tulir Asokan
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -12,29 +12,30 @@ import (
 	"fmt"
 	"net/http"
 	"sync"
-	"time"
 
-	"github.com/gorilla/websocket"
+	"github.com/coder/websocket"
 
 	waLog "go.mau.fi/whatsmeow/util/log"
 )
 
 type FrameSocket struct {
-	conn   *websocket.Conn
-	ctx    context.Context
-	cancel func()
-	log    waLog.Logger
-	lock   sync.Mutex
+	parentCtx context.Context
+	cancelCtx context.Context
+	cancel    context.CancelFunc
+	conn      *websocket.Conn
+	log       waLog.Logger
+	lock      sync.Mutex
 
 	URL         string
 	HTTPHeaders http.Header
+	HTTPClient  *http.Client
 
 	Frames       chan []byte
-	OnDisconnect func(remote bool)
-	WriteTimeout time.Duration
+	OnDisconnect func(ctx context.Context, remote bool)
 
 	Header []byte
-	Dialer websocket.Dialer
+
+	closed bool
 
 	incomingLength int
 	receivedLength int
@@ -42,17 +43,15 @@ type FrameSocket struct {
 	partialHeader  []byte
 }
 
-func NewFrameSocket(log waLog.Logger, dialer websocket.Dialer) *FrameSocket {
+func NewFrameSocket(log waLog.Logger, client *http.Client) *FrameSocket {
 	return &FrameSocket{
-		conn:   nil,
 		log:    log,
 		Header: WAConnHeader,
 		Frames: make(chan []byte),
 
 		URL:         URL,
 		HTTPHeaders: http.Header{"Origin": {Origin}},
-
-		Dialer: dialer,
+		HTTPClient:  client,
 	}
 }
 
@@ -60,11 +59,7 @@ func (fs *FrameSocket) IsConnected() bool {
 	return fs.conn != nil
 }
 
-func (fs *FrameSocket) Context() context.Context {
-	return fs.ctx
-}
-
-func (fs *FrameSocket) Close(code int) {
+func (fs *FrameSocket) Close(code websocket.StatusCode) {
 	fs.lock.Lock()
 	defer fs.lock.Unlock()
 
@@ -72,58 +67,56 @@ func (fs *FrameSocket) Close(code int) {
 		return
 	}
 
+	fs.closed = true
 	if code > 0 {
-		message := websocket.FormatCloseMessage(code, "")
-		err := fs.conn.WriteControl(websocket.CloseMessage, message, time.Now().Add(time.Second))
+		err := fs.conn.Close(code, "")
 		if err != nil {
-			fs.log.Warnf("Error sending close message: %v", err)
+			fs.log.Warnf("Error sending close to websocket: %v", err)
+		}
+	} else {
+		err := fs.conn.CloseNow()
+		if err != nil {
+			fs.log.Debugf("Error force closing websocket: %v", err)
 		}
-	}
-
-	fs.cancel()
-	err := fs.conn.Close()
-	if err != nil {
-		fs.log.Errorf("Error closing websocket: %v", err)
 	}
 	fs.conn = nil
-	fs.ctx = nil
+	fs.cancel()
 	fs.cancel = nil
 	if fs.OnDisconnect != nil {
-		go fs.OnDisconnect(code == 0)
+		go fs.OnDisconnect(fs.parentCtx, code == 0)
 	}
 }
 
-func (fs *FrameSocket) Connect() error {
+func (fs *FrameSocket) Connect(ctx context.Context) error {
 	fs.lock.Lock()
 	defer fs.lock.Unlock()
-
 	if fs.conn != nil {
 		return ErrSocketAlreadyOpen
 	}
-	ctx, cancel := context.WithCancel(context.Background())
+	fs.parentCtx = ctx
+	fs.cancelCtx, fs.cancel = context.WithCancel(ctx)
 
 	fs.log.Debugf("Dialing %s", fs.URL)
-	conn, _, err := fs.Dialer.Dial(fs.URL, fs.HTTPHeaders)
+	conn, _, err := websocket.Dial(ctx, fs.URL, &websocket.DialOptions{
+		HTTPClient: fs.HTTPClient,
+		HTTPHeader: fs.HTTPHeaders,
+	})
 	if err != nil {
-		cancel()
-		return fmt.Errorf("couldn't dial whatsapp web websocket: %w", err)
+		fs.cancel()
+		return fmt.Errorf("failed to dial whatsapp web websocket: %w", err)
 	}
+	conn.SetReadLimit(FrameMaxSize)
 
-	fs.ctx, fs.cancel = ctx, cancel
 	fs.conn = conn
-	conn.SetCloseHandler(func(code int, text string) error {
-		fs.log.Debugf("Server closed websocket with status %d/%s", code, text)
-		cancel()
-		// from default CloseHandler
-		message := websocket.FormatCloseMessage(code, "")
-		_ = conn.WriteControl(websocket.CloseMessage, message, time.Now().Add(time.Second))
-		return nil
-	})
 
 	go fs.readPump(conn, ctx)
 	return nil
 }
 
+func (fs *FrameSocket) Context() context.Context {
+	return fs.cancelCtx
+}
+
 func (fs *FrameSocket) SendFrame(data []byte) error {
 	conn := fs.conn
 	if conn == nil {
@@ -153,13 +146,7 @@ func (fs *FrameSocket) SendFrame(data []byte) error {
 	// Copy actual frame data
 	copy(wholeFrame[headerLength+FrameLengthSize:], data)
 
-	if fs.WriteTimeout > 0 {
-		err := conn.SetWriteDeadline(time.Now().Add(fs.WriteTimeout))
-		if err != nil {
-			fs.log.Warnf("Failed to set write deadline: %v", err)
-		}
-	}
-	return conn.WriteMessage(websocket.BinaryMessage, wholeFrame)
+	return conn.Write(fs.cancelCtx, websocket.MessageBinary, wholeFrame)
 }
 
 func (fs *FrameSocket) frameComplete() {
@@ -219,14 +206,14 @@ func (fs *FrameSocket) readPump(conn *websocket.Conn, ctx context.Context) {
 		go fs.Close(0)
 	}()
 	for {
-		msgType, data, err := conn.ReadMessage()
+		msgType, data, err := conn.Read(ctx)
 		if err != nil {
 			// Ignore the error if the context has been closed
-			if !errors.Is(ctx.Err(), context.Canceled) {
+			if !fs.closed && !errors.Is(ctx.Err(), context.Canceled) {
 				fs.log.Errorf("Error reading from websocket: %v", err)
 			}
 			return
-		} else if msgType != websocket.BinaryMessage {
+		} else if msgType != websocket.MessageBinary {
 			fs.log.Warnf("Got unexpected websocket message type %d", msgType)
 			continue
 		}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/socket/noisehandshake.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Tulir Asokan
+// Copyright (c) 2025 Tulir Asokan
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -7,6 +7,7 @@
 package socket
 
 import (
+	"context"
 	"crypto/cipher"
 	"crypto/sha256"
 	"fmt"
@@ -74,14 +75,19 @@ func (nh *NoiseHandshake) Decrypt(ciphertext []byte) (plaintext []byte, err erro
 	return
 }
 
-func (nh *NoiseHandshake) Finish(fs *FrameSocket, frameHandler FrameHandler, disconnectHandler DisconnectHandler) (*NoiseSocket, error) {
+func (nh *NoiseHandshake) Finish(
+	ctx context.Context,
+	fs *FrameSocket,
+	frameHandler FrameHandler,
+	disconnectHandler DisconnectHandler,
+) (*NoiseSocket, error) {
 	if write, read, err := nh.extractAndExpand(nh.salt, nil); err != nil {
 		return nil, fmt.Errorf("failed to extract final keys: %w", err)
 	} else if writeKey, err := gcmutil.Prepare(write); err != nil {
 		return nil, fmt.Errorf("failed to create final write cipher: %w", err)
 	} else if readKey, err := gcmutil.Prepare(read); err != nil {
 		return nil, fmt.Errorf("failed to create final read cipher: %w", err)
-	} else if ns, err := newNoiseSocket(fs, writeKey, readKey, frameHandler, disconnectHandler); err != nil {
+	} else if ns, err := newNoiseSocket(ctx, fs, writeKey, readKey, frameHandler, disconnectHandler); err != nil {
 		return nil, fmt.Errorf("failed to create noise socket: %w", err)
 	} else {
 		return ns, nil