X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/0018014ab36f3de61a4b8a5515009dab803d6c38..b1095a9efc2d57d0c13a043f3feaddbdec789512:/whatsapp.go diff --git a/whatsapp.go b/whatsapp.go index 3c519e8..75de73f 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -8,16 +8,19 @@ import ( "net/url" "os" "path/filepath" + "slices" "strings" "sync" "time" "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" - // The session store of the library opens SQLite with this pure Go // driver. _ "modernc.org/sqlite" @@ -36,7 +39,8 @@ const ( // as "/whatsapp status". whatsappCommand = "/whatsapp" - // whatsappUsage is the answer to a WhatsApp command that does not exist. + // 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, @@ -64,6 +68,13 @@ const ( // whatsappRequests is the number of pair and unlink commands that can // wait for Run. whatsappRequests = 8 + + // 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 + + // 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." ) // WhatsAppClient is the part of the WhatsApp client that the daemon uses. The @@ -75,6 +86,9 @@ type WhatsAppClient interface { 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) + 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 @@ -91,8 +105,17 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge noticeDelay: whatsappNoticeDelay, requests: make(chan WhatsAppRequest, whatsappRequests), logouts: make(chan struct{}, 1), + groups: newWhatsAppGroups(logger), } + var err error + w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow) + if err != nil { + 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 @@ -113,15 +136,16 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge if w.device.ID != nil { w.linked = true + w.inbox.waitForCatchup() 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. Run keeps a linked device connected, and the library connects +// 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 @@ -132,10 +156,17 @@ 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 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 // LID never go to the log of the agent or to the log of the daemon: redact -// removes them from the errors. +// 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 @@ -144,6 +175,9 @@ type WhatsApp struct { noticeDelay time.Duration requests chan WhatsAppRequest logouts chan struct{} + state *WhatsAppState + groups *WhatsAppGroups + inbox *WhatsAppInbox mutex sync.Mutex container *sqlstore.Container @@ -161,11 +195,14 @@ type WhatsApp struct { closed bool } -// Run connects a linked device, 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, l *TurnLoop, notify func(Event)) { +// 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. +func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error { w.mutex.Lock() w.notify = notify linked := w.linked @@ -184,11 +221,23 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) { }() for { + err := w.inbox.deliver(ctx, l, w.link(), false) + if err != nil { + return err + } + select { case <-ctx.Done(): - return + return nil + case err = <-w.inbox.failures: + return err + case <-w.inbox.wake: + case <-w.inbox.due(): case <-w.logouts: - w.loggedOut(l) + err = w.loggedOut(ctx, l) + if err != nil { + return err + } case request := <-w.requests: cancel() pairing.Wait() @@ -196,7 +245,10 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) { switch { case request.unlink: - w.unlink(ctx, l, request.answer) + 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: @@ -205,7 +257,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) { pairing.Go(func() { defer cancelPair() - w.pair(pairCtx, l, request.phone, request.answer) + w.pair(pairCtx, ctx, l, request.phone, request.answer) }) } } @@ -248,8 +300,8 @@ func (w *WhatsApp) Command(args string, answer func(text string)) { } // 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() @@ -283,12 +335,23 @@ 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) +} + +// 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) } -// openSession opens the session database and its first device. The caller -// holds the mutex, or no other goroutine uses w yet. +// 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 { @@ -318,6 +381,21 @@ func (w *WhatsApp) isLinked() bool { return w.linked } +// 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 makes the client of the linked device and connects it. func (w *WhatsApp) connect(ctx context.Context) { w.mutex.Lock() @@ -331,8 +409,7 @@ func (w *WhatsApp) connect(ctx context.Context) { } } -// close ends the connection and the timer of the notice, and stops all -// notices. +// close ends the connection and the timer of the notice, and stops all notices. func (w *WhatsApp) close() { w.mutex.Lock() w.closed = true @@ -344,19 +421,26 @@ func (w *WhatsApp) close() { w.client = nil w.mutex.Unlock() + w.inbox.close() + if client != nil { client.Disconnect() } } -// loggedOut 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(l *TurnLoop) { +// 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 + return nil } - err := w.removeSession() + 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) } @@ -367,13 +451,16 @@ func (w *WhatsApp) loggedOut(l *TurnLoop) { } w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.") + + return nil } -// unlink 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. -func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text string)) { +// 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 @@ -381,7 +468,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str if !linked { answer("WhatsApp is not linked.") - return + return nil + } + + err := w.inbox.deliver(ctx, l, w.link(), true) + if err != nil { + return err } var logoutErr error @@ -392,10 +484,10 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str logoutErr = client.Logout(ctx) } - err := w.removeSession() + err = w.removeSession() if err != nil { answer("The unlink failed: " + w.redact(err.Error())) - return + return nil } err = l.note("WhatsApp is unlinked.") @@ -405,10 +497,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str 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 + return nil } answer("WhatsApp is unlinked.") + + return nil } // removeSession ends the connection, closes the session database, and deletes @@ -430,6 +524,8 @@ func (w *WhatsApp) removeSession() error { w.device = nil w.mutex.Unlock() + w.inbox.stopCatchup() + if client != nil { client.Disconnect() } @@ -449,12 +545,18 @@ func (w *WhatsApp) removeSession() error { 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)) { +// 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. +// +// 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()) @@ -471,7 +573,7 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f qr, err := client.GetQRChannel(ctx) if err == nil { - err = client.ConnectContext(ctx) + err = client.ConnectContext(runCtx) } if err != nil { @@ -493,6 +595,8 @@ func (w *WhatsApp) pair(ctx context.Context, l *TurnLoop, phone string, answer f 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.") @@ -583,12 +687,33 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) { w.linked = true } -// 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. -// 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. +// handle takes one event of the library and tells if it was handled. A message +// 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.inbox.receive(w.link(), event) + case *events.GroupInfo: + if event.Name != nil { + w.groups.set(event.JID.String(), event.Name.Name) + } + + return true + 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 w.mutex.Lock() switch event := event.(type) { @@ -674,11 +799,17 @@ 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 whatsappRedact(w.own, text) +} - return text +// 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 @@ -689,12 +820,20 @@ type WhatsAppRequest struct { 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. The client tries again after a failed first connection, +// 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.SynchronousAck = true @@ -704,6 +843,48 @@ 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 + } +} + // whatsappOwnIDs returns the own number and the own LID that are not empty. func whatsappOwnIDs(ids ...string) []string { var own []string @@ -716,6 +897,15 @@ func whatsappOwnIDs(ids ...string) []string { 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. @@ -750,9 +940,9 @@ 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. +// 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") == ""