X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/522d7fd117285e4e4ce3ea5ec9b5a1722521b681..12bd9e96f3b3e67290484e3829461e054110db27:/whatsapp.go?ds=sidebyside

diff --git a/whatsapp.go b/whatsapp.go
index 6e1e1e6..4950d28 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,6 +92,8 @@ 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)
 }
@@ -103,26 +103,26 @@ 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,
-		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) {
@@ -163,11 +163,16 @@ 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.
+//
+// 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 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,17 +182,19 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // 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
-
+	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
@@ -218,6 +225,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
@@ -303,7 +311,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()
@@ -354,28 +362,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()
 
@@ -394,10 +464,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 {
@@ -487,7 +557,7 @@ 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
@@ -501,7 +571,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)
 		})
 	}
@@ -538,7 +608,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, run /whatsapp pair PHONE")
 
 	err := w.inbox.deliver(ctx, l, w.link(), true)
 	if err != nil {
@@ -547,12 +617,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 +656,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 +669,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 {
@@ -618,8 +688,12 @@ 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
@@ -751,11 +825,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 + ".")
@@ -773,6 +847,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()
 
@@ -815,19 +892,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)
@@ -848,6 +931,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 +946,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 +964,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 +982,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 +995,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 != "" {
@@ -1054,6 +1145,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 {