import (
"context"
+ "database/sql"
"errors"
"fmt"
- "log"
+ "log/slog"
"net/url"
"os"
"path/filepath"
// 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,
}
var err error
+
w.state, err = openWhatsAppState(filepath.Join(w.dir, whatsappStateFileName), whatsappBatchQuiet, whatsappBatchWindow)
if err != nil {
return nil, err
if w.device.ID != nil {
w.linked = true
w.inbox.waitForCatchup()
+
w.own = whatsappOwnIDs(w.device.ID.User, w.device.LID.User)
}
// 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
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
groups *WhatsAppGroups
inbox *WhatsAppInbox
+ sessionMutex sync.Mutex
mutex sync.Mutex
container *sqlstore.Container
device *store.Device
// 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
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)
}
stopRetry := func() {
timer.Stop()
+
retry = nil
+
w.mutex.Lock()
+
w.retrying = false
w.mutex.Unlock()
}
var pairing sync.WaitGroup
+
cancel := func() {}
defer func() {
cancel()
connect()
case <-w.logouts:
stopRetry()
+
err = w.loggedOut(ctx, l)
if err != nil {
return err
case request := <-w.requests:
cancel()
pairing.Wait()
+
cancel = func() {}
switch {
case request.unlink:
stopRetry()
+
err = w.unlink(ctx, l, request.answer)
if err != nil {
return err
switch {
case len(fields) == 1 && fields[0] == "status":
answer(w.Status())
+
return
case len(fields) == 1 && fields[0] == "unlink":
request.unlink = true
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
}
}
}
+// 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()
// 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
}
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
// 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()
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
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.")
// 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
}
}
var logoutErr error
+
if client != nil {
ctx, cancel := context.WithTimeout(ctx, whatsappLogoutTime)
defer cancel()
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
}
}
// 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
}
var err error
+
if container != nil {
err = container.Close()
}
device, err := w.newDevice(ctx)
if err != nil {
answer("The pairing failed: " + err.Error())
+
return
}
if err != nil {
answer("The connection to WhatsApp failed: " + err.Error())
+
return
}
case item, open := <-qr:
if !open || item.Event != whatsmeow.QRChannelEventCode {
answer("WhatsApp did not start the pairing. Try again later.")
+
return
}
case <-ctx.Done():
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
}
for {
var item whatsmeow.QRChannelItem
+
open := true
select {
case item, open = <-qr:
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 + ".")
return
default:
answer("The pairing failed: " + whatsappItemError(item) + ". Run /whatsapp pair PHONE again.")
+
return
}
}
// 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()
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)
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
case *events.Disconnected:
connected := w.connected
if w.startOutage() {
+ level = slog.LevelWarn
line = "disconnected, retrying"
if !connected {
line = "first connect failed, retrying"
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()))
}
}
w.mutex.Unlock()
if line != "" {
- w.logger.Print(line)
+ w.logger.Log(context.Background(), level, line, attrs...)
}
if notice != "" {
// 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
// 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()
// 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()
}
// 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)
projects / onechat / blobdiff