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/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})
@@ -714,25 +772,17 @@ func (cli *Client) handleFrame(data []byte) {
 	}
 }
 
-func stopAndDrainTimer(timer *time.Timer) {
-	if !timer.Stop() {
-		select {
-		case <-timer.C:
-		default:
-		}
-	}
-}
-
 func (cli *Client) handlerQueueLoop(ctx context.Context) {
-	timer := time.NewTimer(5 * time.Minute)
-	stopAndDrainTimer(timer)
+	ticker := time.NewTicker(30 * time.Second)
+	ticker.Stop()
 	cli.Log.Debugf("Starting handler queue loop")
+Loop:
 	for {
 		select {
 		case node := <-cli.handlerQueue:
 			doneChan := make(chan struct{}, 1)
+			start := time.Now()
 			go func() {
-				start := time.Now()
 				cli.nodeHandlers[node.Tag](node)
 				duration := time.Since(start)
 				doneChan <- struct{}{}
@@ -740,13 +790,18 @@ func (cli *Client) handlerQueueLoop(ctx context.Context) {
 					cli.Log.Warnf("Node handling took %s for %s", duration, node.XMLString())
 				}
 			}()
-			timer.Reset(5 * time.Minute)
-			select {
-			case <-doneChan:
-				stopAndDrainTimer(timer)
-			case <-timer.C:
-				cli.Log.Warnf("Node handling is taking long for %s - continuing in background", node.XMLString())
+			ticker.Reset(30 * time.Second)
+			for i := 0; i < 10; i++ {
+				select {
+				case <-doneChan:
+					ticker.Stop()
+					continue Loop
+				case <-ticker.C:
+					cli.Log.Warnf("Node handling is taking long for %s (started %s ago)", node.XMLString(), time.Since(start))
+				}
 			}
+			cli.Log.Warnf("Continuing handling of %s in background as it's taking too long", node.XMLString())
+			ticker.Stop()
 		case <-ctx.Done():
 			cli.Log.Debugf("Closing handler queue loop")
 			return
@@ -779,7 +834,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 +844,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 +874,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 +883,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 +895,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 +911,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,43 @@ 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 {
+		// This should probably never happen, but check just in case.
+		cli.Log.Warnf("Stored LID doesn't match one in connect success: %s != %s", cli.Store.LID, nodeLID)
+		cli.Store.LID = types.EmptyJID
+	}
+	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 +200,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 +209,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 {