package main
import (
- "cmp"
"context"
+ "database/sql"
"errors"
"fmt"
- "log"
- "maps"
+ "log/slog"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"time"
- "unicode"
"go.mau.fi/whatsmeow"
+ "go.mau.fi/whatsmeow/proto/waCompanionReg"
+ "go.mau.fi/whatsmeow/proto/waE2E"
"go.mau.fi/whatsmeow/store"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
"go.mau.fi/whatsmeow/types/events"
waLog "go.mau.fi/whatsmeow/util/log"
- "golang.org/x/text/runes"
- "golang.org/x/text/transform"
- "golang.org/x/text/unicode/norm"
-
// The session store of the library opens SQLite with this pure Go
// driver.
_ "modernc.org/sqlite"
// whatsappTimeLayout is the layout of the times in the answers.
whatsappTimeLayout = "2006-01-02 15:04"
- // whatsappPairTime is the longest time of a pairing. The library closes
- // the pairing connection after about 160 seconds.
- whatsappPairTime = 3 * time.Minute
+ // whatsappPairTimeout is the longest time of a pairing. The library
+ // closes the pairing connection after about 160 seconds.
+ whatsappPairTimeout = 3 * time.Minute
- // whatsappLogoutTime is the longest time of the logout call of an
+ // whatsappLogoutTimeout is the longest time of the logout call of an
// unlink.
- whatsappLogoutTime = 30 * time.Second
+ whatsappLogoutTimeout = 30 * time.Second
+
+ // whatsappOutageNoticeDelay is the delay from a disconnection to its
+ // notice to the user.
+ whatsappOutageNoticeDelay = 10 * time.Minute
+
+ // whatsappRetryDelay is the first wait after a failed starting
+ // connection.
+ whatsappRetryDelay = 2 * time.Second
- // whatsappNoticeDelay is how long a disconnection lasts before the user
- // gets a notice.
- whatsappNoticeDelay = 10 * time.Minute
+ // whatsappRetryLimit is the longest wait between starting connections.
+ whatsappRetryLimit = 5 * time.Minute
// whatsappRequests is the number of pair and unlink commands that can
// wait for Run.
whatsappRequests = 8
- // whatsappSource is the source of the work events of the batches.
- whatsappSource = "whatsapp"
-
- // whatsappLookupTime is the longest time of a read of the names in the
- // session database or of the groups from WhatsApp.
- whatsappLookupTime = 10 * time.Second
-
- // whatsappGroupsRefresh is the shortest time between two reads of the
- // groups from WhatsApp for a group with no name.
- whatsappGroupsRefresh = time.Minute
-
- // whatsappUnknownGroup is the name of a group whose name is not known.
- whatsappUnknownGroup = "A group with no known name"
-
- // whatsappCatchupLimit is the longest wait for the end of the catch-up
- // after a connection.
- whatsappCatchupLimit = time.Minute
-
- // whatsappGroupsAge is how long whatsapp_find uses the groups that it
- // read from WhatsApp.
- whatsappGroupsAge = time.Hour
-
- // whatsappFindMatches is the most matches of whatsapp_find.
- whatsappFindMatches = 20
-
// whatsappNotLinked is the answer of a WhatsApp tool without a link.
whatsappNotLinked = "WhatsApp is not linked. Tell the user to run /whatsapp pair PHONE in the terminal or in Telegram."
-
- // whatsappNamesNotReady is the answer of whatsapp_find before the names
- // arrive from the phone.
- whatsappNamesNotReady = "The names of the contacts and groups have not arrived from the phone yet. They come some minutes after the link. Try again later."
)
// WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error)
Logout(ctx context.Context) error
GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error)
+ Download(ctx context.Context, message whatsmeow.DownloadableMessage) ([]byte, error)
+ GenerateMessageID() types.MessageID
+ SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error)
}
// openWhatsApp opens the WhatsApp session in the data directory dir. Without
// the account, so a file that another user can read is an error. The clock
// gives the times of the status, logger gets the failures, and newClient makes
// the client of a device with its event handler.
-func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {
+func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *slog.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) {
w := &WhatsApp{
- dir: filepath.Join(dir, whatsappDirName),
- clock: clock,
- logger: logger,
- newClient: newClient,
- noticeDelay: whatsappNoticeDelay,
- catchupLimit: whatsappCatchupLimit,
- requests: make(chan WhatsAppRequest, whatsappRequests),
- logouts: make(chan struct{}, 1),
- wake: make(chan struct{}, 1),
- failures: make(chan error, 1),
- groupNames: make(map[string]string),
+ ctx: ctx,
+ dir: filepath.Join(dir, whatsappDirName),
+ clock: clock,
+ logger: logger,
+ newClient: newClient,
+ requests: make(chan WhatsAppRequest, whatsappRequests),
+ logouts: make(chan struct{}, 1),
+ groups: newWhatsAppGroups(logger),
}
var err error
- w.batches, err = openWhatsAppBatches(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
+
+ w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName))
if err != nil {
return nil, err
}
+ w.inbox = newWhatsAppInbox(w.state, clock, w.groups, &ImageStore{dir: filepath.Join(dir, imageDirName)}, logger)
+
info, err := os.Stat(w.sessionPath())
if errors.Is(err, os.ErrNotExist) {
return w, nil
if w.device.ID != nil {
w.linked = true
- w.catchingUp = true
+ w.inbox.waitForCatchup()
+
w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
}
// of the client that asked. A logout from the phone comes as an event of the
// library, and Run deletes the session. The mutex protects the session, the
// client, and the state of the connection, which the event handler of the
-// library changes from its own goroutines.
+// library changes from its own goroutines. The sessionMutex serializes session
+// creation, close, removal, and snapshots. It is held before mutex, and stays
+// held when removal releases mutex for client callbacks.
//
-// The text messages go into batches, one chat at a time, as WhatsAppBatches
-// says. Run logs each closed batch as a work message that starts with
-// [WhatsApp], and a batch that needs the user wakes the turn loop.
+// ctx is the caller context until Run sets its context for library callbacks.
+// The mutex protects it, so callbacks follow daemon cancellation.
//
-// After each connection, the servers send the messages that came while the
-// daemon was away, and then OfflineSyncCompleted. Until then, or until
-// catchupLimit passes, the closed batches wait in the state file. At the end of
-// the catch-up, Run closes all batches, logs them, and wakes the turn loop
-// once, so the whole catch-up gives one turn and not one turn for each chat.
-// The batches of the state file at the start wait for the first catch-up in the
-// same way. The event handler acknowledges a message only after the state file
-// holds it, so the servers send again a message that a crash lost. A batch
-// leaves the state file only after its work message is durable in the log. A
-// crash between the two makes the batch repeat once.
+// The inbox puts messages into batches and logs them, and groups holds the
+// names of the groups. Both get a WhatsAppLink from link for each call, so they
+// use the current device and client.
//
// The library logs nothing, because its log lines hold the ID of the own
// account, which is the phone number of the user. The own number and the own
// log, and those of private chats hold phone numbers, because the agent needs
// them to send.
type WhatsApp struct {
- dir string
- clock func() time.Time
- logger *log.Logger
- newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient
- noticeDelay time.Duration
- catchupLimit time.Duration
- requests chan WhatsAppRequest
- logouts chan struct{}
- wake chan struct{}
- failures chan error
- batches *WhatsAppBatches
-
+ ctx context.Context
+ dir string
+ clock func() time.Time
+ logger *slog.Logger
+ newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient
+ requests chan WhatsAppRequest
+ logouts chan struct{}
+ state *WhatsAppState
+ groups *WhatsAppGroups
+ inbox *WhatsAppInbox
+ routes *Routes
+
+ sessionMutex sync.Mutex
mutex sync.Mutex
container *sqlstore.Container
device *store.Device
own []string
notify func(Event)
connected bool
+ retrying bool
connectedAt time.Time
disconnectedAt time.Time
disconnections int
noticed bool
timer *time.Timer
closed bool
- groupNames map[string]string
- groupsAt time.Time
- groupsRead time.Time
- catchingUp bool
- caughtUp bool
- catchups int
- catchupTimer *time.Timer
}
// Run connects a linked device, logs the closed batches in l, runs the pair and
// unlink commands, and handles a logout from the phone, until ctx ends. Its
// notes go to the log of l, and notify gets the notices for all clients. A
-// failed first connection is logged, and the library tries again when the
-// failure is one of the network. Run returns the error of a write of the log or
-// of the state file, which stops the daemon, because then messages would be
-// lost.
+// failed first connection starts the same outage notice as a lost connection. A
+// timer in the select retries it with a doubled wait from 2 seconds to 5
+// minutes, without a retry goroutine or a wait that blocks commands or the
+// inbox. A connection, unlink, logout, or ctx end stops retries. The library
+// owns retries after a connection opens. Run returns the error of a write of
+// the log or of the state file, which stops the daemon, because then messages
+// would be lost.
func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error {
w.mutex.Lock()
+
+ w.ctx = ctx
w.notify = notify
linked := w.linked
+ w.retrying = linked
w.mutex.Unlock()
- if linked {
- w.connect(ctx)
+ timer := time.NewTimer(whatsappRetryDelay)
+ timer.Stop()
+ defer timer.Stop()
+
+ var retry <-chan time.Time
+
+ delay := whatsappRetryDelay
+ connect := func() {
+ retry = nil
+ if w.connect(ctx) {
+ timer.Reset(delay)
+
+ retry = timer.C
+ delay = min(2*delay, whatsappRetryLimit)
+ }
+ }
+
+ stopRetry := func() {
+ timer.Stop()
+
+ retry = nil
+
+ w.mutex.Lock()
+
+ w.retrying = false
+ w.mutex.Unlock()
}
var pairing sync.WaitGroup
+
cancel := func() {}
defer func() {
cancel()
w.close()
}()
+ if linked {
+ connect()
+ }
+
for {
- err := w.deliver(ctx, l, false)
+ err := w.inbox.deliver(ctx, l, w.link(), false)
if err != nil {
return err
}
- var due <-chan time.Time
- wait, open := w.batches.Wait(time.Now())
- if open {
- due = time.After(wait)
- }
-
select {
case <-ctx.Done():
return nil
- case err = <-w.failures:
+ case err = <-w.inbox.failures:
return err
- case <-w.wake:
- case <-due:
+ case <-w.inbox.wake:
+ case <-w.inbox.due():
+ case <-retry:
+ connect()
case <-w.logouts:
+ stopRetry()
+
err = w.loggedOut(ctx, l)
if err != nil {
return err
case request := <-w.requests:
cancel()
pairing.Wait()
+
cancel = func() {}
switch {
case request.unlink:
+ stopRetry()
+
err = w.unlink(ctx, l, request.answer)
if err != nil {
return err
case w.isLinked():
request.answer("WhatsApp is linked already. Run /whatsapp unlink first.")
default:
- pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTime)
+ pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTimeout)
cancel = cancelPair
pairing.Go(func() {
defer cancelPair()
- w.pair(pairCtx, l, request.phone, request.answer)
+ w.pair(pairCtx, ctx, l, request.phone, request.answer)
})
}
}
switch {
case len(fields) == 1 && fields[0] == "status":
answer(w.Status())
+
return
case len(fields) == 1 && fields[0] == "unlink":
request.unlink = true
phone, valid := whatsappPhone(strings.Join(fields[1:], ""))
if !valid {
answer("PHONE must be the number of your WhatsApp account with its country code: 7 to 15 digits, such as +15550001111.")
+
return
}
request.phone = phone
default:
answer(whatsappUsage)
+
return
}
}
// Status returns the state of the link: not linked, linked and connected, or
-// linked and disconnected, with the times of the connection. It never holds the
-// phone number.
+// linked and disconnected, with the times of the connection and the routes.
+// Route source IDs can hold the phone numbers of other chats.
func (w *WhatsApp) Status() string {
w.mutex.Lock()
defer w.mutex.Unlock()
+ routes := ""
+ if w.routes != nil {
+ listed := w.routes.List()
+ if listed != "No routes." {
+ routes = "\nWhatsApp routes:\n" + listed
+ }
+ }
+
switch {
case !w.linked:
- return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it."
+ return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it." + routes
case w.connected:
- return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "."
+ return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes
case w.disconnectedAt.IsZero():
- return "WhatsApp is linked and not connected yet."
+ return "WhatsApp is linked and not connected yet." + routes
case w.connectedAt.IsZero():
- return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "."
+ return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "." + routes
default:
- return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "."
+ return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes
+ }
+}
+
+// BackupSession writes a consistent SQLite snapshot to path while the session
+// cannot be created, closed, or removed. The source opens without creation
+// permission. No session file means no linked state to copy.
+func (w *WhatsApp) BackupSession(ctx context.Context, path string) (err error) {
+ w.sessionMutex.Lock()
+ defer w.sessionMutex.Unlock()
+
+ w.mutex.Lock()
+ defer w.mutex.Unlock()
+
+ _, err = os.Stat(w.sessionPath())
+ if errors.Is(err, os.ErrNotExist) {
+ return nil
+ }
+
+ if err != nil {
+ return fmt.Errorf("read session file: %w", err)
+ }
+
+ err = os.MkdirAll(filepath.Dir(path), 0o700)
+ if err != nil {
+ return fmt.Errorf("create session snapshot directory: %w", err)
+ }
+
+ address, err := whatsappSessionAddress(w.sessionPath())
+ if err != nil {
+ return fmt.Errorf("find session database: %w", err)
+ }
+
+ database, err := sql.Open("sqlite", address+"&mode=rw")
+ if err != nil {
+ return fmt.Errorf("open session snapshot source: %w", err)
+ }
+
+ defer func() {
+ err = errors.Join(err, database.Close())
+ }()
+
+ _, err = database.ExecContext(ctx, "VACUUM INTO ?", path)
+ if err != nil {
+ return fmt.Errorf("snapshot session database: %w", err)
+ }
+
+ err = os.Chmod(path, 0o600)
+ if err != nil {
+ return fmt.Errorf("set session snapshot mode: %w", err)
}
+
+ return nil
}
// Close closes the session database.
func (w *WhatsApp) Close() error {
+ w.sessionMutex.Lock()
+ defer w.sessionMutex.Unlock()
+
w.mutex.Lock()
defer w.mutex.Unlock()
return err
}
+// Find returns the answer of whatsapp_find for name, as whatsappFind says.
+func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
+ return whatsappFind(ctx, w.link(), w.groups, name)
+}
+
+// Send returns the answer of whatsapp_send for the send id of text to chat, as
+// whatsappSend says.
+func (w *WhatsApp) Send(ctx context.Context, id, chat, text string) (string, error) {
+ return whatsappSend(ctx, w.link(), w.groups, w.state, w.clock, id, chat, text)
+}
+
func (w *WhatsApp) sessionPath() string {
return filepath.Join(w.dir, whatsappSessionFileName)
}
return w.linked
}
-// connect makes the client of the linked device and connects it.
-func (w *WhatsApp) connect(ctx context.Context) {
+// link returns a copy of the link of the device: whether it is linked, the
+// device, the client, whether it is connected, and the own IDs.
+func (w *WhatsApp) link() WhatsAppLink {
+ w.mutex.Lock()
+ defer w.mutex.Unlock()
+
+ return WhatsAppLink{
+ linked: w.linked,
+ device: w.device,
+ client: w.client,
+ connected: w.connected,
+ own: slices.Clone(w.own),
+ }
+}
+
+// connect tries the starting connection of the linked device with one client.
+// It returns whether Run must retry. A failed call starts the shared outage
+// state and logs its redacted cause once, because a returned ConnectContext
+// error does not emit Disconnected. Connected logs recovery after
+// authentication.
+func (w *WhatsApp) connect(ctx context.Context) bool {
w.mutex.Lock()
- w.client = w.newClient(w.device, w.handle)
+
+ if ctx.Err() != nil || !w.linked || !w.retrying || w.closed {
+ w.mutex.Unlock()
+
+ return false
+ }
+
+ if w.client == nil {
+ w.client = w.newClient(w.device, w.handle)
+ }
+
client := w.client
w.mutex.Unlock()
err := client.ConnectContext(ctx)
- if err != nil {
- w.logger.Printf("connect: %s", w.redact(err.Error()))
+
+ w.mutex.Lock()
+
+ if err == nil || ctx.Err() != nil || !w.retrying || !w.linked {
+ w.retrying = false
+ w.mutex.Unlock()
+
+ return false
+ }
+
+ first := w.startOutage()
+ cause := whatsappRedact(w.own, err.Error())
+ w.mutex.Unlock()
+
+ if first {
+ w.logger.Warn("first connect failed, retrying", "err", cause)
+ }
+
+ return true
+}
+
+// startOutage starts the shared outage time and notice timer once. The caller
+// holds the mutex. Its result tells whether this is the first failure.
+func (w *WhatsApp) startOutage() bool {
+ first := w.linked && (w.connected || w.disconnectedAt.IsZero())
+ if first {
+ w.disconnectedAt = w.clock()
+ w.disconnections++
+ disconnections := w.disconnections
+ w.timer = time.AfterFunc(whatsappOutageNoticeDelay, func() {
+ w.disconnectedLong(disconnections)
+ })
}
+
+ w.connected = false
+
+ return first
}
// close ends the connection and the timer of the notice, and stops all notices.
func (w *WhatsApp) close() {
w.mutex.Lock()
+
w.closed = true
if w.timer != nil {
w.timer.Stop()
}
- if w.catchupTimer != nil {
- w.catchupTimer.Stop()
- }
-
client := w.client
w.client = nil
w.mutex.Unlock()
+ w.inbox.close()
+
if client != nil {
client.Disconnect()
}
return nil
}
- err := w.deliver(ctx, l, true)
+ w.logger.Error("logged out by the phone, run /whatsapp pair PHONE")
+
+ err := w.inbox.deliver(ctx, l, w.link(), true)
if err != nil {
return err
}
err = w.removeSession()
if err != nil {
- w.logger.Printf("delete the session after the logout: %v", err)
+ w.logger.Error("session delete failed", "err", err)
}
err = l.note("WhatsApp was unlinked from the phone.")
if err != nil {
- w.logger.Printf("note the logout: %v", err)
+ w.logger.Error("chat note failed", "err", err)
}
w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")
// file.
func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) error {
w.mutex.Lock()
+
linked := w.linked
client := w.client
w.mutex.Unlock()
if !linked {
answer("WhatsApp is not linked.")
+
return nil
}
- err := w.deliver(ctx, l, true)
+ err := w.inbox.deliver(ctx, l, w.link(), true)
if err != nil {
return err
}
var logoutErr error
+
if client != nil {
- ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
+ ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTimeout)
defer cancel()
logoutErr = client.Logout(ctx)
err = w.removeSession()
if err != nil {
answer("The unlink failed: " + w.redact(err.Error()))
+
return nil
}
+ w.logger.Info("unlinked")
+
err = l.note("WhatsApp is unlinked.")
if err != nil {
- w.logger.Printf("note the unlink: %v", err)
+ w.logger.Error("chat note failed", "err", err)
}
if client == nil || logoutErr != nil {
answer("WhatsApp is unlinked here, but the phone did not get the logout. In WhatsApp on your phone, open Linked devices and remove the device.")
- return nil
- }
-
- answer("WhatsApp is unlinked.")
-
- return nil
-}
-
-// deliver logs the closed batches in l in order, each as a work message of
-// whatsappSource, and wakes the loop once with the batches that start a turn. A
-// batch leaves the state file after its message is durable in the log. A group
-// with no name gets its name from WhatsApp first. During a catch-up it logs
-// nothing, and at its end it closes all batches first. With all, it closes and
-// logs all batches also during a catch-up.
-func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop, all bool) error {
- w.mutex.Lock()
- catchingUp := w.catchingUp
- caughtUp := w.caughtUp
- w.caughtUp = false
- w.mutex.Unlock()
- var err error
- switch {
- case all || caughtUp:
- err = w.batches.CloseAll()
- case catchingUp:
return nil
- default:
- _, err = w.batches.CloseDue(time.Now())
- }
-
- if err != nil {
- return err
- }
-
- var turns []Message
- for _, batch := range w.batches.Closed() {
- if batch.Chat.Group && batch.Chat.Name == "" {
- batch.Chat.Name = w.groupName(ctx, batch.Chat.ID)
- }
-
- message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")
- if err != nil {
- return fmt.Errorf("log a WhatsApp batch: %w", err)
- }
-
- // A stop of the daemon during the flush is no failure: the
- // batch stays in the state file and repeats once at the next
- // start.
- err = l.Flush(ctx)
- if ctx.Err() != nil {
- return nil
- }
-
- if err != nil {
- return fmt.Errorf("log a WhatsApp batch: %w", err)
- }
-
- err = w.batches.Remove(batch.Number)
- if err != nil {
- return err
- }
-
- if batch.Turn() {
- turns = append(turns, message)
- }
}
- l.Wake(turns...)
+ answer("WhatsApp is unlinked.")
return nil
}
-// groupName returns the name of the group id, or whatsappUnknownGroup. A group
-// that is not in the names of the groups reads the groups from WhatsApp again,
-// at most once in whatsappGroupsRefresh.
-func (w *WhatsApp) groupName(ctx context.Context, id string) string {
- w.mutex.Lock()
- name, found := w.groupNames[id]
- fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
- w.mutex.Unlock()
-
- if !found && !fresh {
- w.readGroups(ctx)
-
- w.mutex.Lock()
- name, found = w.groupNames[id]
- w.mutex.Unlock()
- }
-
- if !found || name == "" {
- return whatsappUnknownGroup
- }
-
- return name
-}
-
-// readGroups reads the names of the groups of the account from WhatsApp, and
-// tells if it could. They stay in memory only.
-func (w *WhatsApp) readGroups(ctx context.Context) bool {
- w.mutex.Lock()
- client := w.client
- w.mutex.Unlock()
-
- if client == nil {
- return false
- }
-
- ctx, cancel := context.WithTimeout(ctx, whatsappLookupTime)
- defer cancel()
-
- groups, err := client.GetJoinedGroups(ctx)
- if err != nil {
- w.logger.Printf("read the groups: %s", w.redact(err.Error()))
- }
-
- w.mutex.Lock()
- defer w.mutex.Unlock()
-
- w.groupsAt = time.Now()
- if err != nil {
- return false
- }
-
- w.groupsRead = w.groupsAt
- for _, group := range groups {
- w.groupNames[group.JID.String()] = group.Name
- }
-
- return true
-}
-
-// Find returns the contacts and the groups whose name contains name, with no
-// regard to case and accents, as lines "ID | name | contact" or "ID | name |
-// group", sorted by name. It gives at most whatsappFindMatches lines and the
-// number of the others. The contacts come from the session database, and the
-// groups from WhatsApp, read again after whatsappGroupsAge. When the groups
-// cannot be read and none are known, the answer says so. Before the names
-// arrive from the phone, it says that they are not ready.
-func (w *WhatsApp) Find(ctx context.Context, name string) (string, error) {
- w.mutex.Lock()
- linked := w.linked
- device := w.device
- own := slices.Clone(w.own)
- stale := time.Since(w.groupsRead) >= whatsappGroupsAge
- w.mutex.Unlock()
-
- if !linked {
- return whatsappNotLinked, nil
- }
-
- query := whatsappFold(name)
- if query == "" {
- return "", errors.New("name is empty: give a part of the name of the contact or the group")
- }
-
- contacts, err := device.Contacts.GetAllContacts(ctx)
- if err != nil {
- return "", fmt.Errorf("read the contacts: %s", w.redact(err.Error()))
- }
-
- read := !stale || w.readGroups(ctx)
- w.mutex.Lock()
- groups := maps.Clone(w.groupNames)
- w.mutex.Unlock()
-
- if len(contacts) == 0 && len(groups) == 0 {
- if !read {
- return "The names are not known yet, and WhatsApp is disconnected, so the groups cannot be read. Try again later.", nil
- }
-
- return whatsappNamesNotReady, nil
- }
-
- var matches []WhatsAppMatch
- for jid, contact := range contacts {
- names := []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName}
- shown := slices.IndexFunc(names, func(name string) bool {
- return name != ""
- })
-
- if slices.Contains(own, jid.User) || shown < 0 || !slices.ContainsFunc(names, func(name string) bool {
- return strings.Contains(whatsappFold(name), query)
- }) {
- continue
- }
-
- matches = append(matches, WhatsAppMatch{
- id: jid.ToNonAD().String(),
- name: names[shown],
- kind: "contact",
- })
- }
-
- for id, group := range groups {
- if strings.Contains(whatsappFold(group), query) {
- matches = append(matches, WhatsAppMatch{
- id: id,
- name: group,
- kind: "group",
- })
- }
- }
-
- return whatsappFindAnswer(name, matches, read || len(groups) > 0), nil
-}
-
// removeSession ends the connection, closes the session database, and deletes
-// its files.
+// its files. The session lock covers the cleanup after mutex is released, so a
+// snapshot or a new session cannot open files that cleanup removes.
func (w *WhatsApp) removeSession() error {
+ w.sessionMutex.Lock()
+ defer w.sessionMutex.Unlock()
+
w.mutex.Lock()
+
client := w.client
w.client = nil
w.linked = false
+ w.retrying = false
w.own = nil
w.connected = false
- w.catchingUp = false
+ w.disconnectedAt = time.Time{}
if w.timer != nil {
w.timer.Stop()
}
w.device = nil
w.mutex.Unlock()
+ w.inbox.stopCatchup()
+
if client != nil {
client.Disconnect()
}
var err error
+
if container != nil {
err = container.Close()
}
// number, an expired code, or a failure. A pairing that a new one ends gives no
// answer. A link notes "WhatsApp is linked." in the log of l, with no number.
// The client of a pairing that does not link is disconnected.
-func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer func(text string)) {
+//
+// ctx limits the pairing, but the connection uses runCtx, the context of Run.
+// The library keeps the context of the connection for its keep-alive, its event
+// handler, and its reconnections, and after the link the server ends the stream
+// and the library connects again. With ctx, the end of the pairing would stop
+// that reconnection, and the linked device would never connect.
+func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, answer func(text string)) {
device, err := w.newDevice(ctx)
if err != nil {
answer("The pairing failed: " + err.Error())
+
return
}
qr, err := client.GetQRChannel(ctx)
if err == nil {
- err = client.ConnectContext(ctx)
+ err = client.ConnectContext(runCtx)
}
if err != nil {
answer("The connection to WhatsApp failed: " + err.Error())
+
return
}
case item, open := <-qr:
if !open || item.Event != whatsmeow.QRChannelEventCode {
answer("WhatsApp did not start the pairing. Try again later.")
+
return
}
case <-ctx.Done():
return
}
+ // The server accepts only a display name of the form "Browser (OS)"
+ // with a common browser and OS, and refuses the pairing otherwise.
code, err := client.PairPhone(ctx, phone, true, whatsmeow.PairClientChrome, "Chrome (Linux)")
if err != nil {
answer("WhatsApp refused the pairing: " + err.Error() + ". Check the phone number and run /whatsapp pair PHONE again.")
+
return
}
for {
var item whatsmeow.QRChannelItem
+
open := true
select {
case item, open = <-qr:
switch {
case !open || item.Event == whatsmeow.QRChannelTimeout.Event:
answer(whatsappPairExpired)
+
return
case item.Event == whatsmeow.QRChannelEventCode:
continue
case item.Event == whatsmeow.QRChannelSuccess.Event:
linked = true
+
w.linkedBy(client)
+ w.logger.Info("linked")
err = l.note("WhatsApp is linked.")
if err != nil {
- w.logger.Printf("note the link: %v", err)
+ w.logger.Error("chat note failed", "err", err)
}
answer("WhatsApp is linked to +" + phone + ".")
return
default:
answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.")
+
return
}
}
// directory and the file of the session first, with their modes, when they do
// not exist.
func (w *WhatsApp) newDevice(ctx context.Context) (*store.Device, error) {
+ w.sessionMutex.Lock()
+ defer w.sessionMutex.Unlock()
+
w.mutex.Lock()
defer w.mutex.Unlock()
}
// handle takes one event of the library and tells if it was handled. A message
-// goes to receive. The names of the groups follow the events of the groups. A
-// connection starts a catch-up, which ends at OfflineSyncCompleted or after
-// catchupLimit. A disconnection keeps the time of its start while the library
-// tries again. After noticeDelay of a disconnection, all clients get one
-// notice, and they get one more when the connection comes back. A disconnection
-// that the library does not try again gives a notice at once.
+// goes to the inbox. The names of the groups follow the events of the groups. A
+// connection starts a catch-up of the inbox, which ends at OfflineSyncCompleted
+// or after whatsappCatchupTimeout. A disconnection keeps the time of its start
+// while Run or the library tries again. After whatsappOutageNoticeDelay of a
+// disconnection, all clients get one notice, and they get one more when the
+// connection comes back. A disconnection that the library does not try again
+// gives a notice at once.
+//
+// The log of the daemon gets one line for each change of the connection of the
+// linked device: connected, a failed first connection, a lost connection, and
+// connected again with the length of the outage. The retries of the library and
+// Run between them log nothing.
func (w *WhatsApp) handle(event any) bool {
- message, isMessage := event.(*events.Message)
- if isMessage {
- return w.receive(message)
- }
-
- var notice string
w.mutex.Lock()
+
+ ctx := w.ctx
+ w.mutex.Unlock()
+
switch event := event.(type) {
+ case *events.Message:
+ return w.inbox.receive(ctx, w.link(), event)
case *events.GroupInfo:
if event.Name != nil {
- w.groupNames[event.JID.String()] = event.Name.Name
+ w.groups.set(event.JID.String(), event.Name.Name)
}
+
+ return true
case *events.JoinedGroup:
- w.groupNames[event.JID.String()] = event.Name
+ w.groups.set(event.JID.String(), event.Name)
+
+ return true
+ case *events.OfflineSyncCompleted:
+ w.inbox.endCatchup()
+
+ return true
+ case *events.Connected:
+ w.inbox.startCatchup()
+ }
+
+ var notice, line string
+
+ level := slog.LevelInfo
+
+ var attrs []any
+
+ w.mutex.Lock()
+
+ switch event := event.(type) {
case *events.PairSuccess:
w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
case *events.Connected:
- w.connected = true
- w.connectedAt = w.clock()
- w.catchingUp = true
- w.catchups++
- catchups := w.catchups
- if w.catchupTimer != nil {
- w.catchupTimer.Stop()
+ switch {
+ case !w.linked || w.connected:
+ case w.disconnectedAt.IsZero():
+ line = "connected"
+ default:
+ line = "connected again"
+ attrs = append(attrs, "after", w.clock().Sub(w.disconnectedAt))
}
- w.catchupTimer = time.AfterFunc(w.catchupLimit, func() {
- w.caughtUpBy(catchups)
- })
+ w.connected = true
+ w.retrying = false
+ w.connectedAt = w.clock()
if w.timer != nil {
w.timer.Stop()
}
notice = "WhatsApp is connected again."
}
case *events.Disconnected:
- if w.linked && (w.connected || w.disconnectedAt.IsZero()) {
- w.disconnectedAt = w.clock()
- w.disconnections++
- disconnections := w.disconnections
- w.timer = time.AfterFunc(w.noticeDelay, func() {
- w.disconnectedLong(disconnections)
- })
+ connected := w.connected
+ if w.startOutage() {
+ level = slog.LevelWarn
+ line = "disconnected, retrying"
+ if !connected {
+ line = "first connect failed, retrying"
+ }
}
-
- w.connected = false
- case *events.OfflineSyncCompleted:
- w.endCatchup()
case *events.LoggedOut:
+ w.retrying = false
select {
case w.logouts <- struct{}{}:
default:
}
case events.PermanentDisconnect:
+ w.retrying = false
if w.linked {
w.connected = false
w.noticed = true
notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again."
+ level = slog.LevelError
+ line = "disconnected for good, restart to retry"
+ attrs = append(attrs, "err", whatsappRedact(w.own, event.PermanentDisconnectDescription()))
}
}
- w.mutex.Unlock()
-
- if notice != "" {
- w.broadcast(notice)
- }
-
- return true
-}
-
-// receive puts the text of event into its batch and wakes Run. It returns false
-// when the state file cannot hold the message, so that the library does not
-// acknowledge it, and Run stops the daemon. A message that is not text, or that
-// the batches do not take, is handled with nothing to do.
-func (w *WhatsApp) receive(event *events.Message) bool {
- ctx, cancel := context.WithTimeout(context.Background(), whatsappLookupTime)
- defer cancel()
-
- chat, message, found := w.message(ctx, event)
- if !found {
- return true
- }
-
- _, err := w.batches.Add(chat, message, time.Now())
- if err != nil {
- select {
- case w.failures <- err:
- default:
- }
-
- return false
- }
- select {
- case w.wake <- struct{}{}:
- default:
+ if w.closed {
+ line = ""
}
- return true
-}
-
-// message returns the chat and the batch message of event, or false when the
-// batches do not take it. They take the text of a private chat or a group, from
-// another person or from the user. They do not take media, reactions, edits,
-// deletions, view-once and disappearing messages, old history, status
-// broadcasts, channels, and the chat of the user with itself.
-//
-// A mention of the user becomes @you, another mention @NAME when the name is
-// known, and the own number and LID become OWN, so that they never go to the
-// log.
-func (w *WhatsApp) message(ctx context.Context, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
- w.mutex.Lock()
- device := w.device
- own := slices.Clone(w.own)
w.mutex.Unlock()
- info := event.Info
- chatJID := info.Chat.ToNonAD()
- switch {
- case device == nil:
- case event.IsEdit, info.Edit != "", event.IsEphemeral, event.IsViewOnce, event.SourceWebMsg != nil:
- case chatJID.Server != types.DefaultUserServer && chatJID.Server != types.HiddenUserServer && chatJID.Server != types.GroupServer:
- case slices.Contains(own, chatJID.User):
- default:
- return w.text(ctx, device, own, event)
- }
-
- return WhatsAppChat{}, WhatsAppMessage{}, false
-}
-
-// text returns the chat and the batch message of event, a message that the
-// batches take when it has text.
-func (w *WhatsApp) text(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) {
- info := event.Info
- text := event.Message.GetConversation()
- extended := event.Message.GetExtendedTextMessage()
- if text == "" {
- text = extended.GetText()
- }
-
- if strings.TrimSpace(text) == "" {
- return WhatsAppChat{}, WhatsAppMessage{}, false
- }
-
- contextInfo := extended.GetContextInfo()
- message := WhatsAppMessage{
- ID: info.ID,
- Time: info.Timestamp,
- Mine: info.IsFromMe,
- }
-
- if !message.Mine {
- message.Sender = whatsappContactName(ctx, device, info.Sender, info.PushName)
- }
-
- for _, mentioned := range contextInfo.GetMentionedJID() {
- jid, err := types.ParseJID(mentioned)
- switch {
- case err != nil:
- case slices.Contains(own, jid.User):
- message.Mention = true
- text = strings.ReplaceAll(text, "@"+jid.User, "@you")
- default:
- text = strings.ReplaceAll(text, "@"+jid.User, "@"+whatsappContactName(ctx, device, jid, ""))
- }
- }
-
- participant, err := types.ParseJID(contextInfo.GetParticipant())
- message.Reply = err == nil && slices.Contains(own, participant.User)
-
- for _, id := range own {
- text = strings.ReplaceAll(text, id, "OWN")
- }
-
- message.Text = text
- chatJID := info.Chat.ToNonAD()
- chat := WhatsAppChat{
- ID: chatJID.String(),
- Group: chatJID.Server == types.GroupServer,
- }
-
- if !chat.Group {
- push := info.PushName
- if message.Mine {
- push = ""
- }
-
- chat.Name = whatsappContactName(ctx, device, chatJID, push)
- }
-
- return chat, message, true
-}
-
-// caughtUpBy ends the catch-up of the connection with the number catchups, when
-// no later connection started a new one.
-func (w *WhatsApp) caughtUpBy(catchups int) {
- w.mutex.Lock()
- defer w.mutex.Unlock()
-
- if w.catchups == catchups {
- w.endCatchup()
- }
-}
-
-// endCatchup ends a running catch-up and wakes Run, which logs all batches. The
-// caller holds the mutex.
-func (w *WhatsApp) endCatchup() {
- if !w.catchingUp {
- return
+ if line != "" {
+ w.logger.Log(ctx, level, line, attrs...)
}
- w.catchingUp = false
- w.caughtUp = true
- if w.catchupTimer != nil {
- w.catchupTimer.Stop()
+ if notice != "" {
+ w.broadcast(notice)
}
- select {
- case w.wake <- struct{}{}:
- default:
- }
+ return true
}
// disconnectedLong gives the notice of a long disconnection, unless the
// disconnection with the number disconnections ended.
func (w *WhatsApp) disconnectedLong(disconnections int) {
w.mutex.Lock()
+
long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections
if long {
w.noticed = true
// broadcast gives text as a notice to all clients.
func (w *WhatsApp) broadcast(text string) {
w.mutex.Lock()
+
notify := w.notify
closed := w.closed
w.mutex.Unlock()
w.mutex.Lock()
defer w.mutex.Unlock()
- for _, id := range w.own {
- text = strings.ReplaceAll(text, id, "OWN")
- }
-
- return text
+ return whatsappRedact(w.own, text)
}
-// WhatsAppMatch is one contact or group of Find.
-type WhatsAppMatch struct {
- id string
- name string
- kind string
+// WhatsAppLink is a copy of the link of the device at one time, for the parts
+// of WhatsApp that do not own it: the groups, the batches, find, and send.
+type WhatsAppLink struct {
+ linked bool
+ device *store.Device
+ client WhatsAppClient
+ connected bool
+ own []string
}
// WhatsAppRequest is a pair or unlink command for Run, with the function that
answer func(text string)
}
+// whatsappSetDeviceProps sets the device properties that the library sends at
+// the pairing. They are global values of the library, so the daemon sets them
+// once before any client exists. The phone shows the linked device with the
+// name OneChat and a desktop icon only when the platform type is known.
+func whatsappSetDeviceProps() {
+ store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
+
+ store.DeviceProps.PlatformType = waCompanionReg.DeviceProps_DESKTOP.Enum()
+}
+
// whatsappNewClient returns the client of the library for device, with handle
-// as its event handler. The client tries again after a failed first connection,
-// acknowledges a message only after handle returns true, and downloads no old
-// history. The phone shows the device with the name OneChat.
+// as its event handler. Run owns failed starting connections of linked devices,
+// so only an unlinked device enables the initial retry of the library for
+// pairing. The library still retries a lost connection. The client acknowledges
+// a message only after handle returns true, and downloads no old history.
func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
- store.SetOSInfo("OneChat", [3]uint32{0, 1, 0})
client := whatsmeow.NewClient(device, waLog.Noop)
- client.InitialAutoReconnect = true
+ client.InitialAutoReconnect = device.ID == nil
client.SynchronousAck = true
client.ManualHistorySyncDownload = true
client.AddEventHandlerWithSuccessStatus(handle)
}
}
-// whatsappFold returns text in lower case with no accents and no space at its
-// ends, so that names match with no regard to case and accents.
-func whatsappFold(text string) string {
- folded, _, err := transform.String(transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC), text)
- if err != nil {
- folded = text
- }
-
- return strings.ToLower(strings.TrimSpace(folded))
-}
-
-// whatsappFindAnswer returns the answer of Find for name with matches. Without
-// groups, the answer says that it has no groups.
-func whatsappFindAnswer(name string, matches []WhatsAppMatch, groups bool) string {
- slices.SortFunc(matches, func(a, b WhatsAppMatch) int {
- return cmp.Or(strings.Compare(whatsappFold(a.name), whatsappFold(b.name)), strings.Compare(a.id, b.id))
- })
-
- var lines []string
- for _, match := range matches[:min(len(matches), whatsappFindMatches)] {
- lines = append(lines, match.id+" | "+match.name+" | "+match.kind)
- }
-
- if len(matches) == 0 {
- lines = append(lines, "No contact or group has a name with \""+name+"\".")
- }
-
- if len(matches) > whatsappFindMatches {
- lines = append(lines, fmt.Sprintf("%d more: give a longer part of the name.", len(matches)-whatsappFindMatches))
- }
-
- if !groups {
- lines = append(lines, "The groups are not in this answer, because WhatsApp is disconnected.")
- }
-
- return strings.Join(lines, "\n")
-}
-
// whatsappOwnIDs returns the own number and the own LID that are not empty.
func whatsappOwnIDs(ids ...string) []string {
var own []string
+
for _, id := range ids {
if id != "" {
own = append(own, id)
return own
}
+// whatsappRedact replaces each of the own IDs own in text with OWN.
+func whatsappRedact(own []string, text string) string {
+ for _, id := range own {
+ text = strings.ReplaceAll(text, id, "OWN")
+ }
+
+ return text
+}
+
// whatsappSessionAddress returns the SQLite address of the session database at
// path, with foreign keys on, as the library needs, and a wait for a busy
// database.
projects / onechat / blobdiff