package main
import (
+ "cmp"
"context"
"errors"
"fmt"
"log"
+ "maps"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"time"
+ "unicode"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/store"
"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.
// 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
// 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) {
w := &WhatsApp{
- dir: filepath.Join(dir, whatsappDirName),
- clock: clock,
- logger: logger,
- newClient: newClient,
- noticeDelay: whatsappNoticeDelay,
- 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),
+ 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),
}
var err error
if w.device.ID != nil {
w.linked = true
+ w.catchingUp = true
w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
}
//
// 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. 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.
+// [WhatsApp], and a batch that needs the user wakes the turn loop.
+//
+// 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 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
- requests chan WhatsAppRequest
- logouts chan struct{}
- wake chan struct{}
- failures chan error
- batches *WhatsAppBatches
+ 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
mutex sync.Mutex
container *sqlstore.Container
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
}()
for {
- err := w.deliver(ctx, l)
+ err := w.deliver(ctx, l, false)
if err != nil {
return err
}
w.timer.Stop()
}
+ if w.catchupTimer != nil {
+ w.catchupTimer.Stop()
+ }
+
client := w.client
w.client = nil
w.mutex.Unlock()
return nil
}
- err := w.deliverAll(ctx, l)
+ err := w.deliver(ctx, l, true)
if err != nil {
return err
}
return nil
}
- err := w.deliverAll(ctx, l)
+ err := w.deliver(ctx, l, true)
if err != nil {
return err
}
}
// deliver logs the closed batches in l in order, each as a work message of
-// whatsappSource that wakes the loop when the batch starts 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.
-func (w *WhatsApp) deliver(ctx context.Context, l *TurnLoop) error {
- _, err := w.batches.CloseDue(time.Now())
+// 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)
}
- _, err = l.Work(whatsappSource, batch.Text(w.clock().Location()), "", batch.Turn())
+ message, err := l.Work(whatsappSource, batch.Text(w.clock().Location()), "")
if err != nil {
return fmt.Errorf("log a WhatsApp batch: %w", err)
}
if err != nil {
return err
}
- }
-
- return nil
-}
-// deliverAll closes every open batch and logs all of them.
-func (w *WhatsApp) deliverAll(ctx context.Context, l *TurnLoop) error {
- err := w.batches.CloseAll()
- if err != nil {
- return err
+ if batch.Turn() {
+ turns = append(turns, message)
+ }
}
- return w.deliver(ctx, l)
+ l.Wake(turns...)
+
+ return nil
}
// groupName returns the name of the group id, or whatsappUnknownGroup. A group
func (w *WhatsApp) groupName(ctx context.Context, id string) string {
w.mutex.Lock()
name, found := w.groupNames[id]
- client := w.client
fresh := time.Since(w.groupsAt) < whatsappGroupsRefresh
w.mutex.Unlock()
- if found {
- return name
+ if !found && !fresh {
+ w.readGroups(ctx)
+
+ w.mutex.Lock()
+ name, found = w.groupNames[id]
+ w.mutex.Unlock()
}
- if client == nil || fresh {
+ 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()
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
}
- name, found = w.groupNames[id]
- if !found || name == "" {
- return whatsappUnknownGroup
+ 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
}
- return name
+ 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
w.linked = false
w.own = nil
w.connected = false
+ w.catchingUp = false
if w.timer != nil {
w.timer.Stop()
}
// 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
-// 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.
+// 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.
func (w *WhatsApp) handle(event any) bool {
message, isMessage := event.(*events.Message)
if isMessage {
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()
+ }
+
+ w.catchupTimer = time.AfterFunc(w.catchupLimit, func() {
+ w.caughtUpBy(catchups)
+ })
if w.timer != nil {
w.timer.Stop()
}
}
w.connected = false
+ case *events.OfflineSyncCompleted:
+ w.endCatchup()
case *events.LoggedOut:
select {
case w.logouts <- struct{}{}:
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
+ }
+
+ w.catchingUp = false
+ w.caughtUp = true
+ if w.catchupTimer != nil {
+ w.catchupTimer.Stop()
+ }
+
+ select {
+ case w.wake <- struct{}{}:
+ default:
+ }
+}
+
// disconnectedLong gives the notice of a long disconnection, unless the
// disconnection with the number disconnections ended.
func (w *WhatsApp) disconnectedLong(disconnections int) {
return text
}
+// WhatsAppMatch is one contact or group of Find.
+type WhatsAppMatch struct {
+ id string
+ name string
+ kind string
+}
+
// WhatsAppRequest is a pair or unlink command for Run, with the function that
// gives its answers to the client that asked. A pairing has the phone number.
type WhatsAppRequest struct {
}
}
+// 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
projects / onechat / blobdiff