X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/6844f8c992ec4e276a3a0d93b544de0127eebbd2..c781f79f3c8cb9a7577ee1574d196988da2719b3:/whatsapp.go?ds=sidebyside diff --git a/whatsapp.go b/whatsapp.go index 0c68a44..738ef8d 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -2,6 +2,7 @@ package main import ( "context" + "crypto/sha256" "database/sql" "errors" "fmt" @@ -54,17 +55,17 @@ const ( // whatsappTimeLayout is the layout of the times in the answers. whatsappTimeLayout = "2006-01-02 15:04" - // whatsappPairTime is the longest time of a pairing. The library closes - // the pairing connection after about 160 seconds. - whatsappPairTime = 3 * time.Minute + // whatsappPairTimeout is the longest time of a pairing. The library + // closes the pairing connection after about 160 seconds. + whatsappPairTimeout = 3 * time.Minute - // whatsappLogoutTime is the longest time of the logout call of an + // whatsappLogoutTimeout is the longest time of the logout call of an // unlink. - whatsappLogoutTime = 30 * time.Second + whatsappLogoutTimeout = 30 * time.Second - // whatsappNoticeDelay is how long a disconnection lasts before the user - // gets a notice. - whatsappNoticeDelay = 10 * time.Minute + // whatsappOutageNoticeDelay is the delay from a disconnection to its + // notice to the user. + whatsappOutageNoticeDelay = 10 * time.Minute // whatsappRetryDelay is the first wait after a failed starting // connection. @@ -77,10 +78,6 @@ const ( // 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." ) @@ -95,10 +92,90 @@ type WhatsAppClient interface { PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error) Logout(ctx context.Context) error GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) + Download(ctx context.Context, message whatsmeow.DownloadableMessage) ([]byte, error) + Upload(ctx context.Context, data []byte, mediaType whatsmeow.MediaType) (whatsmeow.UploadResponse, error) GenerateMessageID() types.MessageID SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error) } +// 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 sessionMutex serializes session +// creation, close, removal, and snapshots. It is held before mutex, and stays +// held when removal releases mutex for client callbacks. +// +// ctx is the caller context until Run sets its context for library callbacks. +// The mutex protects it, so callbacks follow daemon cancellation. +// +// The inbox puts messages into batches and logs them, and groups holds the +// names of the groups. Both get a WhatsAppLink from link for each call, so they +// use the current device and client. +// +// The library logs nothing, because its log lines hold the ID of the own +// account, which is the phone number of the user. The own number and the own +// 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 { + ctx context.Context + dir string + clock func() time.Time + logger *slog.Logger + newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient + requests chan WhatsAppRequest + logouts chan struct{} + state *WhatsAppState + groups *WhatsAppGroups + inbox *WhatsAppInbox + routes *Routes + + sessionMutex sync.Mutex + mutex sync.Mutex + container *sqlstore.Container + device *store.Device + client WhatsAppClient + linked bool + own []string + notify func(Event) + connected bool + retrying bool + connectedAt time.Time + disconnectedAt time.Time + disconnections int + noticed bool + timer *time.Timer + closed bool +} + +// 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 +// 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) +} + // 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 @@ -106,24 +183,24 @@ type WhatsAppClient interface { // the client of a device with its event handler. func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *slog.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) { w := &WhatsApp{ - dir: filepath.Join(dir, whatsappDirName), - clock: clock, - logger: logger, - newClient: newClient, - noticeDelay: whatsappNoticeDelay, - requests: make(chan WhatsAppRequest, whatsappRequests), - logouts: make(chan struct{}, 1), - groups: newWhatsAppGroups(logger), + ctx: ctx, + dir: filepath.Join(dir, whatsappDirName), + clock: clock, + logger: logger, + newClient: newClient, + requests: make(chan WhatsAppRequest, whatsappRequests), + logouts: make(chan struct{}, 1), + groups: newWhatsAppGroups(logger), } var err error - w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow) + w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName)) if err != nil { return nil, err } - w.inbox = newWhatsAppInbox(w.state, clock, w.groups) + w.inbox = newWhatsAppInbox(w.state, clock, w.groups, &ImageStore{dir: filepath.Join(dir, imageDirName)}, logger) info, err := os.Stat(w.sessionPath()) if errors.Is(err, os.ErrNotExist) { @@ -153,62 +230,6 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge 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 -// 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 sessionMutex serializes session -// creation, close, removal, and snapshots. It is held before mutex, and stays -// held when removal releases mutex for client callbacks. -// -// 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, 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 *slog.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 - - sessionMutex sync.Mutex - mutex sync.Mutex - container *sqlstore.Container - device *store.Device - client WhatsAppClient - linked bool - own []string - notify func(Event) - connected bool - retrying bool - connectedAt time.Time - disconnectedAt time.Time - disconnections int - noticed bool - timer *time.Timer - closed bool -} - // 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 @@ -222,6 +243,7 @@ type WhatsApp struct { func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) error { w.mutex.Lock() + w.ctx = ctx w.notify = notify linked := w.linked w.retrying = linked @@ -257,7 +279,8 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err var pairing sync.WaitGroup - cancel := func() {} + cancel := func() { + } defer func() { cancel() pairing.Wait() @@ -294,7 +317,8 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err cancel() pairing.Wait() - cancel = func() {} + cancel = func() { + } switch { case request.unlink: @@ -307,7 +331,7 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err case w.isLinked(): request.answer("WhatsApp is linked already. Run /whatsapp unlink first.") default: - pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTime) + pairCtx, cancelPair := context.WithTimeout(ctx, whatsappPairTimeout) cancel = cancelPair pairing.Go(func() { defer cancelPair() @@ -358,23 +382,31 @@ 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 and the routes. +// Route source IDs can hold the phone numbers of other chats. func (w *WhatsApp) Status() string { w.mutex.Lock() defer w.mutex.Unlock() + routes := "" + if w.routes != nil { + listed := w.routes.List() + if listed != "No routes." { + routes = "\nWhatsApp routes:\n" + listed + } + } + switch { case !w.linked: - return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it." + return "WhatsApp is not linked. Run /whatsapp pair PHONE to link it." + routes case w.connected: - return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." + return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes case w.disconnectedAt.IsZero(): - return "WhatsApp is linked and not connected yet." + return "WhatsApp is linked and not connected yet." + routes case w.connectedAt.IsZero(): - return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "." + return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "." + routes default: - return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "." + return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes } } @@ -452,10 +484,10 @@ 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) +// Send returns the answer of whatsapp_send for text and an optional stored +// image to chat, with the durable send id that whatsappSend describes. +func (w *WhatsApp) Send(ctx context.Context, id, chat, text, image string) (string, error) { + return whatsappSend(ctx, w.link(), w.groups, w.state, w.inbox.images, w.logger, w.clock, id, chat, text, image) } func (w *WhatsApp) sessionPath() string { @@ -559,7 +591,7 @@ func (w *WhatsApp) startOutage() bool { w.disconnectedAt = w.clock() w.disconnections++ disconnections := w.disconnections - w.timer = time.AfterFunc(w.noticeDelay, func() { + w.timer = time.AfterFunc(whatsappOutageNoticeDelay, func() { w.disconnectedLong(disconnections) }) } @@ -644,7 +676,7 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str var logoutErr error if client != nil { - ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime) + ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTimeout) defer cancel() logoutErr = client.Logout(ctx) @@ -880,19 +912,25 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) { // 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 -// Run or 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. +// or after whatsappCatchupTimeout. A disconnection keeps the time of its start +// while Run or the library tries again. After whatsappOutageNoticeDelay of a +// disconnection, all clients get one notice, and they get one more when the +// connection comes back. A disconnection that the library does not try again +// gives a notice at once. // // The log of the daemon gets one line for each change of the connection of the // linked device: connected, a failed first connection, a lost connection, and // connected again with the length of the outage. The retries of the library and // Run between them log nothing. func (w *WhatsApp) handle(event any) bool { + w.mutex.Lock() + + ctx := w.ctx + w.mutex.Unlock() + switch event := event.(type) { case *events.Message: - return w.inbox.receive(w.link(), event) + return w.inbox.receive(ctx, w.link(), event) case *events.GroupInfo: if event.Name != nil { w.groups.set(event.JID.String(), event.Name.Name) @@ -977,7 +1015,7 @@ func (w *WhatsApp) handle(event any) bool { w.mutex.Unlock() if line != "" { - w.logger.Log(context.Background(), level, line, attrs...) + w.logger.Log(ctx, level, line, attrs...) } if notice != "" { @@ -1029,24 +1067,6 @@ func (w *WhatsApp) redact(text string) string { return whatsappRedact(w.own, 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 -// 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) -} - // 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 @@ -1127,6 +1147,14 @@ func whatsappOwnIDs(ids ...string) []string { return own } +// whatsappChatHash returns a short hash of chat for the daemon log, so that a +// log line can tell chats apart without a phone number. +func whatsappChatHash(chat types.JID) string { + digest := sha256.Sum256([]byte(chat.ToNonAD().String())) + + return fmt.Sprintf("%x", digest[:6]) +} + // whatsappRedact replaces each of the own IDs own in text with OWN. func whatsappRedact(own []string, text string) string { for _, id := range own {