mautrix-whatsapp/main.go

509 lines
16 KiB
Go
Raw Normal View History

// mautrix-whatsapp - A Matrix-WhatsApp puppeting bridge.
// Copyright (C) 2022 Tulir Asokan
2018-08-12 21:26:05 +02:00
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
package main
import (
2021-10-31 19:42:53 +01:00
_ "embed"
"errors"
"fmt"
"os"
"os/signal"
2021-10-22 19:14:34 +02:00
"strconv"
"strings"
"sync"
"syscall"
2019-11-10 20:22:11 +01:00
"time"
2018-08-26 21:53:13 +02:00
2021-10-22 19:14:34 +02:00
"google.golang.org/protobuf/proto"
waProto "go.mau.fi/whatsmeow/binary/proto"
"go.mau.fi/whatsmeow/store"
"go.mau.fi/whatsmeow/store/sqlstore"
"go.mau.fi/whatsmeow/types"
2021-02-17 00:21:30 +01:00
2018-08-26 21:53:13 +02:00
flag "maunium.net/go/mauflag"
2019-01-11 20:17:31 +01:00
log "maunium.net/go/maulogger/v2"
2019-11-10 20:22:11 +01:00
"maunium.net/go/mautrix"
2020-05-09 13:31:06 +02:00
"maunium.net/go/mautrix/appservice"
"maunium.net/go/mautrix/event"
2020-05-08 21:32:22 +02:00
"maunium.net/go/mautrix/id"
2019-01-11 20:17:31 +01:00
2018-08-26 21:53:13 +02:00
"maunium.net/go/mautrix-whatsapp/config"
"maunium.net/go/mautrix-whatsapp/database"
2019-11-10 20:22:11 +01:00
"maunium.net/go/mautrix-whatsapp/database/upgrades"
)
// The name and repo URL of the bridge.
var (
Name = "mautrix-whatsapp"
2021-08-06 16:46:57 +02:00
URL = "https://github.com/mautrix/whatsapp"
)
// Information to find out exactly which commit the bridge was built from.
// These are filled at build time with the -X linker flag.
var (
2020-06-03 19:59:44 +02:00
Tag = "unknown"
Commit = "unknown"
BuildTime = "unknown"
)
var (
// Version is the version number of the bridge. Changed manually when making a release.
2022-02-16 11:15:38 +01:00
Version = "0.2.4"
// WAVersion is the version number exposed to WhatsApp. Filled in init()
WAVersion = ""
// VersionString is the bridge version, plus commit information. Filled in init() using the build-time values.
VersionString = ""
)
2021-10-31 12:04:44 +01:00
//go:embed example-config.yaml
var ExampleConfig string
func init() {
if len(Tag) > 0 && Tag[0] == 'v' {
Tag = Tag[1:]
}
2021-04-25 14:46:06 +02:00
if Tag != Version {
suffix := ""
if !strings.HasSuffix(Version, "+dev") {
suffix = "+dev"
}
if len(Commit) > 8 {
Version = fmt.Sprintf("%s%s.%s", Version, suffix, Commit[:8])
} else {
Version = fmt.Sprintf("%s%s.unknown", Version, suffix)
}
2020-06-03 19:44:52 +02:00
}
mautrix.DefaultUserAgent = fmt.Sprintf("mautrix-whatsapp/%s %s", Version, mautrix.DefaultUserAgent)
2020-06-03 19:59:44 +02:00
WAVersion = strings.FieldsFunc(Version, func(r rune) bool { return r == '-' || r == '+' })[0]
2021-04-25 14:46:06 +02:00
VersionString = fmt.Sprintf("%s %s (%s)", Name, Version, BuildTime)
2021-10-31 12:04:44 +01:00
config.ExampleConfig = ExampleConfig
}
var configPath = flag.MakeFull("c", "config", "The path to your config file.", "config.yaml").String()
var dontSaveConfig = flag.MakeFull("n", "no-update", "Don't save updated config to disk.", "false").Bool()
var registrationPath = flag.MakeFull("r", "registration", "The path where to save the appservice registration.", "registration.yaml").String()
var generateRegistration = flag.MakeFull("g", "generate-registration", "Generate registration and quit.", "false").Bool()
var version = flag.MakeFull("v", "version", "View bridge version and quit.", "false").Bool()
var ignoreUnsupportedDatabase = flag.Make().LongKey("ignore-unsupported-database").Usage("Run even if database is too new").Default("false").Bool()
2019-08-25 18:26:04 +02:00
var migrateFrom = flag.Make().LongKey("migrate-db").Usage("Source database type and URI to migrate from.").Bool()
var wantHelp, _ = flag.MakeHelpFlag()
func (bridge *Bridge) GenerateRegistration() {
if *dontSaveConfig {
// We need to save the generated as_token and hs_token in the config
_, _ = fmt.Fprintln(os.Stderr, "--no-update is not compatible with --generate-registration")
os.Exit(5)
}
reg, err := bridge.Config.NewRegistration()
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to generate registration:", err)
os.Exit(20)
}
err = reg.Save(*registrationPath)
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to save registration:", err)
os.Exit(21)
}
err = config.Mutate(*configPath, func(helper *config.UpgradeHelper) {
helper.Set(config.Str, bridge.Config.AppService.ASToken, "appservice", "as_token")
helper.Set(config.Str, bridge.Config.AppService.HSToken, "appservice", "hs_token")
})
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to save config:", err)
os.Exit(22)
}
fmt.Println("Registration generated. Add the path to the registration to your Synapse config, restart it, then start the bridge.")
os.Exit(0)
}
2019-08-25 18:26:04 +02:00
func (bridge *Bridge) MigrateDatabase() {
oldDB, err := database.New(config.DatabaseConfig{Type: flag.Arg(0), URI: flag.Arg(1)}, log.DefaultLogger)
2019-08-25 18:26:04 +02:00
if err != nil {
fmt.Println("Failed to open old database:", err)
os.Exit(30)
}
err = oldDB.Init()
if err != nil {
fmt.Println("Failed to upgrade old database:", err)
os.Exit(31)
}
newDB, err := database.New(bridge.Config.AppService.Database, log.DefaultLogger)
2019-08-25 18:26:04 +02:00
if err != nil {
2020-07-30 20:41:04 +02:00
fmt.Println("Failed to open new database:", err)
2019-08-25 18:26:04 +02:00
os.Exit(32)
}
err = newDB.Init()
if err != nil {
fmt.Println("Failed to upgrade new database:", err)
os.Exit(33)
}
database.Migrate(oldDB, newDB)
}
type Bridge struct {
AS *appservice.AppService
EventProcessor *appservice.EventProcessor
MatrixHandler *MatrixHandler
Config *config.Config
DB *database.Database
Log log.Logger
StateStore *database.SQLStateStore
2020-02-09 19:32:14 +01:00
Provisioning *ProvisioningAPI
Bot *appservice.IntentAPI
Formatter *Formatter
Crypto Crypto
Metrics *MetricsHandler
2021-10-22 19:14:34 +02:00
WAContainer *sqlstore.Container
2020-05-08 21:32:22 +02:00
usersByMXID map[id.UserID]*User
2021-10-22 19:14:34 +02:00
usersByUsername map[string]*User
usersLock sync.Mutex
spaceRooms map[id.RoomID]*User
spaceRoomsLock sync.Mutex
managementRooms map[id.RoomID]*User
managementRoomsLock sync.Mutex
2020-05-08 21:32:22 +02:00
portalsByMXID map[id.RoomID]*Portal
portalsByJID map[database.PortalKey]*Portal
portalsLock sync.Mutex
2021-10-22 19:14:34 +02:00
puppets map[types.JID]*Puppet
2020-05-08 21:32:22 +02:00
puppetsByCustomMXID map[id.UserID]*Puppet
puppetsLock sync.Mutex
}
type Crypto interface {
HandleMemberEvent(*event.Event)
Decrypt(*event.Event) (*event.Event, error)
Encrypt(id.RoomID, event.Type, event.Content) (*event.EncryptedEventContent, error)
WaitForSession(id.RoomID, id.SenderKey, id.SessionID, time.Duration) bool
RequestSession(id.RoomID, id.SenderKey, id.SessionID, id.UserID, id.DeviceID)
ResetSession(id.RoomID)
2020-05-09 19:07:21 +02:00
Init() error
Start()
Stop()
}
func (bridge *Bridge) ensureConnection() {
for {
2020-05-08 21:32:22 +02:00
resp, err := bridge.Bot.Whoami()
if err != nil {
if errors.Is(err, mautrix.MUnknownToken) {
bridge.Log.Fatalln("The as_token was not accepted. Is the registration file installed in your homeserver correctly?")
os.Exit(16)
} else if errors.Is(err, mautrix.MExclusive) {
bridge.Log.Fatalln("The as_token was accepted, but the /register request was not. Are the homeserver domain and username template in the config correct, and do they match the values in the registration?")
os.Exit(16)
}
bridge.Log.Errorfln("Failed to connect to homeserver: %v. Retrying in 10 seconds...", err)
time.Sleep(10 * time.Second)
} else if resp.UserID != bridge.Bot.UserID {
bridge.Log.Fatalln("Unexpected user ID in whoami call: got %s, expected %s", resp.UserID, bridge.Bot.UserID)
os.Exit(17)
} else {
break
}
}
}
func (bridge *Bridge) Init() {
var err error
2018-08-16 18:20:07 +02:00
bridge.AS, err = bridge.Config.MakeAppService()
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to initialize AppService:", err)
2018-08-29 22:48:15 +02:00
os.Exit(11)
}
_, _ = bridge.AS.Init()
bridge.Log = log.Create()
bridge.Config.Logging.Configure(bridge.Log)
2018-08-16 18:20:07 +02:00
log.DefaultLogger = bridge.Log.(*log.BasicLogger)
if len(bridge.Config.Logging.FileNameFormat) > 0 {
err = log.OpenFile()
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to open log file:", err)
os.Exit(12)
}
}
bridge.AS.Log = log.Sub("Matrix")
bridge.Bot = bridge.AS.BotIntent()
2021-04-25 14:46:06 +02:00
bridge.Log.Infoln("Initializing", VersionString)
2018-08-16 18:20:07 +02:00
2020-11-02 15:16:36 +01:00
bridge.Log.Debugln("Initializing database connection")
bridge.DB, err = database.New(bridge.Config.AppService.Database, bridge.Log)
2020-11-02 15:16:36 +01:00
if err != nil {
bridge.Log.Fatalln("Failed to initialize database connection:", err)
2018-08-29 22:48:15 +02:00
os.Exit(14)
}
bridge.Log.Debugln("Initializing state store")
bridge.StateStore = database.NewSQLStateStore(bridge.DB)
bridge.AS.StateStore = bridge.StateStore
2021-10-22 19:14:34 +02:00
bridge.WAContainer = sqlstore.NewWithDB(bridge.DB.DB, bridge.Config.AppService.Database.Type, nil)
2020-02-09 19:32:14 +01:00
ss := bridge.Config.AppService.Provisioning.SharedSecret
if len(ss) > 0 && ss != "disable" {
bridge.Provisioning = &ProvisioningAPI{bridge: bridge}
}
bridge.Log.Debugln("Initializing Matrix event processor")
bridge.EventProcessor = appservice.NewEventProcessor(bridge.AS)
bridge.Log.Debugln("Initializing Matrix event handler")
bridge.MatrixHandler = NewMatrixHandler(bridge)
bridge.Formatter = NewFormatter(bridge)
2020-05-09 19:07:21 +02:00
bridge.Crypto = NewCryptoHelper(bridge)
bridge.Metrics = NewMetricsHandler(bridge.Config.Metrics.Listen, bridge.Log.Sub("Metrics"), bridge.DB)
2021-10-22 19:14:34 +02:00
store.BaseClientPayload.UserAgent.OsVersion = proto.String(WAVersion)
store.BaseClientPayload.UserAgent.OsBuildNumber = proto.String(WAVersion)
store.CompanionProps.Os = proto.String(bridge.Config.WhatsApp.OSName)
store.CompanionProps.RequireFullSync = proto.Bool(bridge.Config.Bridge.HistorySync.RequestFullSync)
2021-10-22 19:14:34 +02:00
versionParts := strings.Split(WAVersion, ".")
if len(versionParts) > 2 {
primary, _ := strconv.Atoi(versionParts[0])
secondary, _ := strconv.Atoi(versionParts[1])
tertiary, _ := strconv.Atoi(versionParts[2])
store.CompanionProps.Version.Primary = proto.Uint32(uint32(primary))
store.CompanionProps.Version.Secondary = proto.Uint32(uint32(secondary))
store.CompanionProps.Version.Tertiary = proto.Uint32(uint32(tertiary))
}
platformID, ok := waProto.CompanionProps_CompanionPropsPlatformType_value[strings.ToUpper(bridge.Config.WhatsApp.BrowserName)]
if ok {
store.CompanionProps.PlatformType = waProto.CompanionProps_CompanionPropsPlatformType(platformID).Enum()
}
}
func (bridge *Bridge) Start() {
2020-11-02 15:16:36 +01:00
bridge.Log.Debugln("Running database upgrades")
err := bridge.DB.Init()
2020-11-02 15:16:36 +01:00
if err != nil && (err != upgrades.UnsupportedDatabaseVersion || !*ignoreUnsupportedDatabase) {
bridge.Log.Fatalln("Failed to initialize database:", err)
2018-08-29 22:48:15 +02:00
os.Exit(15)
}
bridge.Log.Debugln("Checking connection to homeserver")
bridge.ensureConnection()
2020-05-09 19:07:21 +02:00
if bridge.Crypto != nil {
err = bridge.Crypto.Init()
2020-05-09 19:07:21 +02:00
if err != nil {
bridge.Log.Fatalln("Error initializing end-to-bridge encryption:", err)
os.Exit(19)
}
}
2020-02-09 19:32:14 +01:00
if bridge.Provisioning != nil {
bridge.Log.Debugln("Initializing provisioning API")
bridge.Provisioning.Init()
}
bridge.Log.Debugln("Starting application service HTTP server")
go bridge.AS.Start()
bridge.Log.Debugln("Starting event processor")
go bridge.EventProcessor.Start()
2018-08-16 18:20:07 +02:00
go bridge.UpdateBotProfile()
2020-05-21 20:56:46 +02:00
if bridge.Crypto != nil {
go bridge.Crypto.Start()
}
go bridge.StartUsers()
if bridge.Config.Metrics.Enabled {
go bridge.Metrics.Start()
}
if bridge.Config.Bridge.ResendBridgeInfo {
go bridge.ResendBridgeInfo()
}
go bridge.Loop()
bridge.AS.Ready = true
}
func (bridge *Bridge) Loop() {
for {
bridge.SleepAndDeleteUpcoming()
time.Sleep(1 * time.Hour)
bridge.WarnUsersAboutDisconnection()
}
}
func (bridge *Bridge) WarnUsersAboutDisconnection() {
bridge.usersLock.Lock()
for _, user := range bridge.usersByUsername {
if user.IsConnected() && !user.PhoneRecentlySeen(true) {
go user.sendPhoneOfflineWarning()
}
}
bridge.usersLock.Unlock()
}
func (bridge *Bridge) ResendBridgeInfo() {
if *dontSaveConfig {
bridge.Log.Warnln("Not setting resend_bridge_info to false in config due to --no-update flag")
} else {
err := config.Mutate(*configPath, func(helper *config.UpgradeHelper) {
helper.Set(config.Bool, "false", "bridge", "resend_bridge_info")
})
if err != nil {
bridge.Log.Errorln("Failed to save config after setting resend_bridge_info to false:", err)
}
}
bridge.Log.Infoln("Re-sending bridge info state event to all portals")
for _, portal := range bridge.GetAllPortals() {
portal.UpdateBridgeInfo()
}
bridge.Log.Infoln("Finished re-sending bridge info state events")
2018-08-16 18:20:07 +02:00
}
func (bridge *Bridge) UpdateBotProfile() {
bridge.Log.Debugln("Updating bot profile")
botConfig := &bridge.Config.AppService.Bot
2018-08-16 18:20:07 +02:00
var err error
2020-05-08 21:32:22 +02:00
var mxc id.ContentURI
2018-08-16 18:20:07 +02:00
if botConfig.Avatar == "remove" {
2020-05-08 21:32:22 +02:00
err = bridge.Bot.SetAvatarURL(mxc)
2018-08-16 18:20:07 +02:00
} else if len(botConfig.Avatar) > 0 {
2020-05-08 21:32:22 +02:00
mxc, err = id.ParseContentURI(botConfig.Avatar)
if err == nil {
err = bridge.Bot.SetAvatarURL(mxc)
}
botConfig.ParsedAvatar = mxc
2018-08-16 18:20:07 +02:00
}
if err != nil {
bridge.Log.Warnln("Failed to update bot avatar:", err)
}
if botConfig.Displayname == "remove" {
err = bridge.Bot.SetDisplayName("")
} else if len(botConfig.Displayname) > 0 {
err = bridge.Bot.SetDisplayName(botConfig.Displayname)
2018-08-16 18:20:07 +02:00
}
if err != nil {
bridge.Log.Warnln("Failed to update bot displayname:", err)
}
}
func (bridge *Bridge) StartUsers() {
2019-03-06 16:33:42 +01:00
bridge.Log.Debugln("Starting users")
foundAnySessions := false
for _, user := range bridge.GetAllUsers() {
2021-10-22 19:14:34 +02:00
if !user.JID.IsEmpty() {
foundAnySessions = true
}
go user.Connect()
}
if !foundAnySessions {
bridge.sendGlobalBridgeState(BridgeState{StateEvent: StateUnconfigured}.fill(nil))
}
bridge.Log.Debugln("Starting custom puppets")
2019-05-31 22:07:33 +02:00
for _, loopuppet := range bridge.GetAllPuppetsWithCustomMXID() {
go func(puppet *Puppet) {
puppet.log.Debugln("Starting custom puppet", puppet.CustomMXID)
err := puppet.StartCustomMXID(true)
if err != nil {
puppet.log.Errorln("Failed to start custom puppet:", err)
}
2019-05-31 22:07:33 +02:00
}(loopuppet)
}
}
func (bridge *Bridge) Stop() {
2020-05-21 20:56:46 +02:00
if bridge.Crypto != nil {
bridge.Crypto.Stop()
}
bridge.AS.Stop()
bridge.Metrics.Stop()
bridge.EventProcessor.Stop()
2021-10-22 19:14:34 +02:00
for _, user := range bridge.usersByUsername {
if user.Client == nil {
continue
}
bridge.Log.Debugln("Disconnecting", user.MXID)
2021-10-22 19:14:34 +02:00
user.Client.Disconnect()
close(user.historySyncs)
}
}
func (bridge *Bridge) Main() {
configData, upgraded, err := config.Upgrade(*configPath, !*dontSaveConfig)
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Error updating config:", err)
if configData == nil {
os.Exit(10)
}
}
bridge.Config, err = config.Load(configData, upgraded)
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, "Failed to parse config:", err)
os.Exit(10)
}
if *generateRegistration {
bridge.GenerateRegistration()
return
2019-08-25 18:26:04 +02:00
} else if *migrateFrom {
bridge.MigrateDatabase()
return
}
bridge.Init()
bridge.Log.Infoln("Bridge initialization complete, starting...")
bridge.Start()
bridge.Log.Infoln("Bridge started!")
c := make(chan os.Signal)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
<-c
bridge.Log.Infoln("Interrupt received, stopping...")
bridge.Stop()
bridge.Log.Infoln("Bridge stopped.")
os.Exit(0)
}
2018-08-12 21:26:05 +02:00
func main() {
flag.SetHelpTitles(
"mautrix-whatsapp - A Matrix-WhatsApp puppeting bridge.",
2019-08-25 18:26:04 +02:00
"mautrix-whatsapp [-h] [-c <path>] [-r <path>] [-g] [--migrate-db <source type> <source uri>]")
err := flag.Parse()
if err != nil {
_, _ = fmt.Fprintln(os.Stderr, err)
flag.PrintHelp()
os.Exit(1)
} else if *wantHelp {
flag.PrintHelp()
os.Exit(0)
2020-06-03 19:47:13 +02:00
} else if *version {
2021-04-25 14:46:06 +02:00
fmt.Println(VersionString)
2020-06-03 19:47:13 +02:00
return
}
(&Bridge{
usersByMXID: make(map[id.UserID]*User),
usersByUsername: make(map[string]*User),
spaceRooms: make(map[id.RoomID]*User),
managementRooms: make(map[id.RoomID]*User),
portalsByMXID: make(map[id.RoomID]*Portal),
portalsByJID: make(map[database.PortalKey]*Portal),
puppets: make(map[types.JID]*Puppet),
puppetsByCustomMXID: make(map[id.UserID]*Puppet),
}).Main()
}