X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/790279faf0fda789d93a75f6f5996e65d5de4a18..3b2bf881d484ba1a33ff77a342564b8195a75c80:/whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 95e1d54..be1acc6 100644
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"database/sql"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -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)
 }
@@ -105,6 +107,7 @@ 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{
+		ctx:         ctx,
 		dir:         filepath.Join(dir, whatsappDirName),
 		clock:       clock,
 		logger:      logger,
@@ -122,7 +125,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 		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 +166,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.
 //
-// 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.
+// 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
@@ -177,6 +185,7 @@ 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 {
+	ctx         context.Context
 	dir         string
 	clock       func() time.Time
 	logger      *slog.Logger
@@ -187,7 +196,9 @@ type WhatsApp struct {
 	state       *WhatsAppState
 	groups      *WhatsAppGroups
 	inbox       *WhatsAppInbox
+	routes      *Routes
 
+	sessionMutex   sync.Mutex
 	mutex          sync.Mutex
 	container      *sqlstore.Container
 	device         *store.Device
@@ -218,6 +229,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
@@ -354,28 +366,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()
 
@@ -618,8 +692,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
@@ -773,6 +851,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()
 
@@ -825,9 +906,14 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 // 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)
@@ -912,7 +998,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 != "" {