X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/ec230eee6b06580031637bc97c99ec6db7b41926..f0604a9ebbee5783d5213d6176191535f4ed335b:/whatsapp.go diff --git a/whatsapp.go b/whatsapp.go index 05db5e4..0e71e98 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -1,22 +1,30 @@ package main import ( + "cmp" "context" "errors" "fmt" "log" + "maps" "net/url" "os" "path/filepath" + "slices" "strings" "sync" "time" + "unicode" "go.mau.fi/whatsmeow" "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. @@ -36,11 +44,67 @@ const ( // as "/whatsapp status". whatsappCommand = "/whatsapp" - // whatsappUsage is the answer to a WhatsApp command that does not exist. - whatsappUsage = "Use /whatsapp status." + // whatsappUsage is the answer to a WhatsApp command that does not + // exist. + whatsappUsage = "Use /whatsapp pair PHONE, /whatsapp status, or /whatsapp unlink. PHONE is the number of your WhatsApp account with its country code, such as +15550001111." + + // whatsappPairSteps tells the user what to do with the pairing code, + // which comes in the next message. + whatsappPairSteps = "In WhatsApp on your phone, open Linked devices, tap Link a device, then tap Link with phone number instead, and enter the code of the next message. The code expires in about 2 minutes." + + // whatsappPairExpired is the answer when the pairing code expires. + whatsappPairExpired = "The pairing code expired. Run /whatsapp pair PHONE again for a new code." // 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 + + // whatsappLogoutTime is the longest time of the logout call of an + // unlink. + whatsappLogoutTime = 30 * time.Second + + // whatsappNoticeDelay is how long a disconnection lasts before the user + // gets a notice. + whatsappNoticeDelay = 10 * 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 @@ -49,23 +113,39 @@ const ( type WhatsAppClient interface { ConnectContext(ctx context.Context) error Disconnect() + GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error) + 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) } // openWhatsApp opens the WhatsApp session in the data directory dir. Without // the session file, WhatsApp is not linked. The session gives full access to // 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 linked device with its event handler. +// 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, + 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), } - path := filepath.Join(w.dir, whatsappSessionFileName) - info, err := os.Stat(path) + var err error + w.batches, err = openWhatsAppBatches(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow) + if err != nil { + return nil, err + } + + info, err := os.Stat(w.sessionPath()) if errors.Is(err, os.ErrNotExist) { return w, nil } @@ -78,89 +158,211 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge return nil, fmt.Errorf("%s holds the WhatsApp session, so its mode must be 0600", filepath.Join(whatsappDirName, whatsappSessionFileName)) } - address, err := whatsappSessionAddress(path) + err = w.openSession(ctx) if err != nil { return nil, err } - w.container, err = sqlstore.New(ctx, "sqlite", address, waLog.Noop) - if err != nil { - return nil, fmt.Errorf("open WhatsApp session: %w", err) - } - - w.device, err = w.container.GetFirstDevice(ctx) - if err != nil { - return nil, errors.Join(fmt.Errorf("read WhatsApp device: %w", err), w.container.Close()) + if w.device.ID != nil { + w.linked = true + w.catchingUp = true + w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User) } return w, nil } -// WhatsApp is the link of the daemon to the WhatsApp account of the user, as -// a linked device. The session database of the library in dir holds the keys -// of the device. A device with an ID is linked, and Run keeps it connected. -// The library connects again by itself after a network failure. The mutex -// protects the state of the connection, which the event handler of the library -// changes from its own goroutines. +// WhatsApp is the link of the daemon to the WhatsApp account of the user, as a +// linked device. The session database of the library in dir holds the keys of +// the device. Run keeps a linked device connected, and the library connects +// again by itself after a network failure. +// +// The commands pair and unlink go to Run as requests, and Run runs one at a +// time. A pairing runs in its own goroutine until its code expires, and a new +// pairing ends the one before. Its phone number and code go only to the answer +// 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. +// +// 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. +// +// 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. +// account, which is the phone number of the user. The own number and the own +// LID never go to the log of the agent or to the log of the daemon: redact +// removes them from the errors, and a batch shows the messages of the user as +// You and a mention of the user as @you. The IDs of the other chats go to the +// 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 - container *sqlstore.Container - device *store.Device - client WhatsAppClient + 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 + device *store.Device + client WhatsAppClient + linked bool + own []string + notify func(Event) connected 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 and keeps the connection until ctx ends. A +// 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. -func (w *WhatsApp) Run(ctx context.Context) { - if !w.linked() { - <-ctx.Done() - return - } +// 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. +func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error { + w.mutex.Lock() + w.notify = notify + linked := w.linked + w.mutex.Unlock() - w.client = w.newClient(w.device, w.handle) - err := w.client.ConnectContext(ctx) - if err != nil { - w.logger.Printf("connect: %v", err) + if linked { + w.connect(ctx) } - <-ctx.Done() - w.client.Disconnect() + var pairing sync.WaitGroup + cancel := func() {} + defer func() { + cancel() + pairing.Wait() + w.close() + }() + + for { + err := w.deliver(ctx, l, 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: + return err + case <-w.wake: + case <-due: + case <-w.logouts: + err = w.loggedOut(ctx, l) + if err != nil { + return err + } + case request := <-w.requests: + cancel() + pairing.Wait() + cancel = func() {} + + switch { + case request.unlink: + 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) + cancel = cancelPair + pairing.Go(func() { + defer cancelPair() + + w.pair(pairCtx, l, request.phone, request.answer) + }) + } + } + } } // Command runs the WhatsApp command args, the text after /whatsapp, and gives // each answer to answer. The answers go only to the client that sent the // command. func (w *WhatsApp) Command(args string, answer func(text string)) { - switch strings.TrimSpace(args) { - case "status": + fields := strings.Fields(args) + request := WhatsAppRequest{ + answer: answer, + } + + switch { + case len(fields) == 1 && fields[0] == "status": answer(w.Status()) + return + case len(fields) == 1 && fields[0] == "unlink": + request.unlink = true + case len(fields) >= 2 && fields[0] == "pair": + 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 + } + + select { + case w.requests <- request: + default: + answer("Too many WhatsApp commands wait. Try again in a minute.") } } // 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. It never holds the +// phone number. func (w *WhatsApp) Status() string { w.mutex.Lock() defer w.mutex.Unlock() switch { - case !w.linked(): - return "WhatsApp is not linked." + case !w.linked: + return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it." case w.connected: return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." case w.disconnectedAt.IsZero(): @@ -174,44 +376,834 @@ func (w *WhatsApp) Status() string { // Close closes the session database. func (w *WhatsApp) Close() error { + w.mutex.Lock() + defer w.mutex.Unlock() + if w.container == nil { return nil } - return w.container.Close() + err := w.container.Close() + w.container = nil + + return err } -// linked tells if the session holds a linked device. -func (w *WhatsApp) linked() bool { - return w.device != nil && w.device.ID != nil +func (w *WhatsApp) sessionPath() string { + return filepath.Join(w.dir, whatsappSessionFileName) } -// handle takes one event of the library and tells if it was handled. A -// disconnection keeps the time of its start while the library tries again. -func (w *WhatsApp) handle(event any) bool { +// openSession opens the session database and its first device. The caller holds +// the mutex, or no other goroutine uses w yet. +func (w *WhatsApp) openSession(ctx context.Context) error { + address, err := whatsappSessionAddress(w.sessionPath()) + if err != nil { + return err + } + + container, err := sqlstore.New(ctx, "sqlite", address, waLog.Noop) + if err != nil { + return fmt.Errorf("open WhatsApp session: %w", err) + } + + device, err := container.GetFirstDevice(ctx) + if err != nil { + return errors.Join(fmt.Errorf("read WhatsApp device: %w", err), container.Close()) + } + + w.container = container + w.device = device + + return nil +} + +func (w *WhatsApp) isLinked() bool { w.mutex.Lock() defer w.mutex.Unlock() - switch event.(type) { + return w.linked +} + +// connect makes the client of the linked device and connects it. +func (w *WhatsApp) connect(ctx context.Context) { + w.mutex.Lock() + 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())) + } +} + +// 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() + + if client != nil { + client.Disconnect() + } +} + +// loggedOut logs the open batches, deletes the session after a logout from the +// phone, notes it in the log of l, and tells all clients one time. +func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { + if !w.isLinked() { + return nil + } + + err := w.deliver(ctx, l, true) + if err != nil { + return err + } + + err = w.removeSession() + if err != nil { + w.logger.Printf("delete the session after the logout: %v", err) + } + + err = l.note("WhatsApp was unlinked from the phone.") + if err != nil { + w.logger.Printf("note the logout: %v", err) + } + + w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.") + + return nil +} + +// unlink logs the open batches, logs out the linked device, and deletes the +// session. When the logout call fails, as it does while WhatsApp is +// disconnected, the session is deleted all the same, and answer tells the user +// to remove the device in the phone. Its error is one of the log or the state +// 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) + if err != nil { + return err + } + + var logoutErr error + if client != nil { + ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime) + defer cancel() + + logoutErr = client.Logout(ctx) + } + + err = w.removeSession() + if err != nil { + answer("The unlink failed: " + w.redact(err.Error())) + return nil + } + + err = l.note("WhatsApp is unlinked.") + if err != nil { + w.logger.Printf("note the unlink: %v", 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...) + + 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. +func (w *WhatsApp) removeSession() error { + w.mutex.Lock() + client := w.client + w.client = nil + w.linked = false + w.own = nil + w.connected = false + w.catchingUp = false + if w.timer != nil { + w.timer.Stop() + } + + w.noticed = false + container := w.container + w.container = nil + w.device = nil + w.mutex.Unlock() + + if client != nil { + client.Disconnect() + } + + var err error + if container != nil { + err = container.Close() + } + + for _, suffix := range []string{"", "-wal", "-shm"} { + removeErr := os.Remove(w.sessionPath() + suffix) + if !errors.Is(removeErr, os.ErrNotExist) { + err = errors.Join(err, removeErr) + } + } + + return err +} + +// pair links a new device to the account of phone with a pairing code. It gives +// the steps and the code to answer, and then the end of the pairing: the linked +// 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)) { + device, err := w.newDevice(ctx) + if err != nil { + answer("The pairing failed: " + err.Error()) + return + } + + client := w.newClient(device, w.handle) + linked := false + defer func() { + if !linked { + client.Disconnect() + } + }() + + qr, err := client.GetQRChannel(ctx) + if err == nil { + err = client.ConnectContext(ctx) + } + + if err != nil { + answer("The connection to WhatsApp failed: " + err.Error()) + return + } + + select { + case item, open := <-qr: + if !open || item.Event != whatsmeow.QRChannelEventCode { + answer("WhatsApp did not start the pairing. Try again later.") + return + } + case <-ctx.Done(): + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + answer("The connection to WhatsApp did not start the pairing in time. Try again later.") + } + + return + } + + 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 + } + + answer(whatsappPairSteps) + answer(code) + + for { + var item whatsmeow.QRChannelItem + open := true + select { + case item, open = <-qr: + case <-ctx.Done(): + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + answer(whatsappPairExpired) + } + + return + } + + 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) + + err = l.note("WhatsApp is linked.") + if err != nil { + w.logger.Printf("note the link: %v", err) + } + + answer("WhatsApp is linked to +" + phone + ".") + + return + default: + answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.") + return + } + } +} + +// newDevice returns a new device in the session database. It makes the +// 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.mutex.Lock() + defer w.mutex.Unlock() + + if w.container == nil { + err := os.MkdirAll(w.dir, 0o700) + if err != nil { + return nil, fmt.Errorf("create WhatsApp directory: %w", err) + } + + file, err := os.OpenFile(w.sessionPath(), os.O_CREATE|os.O_RDWR, 0o600) + if err != nil { + return nil, fmt.Errorf("create WhatsApp session: %w", err) + } + + err = file.Close() + if err != nil { + return nil, fmt.Errorf("create WhatsApp session: %w", err) + } + + err = w.openSession(ctx) + if err != nil { + return nil, err + } + } + + w.device = w.container.NewDevice() + + return w.device, nil +} + +// linkedBy makes client the client of the linked device. +func (w *WhatsApp) linkedBy(client WhatsAppClient) { + w.mutex.Lock() + defer w.mutex.Unlock() + + w.client = client + w.linked = true +} + +// 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. +func (w *WhatsApp) handle(event any) bool { + message, isMessage := event.(*events.Message) + if isMessage { + return w.receive(message) + } + + var notice string + w.mutex.Lock() + switch event := event.(type) { + case *events.GroupInfo: + if event.Name != nil { + w.groupNames[event.JID.String()] = event.Name.Name + } + case *events.JoinedGroup: + w.groupNames[event.JID.String()] = event.Name + 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() + } + + w.catchupTimer = time.AfterFunc(w.catchupLimit, func() { + w.caughtUpBy(catchups) + }) + if w.timer != nil { + w.timer.Stop() + } + + if w.noticed { + w.noticed = false + notice = "WhatsApp is connected again." + } case *events.Disconnected: - if w.connected || w.disconnectedAt.IsZero() { + 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) + }) } w.connected = false + case *events.OfflineSyncCompleted: + w.endCatchup() + case *events.LoggedOut: + select { + case w.logouts <- struct{}{}: + default: + } + case events.PermanentDisconnect: + 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." + } + } + 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: + } + + 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 + } + + 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) { + w.mutex.Lock() + long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections + if long { + w.noticed = true + } + + since := w.disconnectedAt + w.mutex.Unlock() + + if long { + w.broadcast("WhatsApp is disconnected since " + since.Format(whatsappTimeLayout) + ". OneChat tries again.") + } +} + +// 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() + + if notify != nil && !closed { + notify(Event{ + Kind: "notice", + Text: text, + }) + } +} + +// redact replaces the own number and the own LID in text with OWN. +func (w *WhatsApp) redact(text string) string { + w.mutex.Lock() + defer w.mutex.Unlock() + + for _, id := range w.own { + text = strings.ReplaceAll(text, id, "OWN") + } + + 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 { + phone string + unlink bool + answer func(text string) +} + // 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. +// 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. 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.SynchronousAck = true @@ -221,6 +1213,98 @@ func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsA return client } +// 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 +// LID gets its phone number from the LID map of the session. +func whatsappContactName(ctx context.Context, device *store.Device, jid types.JID, push string) string { + jid = jid.ToNonAD() + candidates := []types.JID{jid} + phone := types.EmptyJID + switch jid.Server { + case types.DefaultUserServer: + phone = jid + case types.HiddenUserServer: + mapped, err := device.LIDs.GetPNForLID(ctx, jid) + if err == nil && !mapped.IsEmpty() { + phone = mapped + candidates = append(candidates, mapped) + } + } + + for _, candidate := range candidates { + contact, err := device.Contacts.GetContact(ctx, candidate) + if err != nil || !contact.Found { + continue + } + + for _, name := range []string{contact.FullName, contact.FirstName, contact.BusinessName, contact.PushName} { + if name != "" { + return name + } + } + } + + switch { + case push != "": + return push + case !phone.IsEmpty(): + return "+" + phone.User + default: + return jid.User + } +} + +// 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 +} + // 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. @@ -254,3 +1338,23 @@ func whatsappCommandArgs(line string) (string, bool) { return strings.TrimSpace(args), true } + +// whatsappPhone returns the digits of phone, a number with its country code and +// an optional + and dashes, and tells if it has the form of a number: 7 to 15 +// digits, with no 0 first. +func whatsappPhone(phone string) (string, bool) { + phone = strings.ReplaceAll(strings.TrimPrefix(phone, "+"), "-", "") + valid := len(phone) >= 7 && len(phone) <= 15 && phone[0] != '0' && strings.Trim(phone, "0123456789") == "" + + return phone, valid +} + +// whatsappItemError returns the error of a pairing item that is not a code, a +// success, or a timeout. +func whatsappItemError(item whatsmeow.QRChannelItem) string { + if item.Error != nil { + return item.Error.Error() + } + + return item.Event +}