+package main
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "log"
+ "net/url"
+ "os"
+ "path/filepath"
+ "strings"
+ "sync"
+ "time"
+
+ "go.mau.fi/whatsmeow"
+ "go.mau.fi/whatsmeow/store"
+ "go.mau.fi/whatsmeow/store/sqlstore"
+ "go.mau.fi/whatsmeow/types/events"
+ waLog "go.mau.fi/whatsmeow/util/log"
+
+ // The session store of the library opens SQLite with this pure Go
+ // driver.
+ _ "modernc.org/sqlite"
+)
+
+const (
+ // whatsappDirName is the directory of the WhatsApp files in the data
+ // directory.
+ whatsappDirName = "whatsapp"
+
+ // whatsappSessionFileName is the session database of the library in
+ // whatsappDirName.
+ whatsappSessionFileName = "session.db"
+
+ // whatsappCommand starts the input lines of the WhatsApp commands, such
+ // as "/whatsapp status".
+ whatsappCommand = "/whatsapp"
+
+ // whatsappUsage is the answer to a WhatsApp command that does not exist.
+ whatsappUsage = "Use /whatsapp status."
+
+ // whatsappTimeLayout is the layout of the times in the answers.
+ whatsappTimeLayout = "2006-01-02 15:04"
+)
+
+// WhatsAppClient is the part of the WhatsApp client that the daemon uses. The
+// real one is a *whatsmeow.Client from whatsappNewClient, and the tests use a
+// fake.
+type WhatsAppClient interface {
+ ConnectContext(ctx context.Context) error
+ Disconnect()
+}
+
+// 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 linked 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) {
+ w := &WhatsApp{
+ dir: filepath.Join(dir, whatsappDirName),
+ clock: clock,
+ logger: logger,
+ newClient: newClient,
+ }
+
+ path := filepath.Join(w.dir, whatsappSessionFileName)
+ info, err := os.Stat(path)
+ if errors.Is(err, os.ErrNotExist) {
+ return w, nil
+ }
+
+ if err != nil {
+ return nil, fmt.Errorf("read WhatsApp session: %w", err)
+ }
+
+ if info.Mode().Perm()&0o077 != 0 {
+ return nil, fmt.Errorf("%s holds the WhatsApp session, so its mode must be 0600", filepath.Join(whatsappDirName, whatsappSessionFileName))
+ }
+
+ address, err := whatsappSessionAddress(path)
+ if err != nil {
+ return nil, err
+ }
+
+ w.container, err = sqlstore.New(ctx, "sqlite", address, waLog.Noop)
+ if err != nil {
+ return nil, fmt.Errorf("open WhatsApp session: %w", err)
+ }
+
+ w.device, err = w.container.GetFirstDevice(ctx)
+ if err != nil {
+ return nil, errors.Join(fmt.Errorf("read WhatsApp device: %w", err), w.container.Close())
+ }
+
+ 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. A device with an ID is linked, and Run keeps it connected.
+// The library connects again by itself after a network failure. The mutex
+// protects the state of the connection, which the event handler of the library
+// changes from its own goroutines.
+//
+// The library logs nothing, because its log lines hold the ID of the own
+// account, which is the phone number of the user.
+type WhatsApp struct {
+ dir string
+ clock func() time.Time
+ logger *log.Logger
+ newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient
+ container *sqlstore.Container
+ device *store.Device
+ client WhatsAppClient
+
+ mutex sync.Mutex
+ connected bool
+ connectedAt time.Time
+ disconnectedAt time.Time
+}
+
+// Run connects a linked device and keeps the connection until ctx ends. A
+// failed first connection is logged, and the library tries again when the
+// failure is one of the network.
+func (w *WhatsApp) Run(ctx context.Context) {
+ if !w.linked() {
+ <-ctx.Done()
+ return
+ }
+
+ w.client = w.newClient(w.device, w.handle)
+ err := w.client.ConnectContext(ctx)
+ if err != nil {
+ w.logger.Printf("connect: %v", err)
+ }
+
+ <-ctx.Done()
+ w.client.Disconnect()
+}
+
+// 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)) {
+ switch strings.TrimSpace(args) {
+ case "status":
+ answer(w.Status())
+ default:
+ answer(whatsappUsage)
+ }
+}
+
+// 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."
+ 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 {
+ if w.container == nil {
+ return nil
+ }
+
+ return w.container.Close()
+}
+
+// linked tells if the session holds a linked device.
+func (w *WhatsApp) linked() bool {
+ return w.device != nil && w.device.ID != nil
+}
+
+// handle takes one event of the library and tells if it was handled. A
+// disconnection keeps the time of its start while the library tries again.
+func (w *WhatsApp) handle(event any) bool {
+ w.mutex.Lock()
+ defer w.mutex.Unlock()
+
+ switch event.(type) {
+ case *events.Connected:
+ w.connected = true
+ w.connectedAt = w.clock()
+ case *events.Disconnected:
+ if w.connected || w.disconnectedAt.IsZero() {
+ w.disconnectedAt = w.clock()
+ }
+
+ w.connected = false
+ }
+
+ return true
+}
+
+// whatsappNewClient returns the client of the library for device, with handle
+// as its event handler. The client tries again after a failed first
+// connection, acknowledges a message only after handle returns true, and
+// downloads no old history.
+func whatsappNewClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
+ client := whatsmeow.NewClient(device, waLog.Noop)
+ client.InitialAutoReconnect = true
+ client.SynchronousAck = true
+ client.ManualHistorySyncDownload = true
+ client.AddEventHandlerWithSuccessStatus(handle)
+
+ return client
+}
+
+// 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
+}
+
+// whatsappCommandArgs returns the text after /whatsapp of a line of a WhatsApp
+// command, or false for any other line.
+func whatsappCommandArgs(line string) (string, bool) {
+ line = strings.TrimSpace(line)
+ if line == whatsappCommand {
+ return "", true
+ }
+
+ args, found := strings.CutPrefix(line, whatsappCommand+" ")
+ if !found {
+ return "", false
+ }
+
+ return strings.TrimSpace(args), true
+}
projects / onechat / commitdiff