1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright (c) 2021 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
package whatsmeow
import (
"sync/atomic"
"time"
waBinary "go.mau.fi/whatsmeow/binary"
"go.mau.fi/whatsmeow/types"
"go.mau.fi/whatsmeow/types/events"
)
func (cli *Client) handleStreamError(node *waBinary.Node) {
atomic.StoreUint32(&cli.isLoggedIn, 0)
cli.clearResponseWaiters(node)
code, _ := node.Attrs["code"].(string)
conflict, _ := node.GetOptionalChildByTag("conflict")
conflictType := conflict.AttrGetter().OptionalString("type")
switch {
case code == "515":
cli.Log.Infof("Got 515 code, reconnecting...")
go func() {
cli.Disconnect()
err := cli.Connect()
if err != nil {
cli.Log.Errorf("Failed to reconnect after 515 code:", err)
}
}()
case code == "401" && conflictType == "device_removed":
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()
if err != nil {
cli.Log.Warnf("Failed to delete store after device_removed error: %v", err)
}
case conflictType == "replaced":
cli.expectDisconnect()
cli.Log.Infof("Got replaced stream error, sending StreamReplaced event")
go cli.dispatchEvent(&events.StreamReplaced{})
case code == "503":
// This seems to happen when the server wants to restart or something.
// The disconnection will be emitted as an events.Disconnected and then the auto-reconnect will do its thing.
cli.Log.Warnf("Got 503 stream error, assuming automatic reconnect will handle it")
default:
cli.Log.Errorf("Unknown stream error: %s", node.XMLString())
go cli.dispatchEvent(&events.StreamError{Code: code, Raw: node})
}
}
func (cli *Client) handleIB(node *waBinary.Node) {
children := node.GetChildren()
for _, child := range children {
ag := child.AttrGetter()
switch child.Tag {
case "downgrade_webclient":
go cli.dispatchEvent(&events.QRScannedWithoutMultidevice{})
case "offline_preview":
cli.dispatchEvent(&events.OfflineSyncPreview{
Total: ag.Int("count"),
AppDataChanges: ag.Int("appdata"),
Messages: ag.Int("message"),
Notifications: ag.Int("notification"),
Receipts: ag.Int("receipt"),
})
case "offline":
cli.dispatchEvent(&events.OfflineSyncCompleted{
Count: ag.Int("count"),
})
}
}
}
func (cli *Client) handleConnectFailure(node *waBinary.Node) {
ag := node.AttrGetter()
reason := events.ConnectFailureReason(ag.Int("reason"))
// Let the auto-reconnect happen for 503s, for all other failures block it
if reason != events.ConnectFailureServiceUnavailable {
cli.expectDisconnect()
}
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()
if err != nil {
cli.Log.Warnf("Failed to delete store after %d failure: %v", int(reason), err)
}
} else if reason == events.ConnectFailureTempBanned {
cli.Log.Warnf("Temporary ban connect failure: %s", node.XMLString())
go cli.dispatchEvent(&events.TemporaryBan{
Code: events.TempBanReason(ag.Int("code")),
Expire: time.Duration(ag.Int("expire")) * time.Second,
})
} else if reason == events.ConnectFailureClientOutdated {
cli.Log.Errorf("Client outdated (405) connect failure")
go cli.dispatchEvent(&events.ClientOutdated{})
} else if reason == events.ConnectFailureServiceUnavailable {
cli.Log.Warnf("Got 503 connect failure, assuming automatic reconnect will handle it")
} else {
cli.Log.Warnf("Unknown connect failure: %s", node.XMLString())
go cli.dispatchEvent(&events.ConnectFailure{Reason: reason, Raw: node})
}
}
func (cli *Client) handleConnectSuccess(node *waBinary.Node) {
cli.Log.Infof("Successfully authenticated")
cli.LastSuccessfulConnect = time.Now()
cli.AutoReconnectErrors = 0
atomic.StoreUint32(&cli.isLoggedIn, 1)
go func() {
if dbCount, err := cli.Store.PreKeys.UploadedPreKeyCount(); err != nil {
cli.Log.Errorf("Failed to get number of prekeys in database: %v", err)
} else if serverCount, err := cli.getServerPreKeyCount(); 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.Log.Debugf("Prekey count after upload: %d", sc)
}
}
err := cli.SetPassive(false)
if err != nil {
cli.Log.Warnf("Failed to send post-connect passive IQ: %v", err)
}
cli.dispatchEvent(&events.Connected{})
cli.closeSocketWaitChan()
}()
}
// SetPassive tells the WhatsApp server whether this device is passive or not.
//
// 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 {
tag := "active"
if passive {
tag = "passive"
}
_, err := cli.sendIQ(infoQuery{
Namespace: "passive",
Type: "set",
To: types.ServerJID,
Content: []waBinary.Node{{Tag: tag}},
})
if err != nil {
return err
}
return nil
}
|
