X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/53c6c8a5a17e2dfc8bd3ff02ab99d29d709dda2f..0da50dc187c8b4aa23ac1ddd0418c0da779389d9:/whatsapp.go diff --git a/whatsapp.go b/whatsapp.go index e02e8c6..f225756 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -2,9 +2,10 @@ package main import ( "context" + "database/sql" "errors" "fmt" - "log" + "log/slog" "net/url" "os" "path/filepath" @@ -94,6 +95,7 @@ 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) GenerateMessageID() types.MessageID SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error) } @@ -103,7 +105,7 @@ type WhatsAppClient interface { // 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, @@ -116,12 +118,13 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge } 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) + 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) { @@ -144,6 +147,7 @@ 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) } @@ -161,11 +165,13 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge // 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. +// 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 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 @@ -177,7 +183,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge type WhatsApp struct { dir string clock func() time.Time - logger *log.Logger + logger *slog.Logger newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient noticeDelay time.Duration requests chan WhatsAppRequest @@ -185,7 +191,9 @@ type WhatsApp struct { state *WhatsAppState groups *WhatsAppGroups inbox *WhatsAppInbox + routes *Routes + sessionMutex sync.Mutex mutex sync.Mutex container *sqlstore.Container device *store.Device @@ -209,12 +217,13 @@ type WhatsApp struct { // failed first connection starts the same outage notice as a lost connection. A // timer in the select retries it with a doubled wait from 2 seconds to 5 // minutes, without a retry goroutine or a wait that blocks commands or the -// inbox. A connection, unlink, logout, pair command, or ctx end stops retries. -// The library owns retries after a connection opens. 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. +// inbox. A connection, unlink, logout, or ctx end stops retries. The library +// owns retries after a connection opens. 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.retrying = linked @@ -225,11 +234,13 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err defer timer.Stop() var retry <-chan time.Time + delay := whatsappRetryDelay connect := func() { retry = nil if w.connect(ctx) { timer.Reset(delay) + retry = timer.C delay = min(2*delay, whatsappRetryLimit) } @@ -237,13 +248,17 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err stopRetry := func() { timer.Stop() + retry = nil + w.mutex.Lock() + w.retrying = false w.mutex.Unlock() } var pairing sync.WaitGroup + cancel := func() {} defer func() { cancel() @@ -272,18 +287,21 @@ func (w *WhatsApp) Run(ctx context.Context, l *TurnLoop, notify func(Event)) err connect() case <-w.logouts: stopRetry() + err = w.loggedOut(ctx, l) if err != nil { return err } case request := <-w.requests: - stopRetry() cancel() pairing.Wait() + cancel = func() {} switch { case request.unlink: + stopRetry() + err = w.unlink(ctx, l, request.answer) if err != nil { return err @@ -315,6 +333,7 @@ func (w *WhatsApp) Command(args string, answer func(text string)) { switch { case len(fields) == 1 && fields[0] == "status": answer(w.Status()) + return case len(fields) == 1 && fields[0] == "unlink": request.unlink = true @@ -322,12 +341,14 @@ func (w *WhatsApp) Command(args string, answer func(text string)) { 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 } @@ -339,28 +360,90 @@ 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 } } +// 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() @@ -442,8 +525,10 @@ func (w *WhatsApp) link() WhatsAppLink { // authentication. func (w *WhatsApp) connect(ctx context.Context) bool { w.mutex.Lock() + if ctx.Err() != nil || !w.linked || !w.retrying || w.closed { w.mutex.Unlock() + return false } @@ -455,18 +540,22 @@ func (w *WhatsApp) connect(ctx context.Context) bool { w.mutex.Unlock() err := client.ConnectContext(ctx) + w.mutex.Lock() + if err == nil || ctx.Err() != nil || !w.retrying || !w.linked { w.retrying = false w.mutex.Unlock() + return false } first := w.startOutage() cause := whatsappRedact(w.own, err.Error()) 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 @@ -493,6 +582,7 @@ func (w *WhatsApp) startOutage() bool { // 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() @@ -516,7 +606,8 @@ 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, run /whatsapp pair PHONE") + err := w.inbox.deliver(ctx, l, w.link(), true) if err != nil { return err @@ -524,12 +615,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.") @@ -544,12 +635,14 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { // 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 } @@ -559,6 +652,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) defer cancel() @@ -569,17 +663,20 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str err = w.removeSession() if err != nil { answer("The unlink failed: " + w.redact(err.Error())) + 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 { 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 } @@ -589,9 +686,14 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str } // removeSession ends the connection, closes the session database, and deletes -// its files. +// 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() + client := w.client w.client = nil w.linked = false @@ -616,6 +718,7 @@ func (w *WhatsApp) removeSession() error { } var err error + if container != nil { err = container.Close() } @@ -645,6 +748,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, device, err := w.newDevice(ctx) if err != nil { answer("The pairing failed: " + err.Error()) + return } @@ -663,6 +767,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, if err != nil { answer("The connection to WhatsApp failed: " + err.Error()) + return } @@ -670,6 +775,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, case item, open := <-qr: if !open || item.Event != whatsmeow.QRChannelEventCode { answer("WhatsApp did not start the pairing. Try again later.") + return } case <-ctx.Done(): @@ -685,6 +791,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, 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 } @@ -693,6 +800,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, for { var item whatsmeow.QRChannelItem + open := true select { case item, open = <-qr: @@ -707,17 +815,19 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, 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) - 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 + ".") @@ -725,6 +835,7 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, return default: answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.") + return } } @@ -734,6 +845,9 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, // 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() @@ -797,16 +911,24 @@ func (w *WhatsApp) handle(event any) bool { 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, line string + + level := slog.LevelInfo + + var attrs []any + w.mutex.Lock() + switch event := event.(type) { case *events.PairSuccess: w.own = whatsappOwnIDs(event.ID.User, event.LID.User) @@ -816,7 +938,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 @@ -833,6 +956,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" @@ -850,7 +974,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())) } } @@ -861,7 +987,7 @@ func (w *WhatsApp) handle(event any) bool { w.mutex.Unlock() if line != "" { - w.logger.Print(line) + w.logger.Log(context.Background(), level, line, attrs...) } if notice != "" { @@ -875,6 +1001,7 @@ func (w *WhatsApp) handle(event any) bool { // 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 @@ -891,6 +1018,7 @@ func (w *WhatsApp) disconnectedLong(disconnections int) { // 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() @@ -935,6 +1063,7 @@ type WhatsAppRequest struct { // 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() } @@ -998,6 +1127,7 @@ 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)