X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/522d7fd117285e4e4ce3ea5ec9b5a1722521b681..f4509310b5abe5012cb83bed3960404e8fa92217:/whatsapp.go?ds=sidebyside diff --git a/whatsapp.go b/whatsapp.go index 6e1e1e6..27dd3c3 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -2,9 +2,11 @@ package main import ( "context" + "crypto/sha256" + "database/sql" "errors" "fmt" - "log" + "log/slog" "net/url" "os" "path/filepath" @@ -53,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. @@ -76,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." ) @@ -94,35 +92,115 @@ 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 // gives the times of the status, logger gets the failures, and newClient makes // 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) { +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 + return nil, fmt.Errorf("open WhatsApp state: %w", 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) { @@ -139,7 +217,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge err = w.openSession(ctx) if err != nil { - return nil, err + return nil, fmt.Errorf("open WhatsApp session: %w", err) } if w.device.ID != nil { @@ -152,57 +230,32 @@ 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 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 *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 +func (w *WhatsApp) sessionPath() string { + return filepath.Join(w.dir, whatsappSessionFileName) +} - 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 +// 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 fmt.Errorf("find WhatsApp session address: %w", 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 } // Run connects a linked device, logs the closed batches in l, runs the pair and @@ -218,6 +271,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 @@ -253,7 +307,9 @@ 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() @@ -267,14 +323,18 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err for { err := w.inbox.deliver(ctx, l, w.link(), false) if err != nil { - return err + return fmt.Errorf("deliver WhatsApp inbox: %w", err) } select { case <-ctx.Done(): return nil case err = <-w.inbox.failures: - return err + if err != nil { + return fmt.Errorf("receive WhatsApp inbox: %w", err) + } + + return nil case <-w.inbox.wake: case <-w.inbox.due(): case <-retry: @@ -284,13 +344,14 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err err = w.loggedOut(ctx, l) if err != nil { - return err + return fmt.Errorf("handle WhatsApp logout: %w", err) } case request := <-w.requests: cancel() pairing.Wait() - cancel = func() {} + cancel = func() { + } switch { case request.unlink: @@ -298,12 +359,12 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err err = w.unlink(ctx, l, request.answer) if err != nil { - return err + return fmt.Errorf("unlink WhatsApp: %w", 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() @@ -315,141 +376,6 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err } } -// 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)) { - 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. -func (w *WhatsApp) Status() string { - w.mutex.Lock() - defer w.mutex.Unlock() - - switch { - 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(): - return "WhatsApp is linked and not connected yet." - case w.connectedAt.IsZero(): - return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + "." - default: - return "WhatsApp is linked and disconnected since " + w.disconnectedAt.Format(whatsappTimeLayout) + ". The last connection started at " + w.connectedAt.Format(whatsappTimeLayout) + "." - } -} - -// Close closes the session database. -func (w *WhatsApp) Close() error { - w.mutex.Lock() - defer w.mutex.Unlock() - - if w.container == nil { - return nil - } - - err := w.container.Close() - w.container = nil - - 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. -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() - - 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 tries the starting connection of the linked device with one client. // It returns whether Run must retry. A failed call starts the shared outage // state and logs its redacted cause once, because a returned ConnectContext @@ -487,30 +413,12 @@ func (w *WhatsApp) connect(ctx context.Context) bool { w.mutex.Unlock() if first { - w.logger.Printf("first connect failed, retrying: %s", cause) + w.logger.Warn("first connect failed, retrying", "err", cause) } return true } -// startOutage starts the shared outage time and notice timer once. The caller -// holds the mutex. Its result tells whether this is the first failure. -func (w *WhatsApp) startOutage() bool { - first := w.linked && (w.connected || w.disconnectedAt.IsZero()) - if first { - w.disconnectedAt = w.clock() - w.disconnections++ - disconnections := w.disconnections - w.timer = time.AfterFunc(w.noticeDelay, func() { - w.disconnectedLong(disconnections) - }) - } - - w.connected = false - - return first -} - // close ends the connection and the timer of the notice, and stops all notices. func (w *WhatsApp) close() { w.mutex.Lock() @@ -531,6 +439,21 @@ func (w *WhatsApp) close() { } } +// 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), + } +} + // 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 { @@ -538,7 +461,7 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { return nil } - w.logger.Print("logged out by the phone, run /whatsapp pair PHONE") + w.logger.Error("logged out by the phone") err := w.inbox.deliver(ctx, l, w.link(), true) if err != nil { @@ -547,12 +470,12 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { err = w.removeSession() if err != nil { - w.logger.Printf("session delete failed: %v", err) + w.logger.Error("session delete failed", "err", err) } err = l.note("WhatsApp was unlinked from the phone.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.") @@ -586,7 +509,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) @@ -599,11 +522,11 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str return nil } - w.logger.Print("unlinked") + w.logger.Info("unlinked") err = l.note("WhatsApp is unlinked.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } if client == nil || logoutErr != nil { @@ -617,48 +540,11 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str return nil } -// removeSession ends the connection, closes the session database, and deletes -// its files. -func (w *WhatsApp) removeSession() error { +func (w *WhatsApp) isLinked() bool { w.mutex.Lock() + defer w.mutex.Unlock() - client := w.client - w.client = nil - w.linked = false - w.retrying = false - w.own = nil - w.connected = false - w.disconnectedAt = time.Time{} - if w.timer != nil { - w.timer.Stop() - } - - w.noticed = false - container := w.container - w.container = nil - w.device = nil - w.mutex.Unlock() - - w.inbox.stopCatchup() - - 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 + return w.linked } // pair links a new device to the account of phone with a pairing code. It gives @@ -751,11 +637,11 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, linked = true w.linkedBy(client) - w.logger.Print("linked") + w.logger.Info("linked") err = l.note("WhatsApp is linked.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } answer("WhatsApp is linked to +" + phone + ".") @@ -769,65 +655,28 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, } } -// 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 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) @@ -848,6 +697,10 @@ func (w *WhatsApp) handle(event any) bool { var notice, line string + level := slog.LevelInfo + + var attrs []any + w.mutex.Lock() switch event := event.(type) { @@ -859,7 +712,8 @@ func (w *WhatsApp) handle(event any) bool { case w.disconnectedAt.IsZero(): line = "connected" default: - line = "connected again after " + durationText(w.clock().Sub(w.disconnectedAt)) + line = "connected again" + attrs = append(attrs, "after", w.clock().Sub(w.disconnectedAt)) } w.connected = true @@ -876,6 +730,7 @@ func (w *WhatsApp) handle(event any) bool { case *events.Disconnected: connected := w.connected if w.startOutage() { + level = slog.LevelWarn line = "disconnected, retrying" if !connected { line = "first connect failed, retrying" @@ -893,7 +748,9 @@ func (w *WhatsApp) handle(event any) bool { 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." - line = "disconnected for good, restart to retry: " + whatsappRedact(w.own, event.PermanentDisconnectDescription()) + level = slog.LevelError + line = "disconnected for good, restart to retry" + attrs = append(attrs, "err", whatsappRedact(w.own, event.PermanentDisconnectDescription())) } } @@ -904,7 +761,7 @@ func (w *WhatsApp) handle(event any) bool { w.mutex.Unlock() if line != "" { - w.logger.Print(line) + w.logger.Log(ctx, level, line, attrs...) } if notice != "" { @@ -914,22 +771,70 @@ func (w *WhatsApp) handle(event any) bool { return true } -// disconnectedLong gives the notice of a long disconnection, unless the -// disconnection with the number disconnections ended. -func (w *WhatsApp) disconnectedLong(disconnections int) { +// startOutage starts the shared outage time and notice timer once. The caller +// holds the mutex. Its result tells whether this is the first failure. +func (w *WhatsApp) startOutage() bool { + first := w.linked && (w.connected || w.disconnectedAt.IsZero()) + if first { + w.disconnectedAt = w.clock() + w.disconnections++ + disconnections := w.disconnections + w.timer = time.AfterFunc(whatsappOutageNoticeDelay, func() { + w.disconnectedLong(disconnections) + }) + } + + w.connected = false + + return first +} + +// removeSession ends the connection, closes the session database, and deletes +// its files. The session lock covers the cleanup after mutex is released, so a +// snapshot or a new session cannot open files that cleanup removes. +func (w *WhatsApp) removeSession() error { + w.sessionMutex.Lock() + defer w.sessionMutex.Unlock() + w.mutex.Lock() - long := !w.closed && w.linked && !w.connected && !w.noticed && w.disconnections == disconnections - if long { - w.noticed = true + client := w.client + w.client = nil + w.linked = false + w.retrying = false + w.own = nil + w.connected = false + w.disconnectedAt = time.Time{} + if w.timer != nil { + w.timer.Stop() } - since := w.disconnectedAt + w.noticed = false + container := w.container + w.container = nil + w.device = nil w.mutex.Unlock() - if long { - w.broadcast("WhatsApp is disconnected since " + since.Format(whatsappTimeLayout) + ". OneChat tries again.") + w.inbox.stopCatchup() + + 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 } // broadcast gives text as a notice to all clients. @@ -956,22 +861,275 @@ 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 +// 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.sessionMutex.Lock() + defer w.sessionMutex.Unlock() + + 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, fmt.Errorf("open new WhatsApp session: %w", err) + } + } + + w.device = w.container.NewDevice() + + return w.device, nil } -// 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) +// 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 +} + +// 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.") + } +} + +// 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)) { + 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 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." + routes + case w.connected: + return "WhatsApp is linked and connected since " + w.connectedAt.Format(whatsappTimeLayout) + "." + routes + case w.disconnectedAt.IsZero(): + return "WhatsApp is linked and not connected yet." + routes + case w.connectedAt.IsZero(): + 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) + "." + routes + } +} + +// BackupSession writes a consistent SQLite snapshot to path while the session +// cannot be created, closed, or removed. The source opens without creation +// permission. No session file means no linked state to copy. +func (w *WhatsApp) BackupSession(ctx context.Context, path string) (err error) { + w.sessionMutex.Lock() + defer w.sessionMutex.Unlock() + + w.mutex.Lock() + defer w.mutex.Unlock() + + _, err = os.Stat(w.sessionPath()) + if errors.Is(err, os.ErrNotExist) { + return nil + } + + if err != nil { + return fmt.Errorf("read session file: %w", err) + } + + err = os.MkdirAll(filepath.Dir(path), 0o700) + if err != nil { + return fmt.Errorf("create session snapshot directory: %w", err) + } + + address, err := whatsappSessionAddress(w.sessionPath()) + if err != nil { + return fmt.Errorf("find session database: %w", err) + } + + database, err := sql.Open("sqlite", address+"&mode=rw") + if err != nil { + return fmt.Errorf("open session snapshot source: %w", err) + } + + defer func() { + err = errors.Join(err, database.Close()) + }() + + _, err = database.ExecContext(ctx, "VACUUM INTO ?", path) + if err != nil { + return fmt.Errorf("snapshot session database: %w", err) + } + + err = os.Chmod(path, 0o600) + if err != nil { + return fmt.Errorf("set session snapshot mode: %w", err) + } + + return nil +} + +// Close closes the session database. +func (w *WhatsApp) Close() error { + w.sessionMutex.Lock() + defer w.sessionMutex.Unlock() + + w.mutex.Lock() + defer w.mutex.Unlock() + + if w.container == nil { + return nil + } + + err := w.container.Close() + w.container = nil + + 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 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) +} + +// 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. +func whatsappSessionAddress(path string) (string, error) { + path, err := filepath.Abs(path) + if err != nil { + return "", fmt.Errorf("find WhatsApp session: %w", err) + } + + address := url.URL{ + Scheme: "file", + Path: path, + RawQuery: "_pragma=foreign_keys(1)&_pragma=busy_timeout(5000)", + } + + return address.String(), nil +} + +// 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 +} + +// 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 +} + +// 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 } // whatsappSetDeviceProps sets the device properties that the library sends at @@ -1041,44 +1199,12 @@ func whatsappContactName(ctx context.Context, device *store.Device, jid types.JI } } -// 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 -} - -// 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") - } +// 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 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. -func whatsappSessionAddress(path string) (string, error) { - path, err := filepath.Abs(path) - if err != nil { - return "", fmt.Errorf("find WhatsApp session: %w", err) - } - - address := url.URL{ - Scheme: "file", - Path: path, - RawQuery: "_pragma=foreign_keys(1)&_pragma=busy_timeout(5000)", - } - - return address.String(), nil + return fmt.Sprintf("%x", digest[:6]) } // whatsappCommandArgs returns the text after /whatsapp of a line of a WhatsApp @@ -1096,23 +1222,3 @@ 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 -}