X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/1804474c7a03cca8bf780dd870a985e7badb4331..2e2524881dfe8f6c5cabfd9d342d5d3492953bd4:/whatsapp.go diff --git a/whatsapp.go b/whatsapp.go index 929ae5d..5b07300 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -1,7 +1,6 @@ package main import ( - "cmp" "context" "crypto/sha256" "encoding/hex" @@ -15,7 +14,6 @@ import ( "strings" "sync" "time" - "unicode" "go.mau.fi/whatsmeow" "go.mau.fi/whatsmeow/proto/waE2E" @@ -24,9 +22,6 @@ import ( "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. @@ -76,20 +71,10 @@ const ( // 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 - // whatsappCatchupLimit is the longest wait for the end of the catch-up - // after a connection. - whatsappCatchupLimit = time.Minute - - // 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." @@ -106,10 +91,6 @@ const ( whatsappSending = "sending" whatsappSent = "sent" whatsappFailed = "failed" - - // 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 @@ -133,17 +114,14 @@ type WhatsAppClient interface { // 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, - catchupLimit: whatsappCatchupLimit, - requests: make(chan WhatsAppRequest, whatsappRequests), - logouts: make(chan struct{}, 1), - wake: make(chan struct{}, 1), - failures: make(chan error, 1), - groups: newWhatsAppGroups(logger), + dir: filepath.Join(dir, whatsappDirName), + clock: clock, + logger: logger, + newClient: newClient, + noticeDelay: whatsappNoticeDelay, + requests: make(chan WhatsAppRequest, whatsappRequests), + logouts: make(chan struct{}, 1), + groups: newWhatsAppGroups(logger), } var err error @@ -152,6 +130,8 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge return nil, err } + w.inbox = newWhatsAppInbox(w.state, clock, w.groups) + info, err := os.Stat(w.sessionPath()) if errors.Is(err, os.ErrNotExist) { return w, nil @@ -172,7 +152,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge 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) } @@ -192,20 +172,9 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge // client, and the state of the connection, which the event handler of the // library changes from its own goroutines. // -// The text messages go into batches, one chat at a time, as WhatsAppState 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. -// -// 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 the text 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 @@ -215,18 +184,16 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge // 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 - state *WhatsAppState - groups *WhatsAppGroups + 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{} + state *WhatsAppState + groups *WhatsAppGroups + inbox *WhatsAppInbox mutex sync.Mutex container *sqlstore.Container @@ -242,10 +209,6 @@ type WhatsApp struct { noticed bool timer *time.Timer closed bool - catchingUp bool - caughtUp bool - catchups int - catchupTimer *time.Timer } // Run connects a linked device, logs the closed batches in l, runs the pair and @@ -274,24 +237,18 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err }() 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.state.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 <-w.logouts: err = w.loggedOut(ctx, l) if err != nil { @@ -394,6 +351,11 @@ func (w *WhatsApp) Close() error { 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) +} + func (w *WhatsApp) sessionPath() string { return filepath.Join(w.dir, whatsappSessionFileName) } @@ -465,14 +427,12 @@ func (w *WhatsApp) close() { 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() } @@ -485,7 +445,7 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { return nil } - err := w.deliver(ctx, l, true) + err := w.inbox.deliver(ctx, l, w.link(), true) if err != nil { return err } @@ -521,7 +481,7 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str return nil } - err := w.deliver(ctx, l, true) + err := w.inbox.deliver(ctx, l, w.link(), true) if err != nil { return err } @@ -555,145 +515,6 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str 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.state.CloseAll() - case catchingUp: - return nil - default: - _, err = w.state.CloseDue(time.Now()) - } - - if err != nil { - return err - } - - var turns []Message - for _, batch := range w.state.Closed() { - if batch.Chat.Group && batch.Chat.Name == "" { - batch.Chat.Name = w.groups.name(ctx, w.link(), 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.state.Remove(batch.Number) - if err != nil { - return err - } - - if batch.Turn() { - turns = append(turns, message) - } - } - - l.Wake(turns...) - - return nil -} - -// 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) - w.mutex.Unlock() - - stale := w.groups.stale() - - 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.groups.read(ctx, w.link()) - groups := w.groups.all() - - 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. func (w *WhatsApp) removeSession() error { @@ -703,7 +524,6 @@ func (w *WhatsApp) removeSession() error { w.linked = false w.own = nil w.connected = false - w.catchingUp = false if w.timer != nil { w.timer.Stop() } @@ -714,6 +534,8 @@ func (w *WhatsApp) removeSession() error { w.device = nil w.mutex.Unlock() + w.inbox.stopCatchup() + if client != nil { client.Disconnect() } @@ -874,16 +696,16 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) { } // 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 its 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 { switch event := event.(type) { case *events.Message: - return w.receive(event) + return w.inbox.receive(w.link(), event) case *events.GroupInfo: if event.Name != nil { w.groups.set(event.JID.String(), event.Name.Name) @@ -893,6 +715,11 @@ func (w *WhatsApp) handle(event any) bool { case *events.JoinedGroup: 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 string @@ -903,16 +730,6 @@ func (w *WhatsApp) handle(event any) bool { 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() } @@ -932,8 +749,6 @@ func (w *WhatsApp) handle(event any) bool { } w.connected = false - case *events.OfflineSyncCompleted: - w.endCatchup() case *events.LoggedOut: select { case w.logouts <- struct{}{}: @@ -955,72 +770,6 @@ func (w *WhatsApp) handle(event any) bool { 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() - - w.mutex.Lock() - device := w.device - own := slices.Clone(w.own) - w.mutex.Unlock() - - chat, message, found := whatsappMessage(ctx, device, own, event) - if !found { - return true - } - - _, err := w.state.Add(chat, message, time.Now()) - if err != nil { - select { - case w.failures <- err: - default: - } - - return false - } - - select { - case w.wake <- struct{}{}: - default: - } - - return 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) { @@ -1143,13 +892,6 @@ func (w *WhatsApp) Send(ctx context.Context, id, chat, text string) (string, err return record.Answer, nil } -// 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 { @@ -1183,90 +925,6 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA return client } -// whatsappMessage returns the chat and the batch message of event, or false -// when the batches do not take it. device is the linked device, and own holds -// the own IDs. The batches 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 whatsappMessage(ctx context.Context, device *store.Device, own []string, event *events.Message) (WhatsAppChat, WhatsAppMessage, bool) { - 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 whatsappText(ctx, device, own, event) - } - - return WhatsAppChat{}, WhatsAppMessage{}, false -} - -// whatsappText returns the chat and the batch message of event, a message that -// the batches take when it has text. -func whatsappText(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) - - message.Text = whatsappRedact(own, 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 -} - // whatsappContactName returns the name of the person jid: the full name, the // first name, the business name, or the push name of the contact in the session // of device, then push, the push name of a message, then the phone number. A @@ -1309,44 +967,6 @@ func whatsappContactName(ctx context.Context, device *store.Device, jid types.JI } } -// 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") -} - // whatsappSendCheck returns the JID of chat, and an error when id, chat, or // text cannot go to a send. The chat is a private chat or a group, and not the // chat of the user with itself.