package main import ( "fmt" "reflect" "strings" "sync" log "github.com/sirupsen/logrus" . "git.deuxfleurs.fr/Deuxfleurs/easybridge/connector" // Necessary for them to register their protocols _ "git.deuxfleurs.fr/Deuxfleurs/easybridge/connector/external" _ "git.deuxfleurs.fr/Deuxfleurs/easybridge/connector/irc" _ "git.deuxfleurs.fr/Deuxfleurs/easybridge/connector/mattermost" _ "git.deuxfleurs.fr/Deuxfleurs/easybridge/connector/xmpp" ) type Account struct { MatrixUser string AccountName string Protocol string Config map[string]string Conn Connector JoinedRooms map[RoomID]bool } var accountsLock sync.Mutex var registeredAccounts = map[string]map[string]*Account{} func SetAccount(mxid string, name string, protocol string, config map[string]string) error { accountsLock.Lock() defer accountsLock.Unlock() if _, ok := registeredAccounts[mxid]; !ok { registeredAccounts[mxid] = make(map[string]*Account) } accounts := registeredAccounts[mxid] // Check we can create connector proto, ok := Protocols[protocol] if !ok { return fmt.Errorf("Invalid protocol: %s", protocol) } conn := proto.NewConnector() if conn == nil { return fmt.Errorf("Could not create connector for protocol %s", protocol) } // If the account existed already, close and drop connector if prev_acct, ok := accounts[name]; ok { if prev_acct.Protocol == protocol && reflect.DeepEqual(config, prev_acct.Config) { return nil } go prev_acct.Conn.Close() delete(accounts, name) } // Configure and connect account := &Account{ MatrixUser: mxid, AccountName: name, Protocol: protocol, Config: config, Conn: conn, JoinedRooms: map[RoomID]bool{}, } conn.SetHandler(account) accounts[name] = account go account.connect() return nil } func ListAccounts(mxUser string) []*Account { accountsLock.Lock() defer accountsLock.Unlock() ret := []*Account{} if accts, ok := registeredAccounts[mxUser]; ok { for _, acct := range accts { ret = append(ret, acct) } } return ret } func FindAccount(mxUser string, name string) *Account { accountsLock.Lock() defer accountsLock.Unlock() if u, ok := registeredAccounts[mxUser]; ok { if a, ok := u[name]; ok { return a } } return nil } func FindJoinedAccount(mxUser string, protocol string, room RoomID) *Account { accountsLock.Lock() defer accountsLock.Unlock() if u, ok := registeredAccounts[mxUser]; ok { for _, acct := range u { if acct.Protocol == protocol { if j, ok := acct.JoinedRooms[room]; ok && j { return acct } } } } return nil } func RemoveAccount(mxUser string, name string) { accountsLock.Lock() defer accountsLock.Unlock() if u, ok := registeredAccounts[mxUser]; ok { if acct, ok := u[name]; ok { acct.Conn.Close() } delete(u, name) } } func CloseAllAccountsForShutdown() { accountsLock.Lock() defer accountsLock.Unlock() for _, accl := range registeredAccounts { for _, acct := range accl { log.Printf("Closing %s %s (%s)", acct.MatrixUser, acct.AccountName, acct.Protocol) acct.Conn.Close() } } } // ---- func SaveDbAccounts(mxid string, key *[32]byte) { accountsLock.Lock() defer accountsLock.Unlock() if accounts, ok := registeredAccounts[mxid]; ok { for name, acct := range accounts { var entry DbAccountConfig db.Where(&DbAccountConfig{ MxUserID: mxid, Name: name, }).Assign(&DbAccountConfig{ Protocol: acct.Protocol, Config: encryptAccountConfig(acct.Config, key), }).FirstOrCreate(&entry) } } } func LoadDbAccounts(mxid string, key *[32]byte) { var allAccounts []DbAccountConfig db.Where(&DbAccountConfig{MxUserID: mxid}).Find(&allAccounts) for _, acct := range allAccounts { config, err := decryptAccountConfig(acct.Config, key) if err != nil { ezbrSystemSendf("Could not decrypt stored configuration for account %s (%s)", acct.Name, acct.Protocol) continue } err = SetAccount(mxid, acct.Name, acct.Protocol, config) if err != nil { ezbrSystemSendf(mxid, "Could not setup account %s: %s", acct.Name, err.Error()) } } } // ---- func (a *Account) ezbrMessagef(format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) msg = fmt.Sprintf("%s: %s", a.Protocol, msg) ezbrSystemSend(a.MatrixUser, msg) } func (a *Account) connect() { log.Printf("Connecting %s %s (%s)", a.MatrixUser, a.AccountName, a.Protocol) ezbrSystemSendf(a.MatrixUser, "Connecting to account %s (%s)", a.AccountName, a.Protocol) err := a.Conn.Configure(a.Config) if err != nil { ezbrSystemSendf(a.MatrixUser, "%s (%s) cannot connect: %s", a.AccountName, a.Protocol, err.Error()) return } var autojoin []DbJoinedRoom db.Where(&DbJoinedRoom{ MxUserID: a.MatrixUser, Protocol: a.Protocol, AccountName: a.AccountName, }).Find(&autojoin) for _, aj := range autojoin { err := a.Conn.Join(aj.RoomID) if err != nil { ezbrSystemSendf(a.MatrixUser, "%s (%s) cannot join %s: %s", a.AccountName, a.Protocol, aj.RoomID, err.Error()) } } } func (a *Account) addAutojoin(roomId RoomID) { var entry DbJoinedRoom db.Where(&DbJoinedRoom{ MxUserID: a.MatrixUser, Protocol: a.Protocol, AccountName: a.AccountName, RoomID: roomId, }).FirstOrCreate(&entry) } func (a *Account) delAutojoin(roomId RoomID) { db.Where(&DbJoinedRoom{ MxUserID: a.MatrixUser, Protocol: a.Protocol, AccountName: a.AccountName, RoomID: roomId, }).Delete(&DbJoinedRoom{}) } // ---- Begin event handlers ---- func (a *Account) SaveConfig(config Configuration) { a.Config = config if key, ok := userKeys[a.MatrixUser]; ok { var entry DbAccountConfig db.Where(&DbAccountConfig{ MxUserID: a.MatrixUser, Name: a.AccountName, }).Assign(&DbAccountConfig{ Protocol: a.Protocol, Config: encryptAccountConfig(a.Config, key), }).FirstOrCreate(&entry) } } func (a *Account) Joined(roomId RoomID) { err := a.joinedInternal(roomId) if err != nil { a.ezbrMessagef("Dropping Account.Joined %s: %s", roomId, err.Error()) } } func (a *Account) joinedInternal(roomId RoomID) error { a.JoinedRooms[roomId] = true a.addAutojoin(roomId) mx_room_id, err := dbGetMxRoom(a.Protocol, roomId) if err != nil { return err } log.Tracef("Joined %s (%s)\n", roomId, a.MatrixUser) err = mx.RoomInvite(mx_room_id, a.MatrixUser) if err != nil && strings.Contains(err.Error(), "already in the room") { err = nil } return err } // ---- func (a *Account) Left(roomId RoomID) { err := a.leftInternal(roomId) if err != nil { a.ezbrMessagef("Dropping Account.Left %s: %s", roomId, err.Error()) } } func (a *Account) leftInternal(roomId RoomID) error { delete(a.JoinedRooms, roomId) a.delAutojoin(roomId) mx_room_id, err := dbGetMxRoom(a.Protocol, roomId) if err != nil { return err } log.Tracef("Left %s (%s)\n", roomId, a.MatrixUser) err = mx.RoomKick(mx_room_id, a.MatrixUser, fmt.Sprintf("got leave room event on %s", a.Protocol)) if err != nil && strings.Contains(err.Error(), "not in the room") { err = nil } return err } // ---- func (a *Account) UserInfoUpdated(user UserID, info *UserInfo) { err := a.userInfoUpdatedInternal(user, info) if err != nil { a.ezbrMessagef("Dropping Account.UserInfoUpdated %s: %s", user, err.Error()) } } func (a *Account) userInfoUpdatedInternal(user UserID, info *UserInfo) error { mx_user_id, err := dbGetMxUser(a.Protocol, user) if err != nil { return err } if info.DisplayName != "" { err2 := mx.ProfileDisplayname(mx_user_id, fmt.Sprintf("%s (%s)", info.DisplayName, a.Protocol)) if err2 != nil { err = err2 } } if info.Avatar.MediaObject != nil { cache_key := fmt.Sprintf("%s/user_avatar/%s", a.Protocol, user) cache_val := info.Avatar.Filename() if cache_val == "" || dbKvGet(cache_key) != cache_val { err2 := mx.ProfileAvatar(mx_user_id, info.Avatar) if err2 == nil { dbKvPut(cache_key, cache_val) } else { err = err2 } } } return err } // ---- func (a *Account) RoomInfoUpdated(roomId RoomID, author UserID, info *RoomInfo) { err := a.roomInfoUpdatedInternal(roomId, author, info) if err != nil { a.ezbrMessagef("Dropping Account.RoomInfoUpdated %s: %s", roomId, err.Error()) } } func (a *Account) roomInfoUpdatedInternal(roomId RoomID, author UserID, info *RoomInfo) error { mx_room_id, err := dbGetMxRoom(a.Protocol, roomId) if err != nil { return err } as_mxid := ezbrMxId() if author == a.Conn.User() { as_mxid = a.MatrixUser } else if len(author) > 0 { mx_user_id, err2 := dbGetMxUser(a.Protocol, author) if err2 == nil { as_mxid = mx_user_id } } if info.Topic != "" { err2 := mx.RoomTopicAs(mx_room_id, info.Topic, as_mxid) if err2 != nil { err = err2 } } if info.Name != "" { name := fmt.Sprintf("%s (%s)", info.Name, a.Protocol) err2 := mx.RoomNameAs(mx_room_id, name, as_mxid) if err2 != nil { err = err2 } } if info.Picture.MediaObject != nil { cache_key := fmt.Sprintf("%s/room_picture/%s", a.Protocol, roomId) cache_val := info.Picture.Filename() if cache_val == "" || dbKvGet(cache_key) != cache_val { err2 := mx.RoomAvatarAs(mx_room_id, info.Picture, as_mxid) if err2 == nil { dbKvPut(cache_key, cache_val) } else { err = err2 } } } return err } // ---- func (a *Account) Event(event *Event) { err := a.eventInternal(event) if err != nil { a.ezbrMessagef("Dropping Account.Event %s %s %s: %s", event.Author, event.Recipient, event.Room, err.Error()) } } func (a *Account) eventInternal(event *Event) error { // TODO: automatically ignore events that come from one of our bridged matrix users // TODO: deduplicate events if we have several matrix users joined the same room (hard problem) mx_user_id, err := dbGetMxUser(a.Protocol, event.Author) if err != nil { return err } if event.Type == EVENT_JOIN { log.Tracef("%s join %s %s", a.Protocol, event.Author, event.Room) mx_room_id, err := dbGetMxRoom(a.Protocol, event.Room) if err != nil { return err } err = mx.RoomInvite(mx_room_id, mx_user_id) if err != nil { if strings.Contains(err.Error(), "already in the room") { return nil } return err } return mx.RoomJoinAs(mx_room_id, mx_user_id) } else if event.Type == EVENT_LEAVE { log.Tracef("%s join %s %s", a.Protocol, event.Author, event.Room) mx_room_id, err := dbGetMxRoom(a.Protocol, event.Room) if err != nil { return err } return mx.RoomLeaveAs(mx_room_id, mx_user_id) } else { log.Tracef("%s msg %s %s", a.Protocol, event.Author, event.Room) mx_room_id := "" if len(event.Room) > 0 { mx_room_id, err = dbGetMxRoom(a.Protocol, event.Room) if err != nil { return err } } else { mx_room_id, err = dbGetMxPmRoom(a.Protocol, event.Author, mx_user_id, a.MatrixUser, a.AccountName) if err != nil { return err } } var cache_key string if event.Id != "" { // Use mx_room_id as a lock slot key, because this section is // concurrent with the part that sends events out in server.go, // and at that point we don't know the event's ID yet // since it will be attributed by the backend during the call to send dbLockSlot(mx_room_id) defer dbUnlockSlot(mx_room_id) // If the event has an ID, make sure it is processed only once cache_key = fmt.Sprintf("%s/event_seen/%s/%s", a.Protocol, mx_room_id, event.Id) if dbKvGet(cache_key) == "yes" { // false: cache key was not modified, meaning we // already saw the event return nil } } typ := "m.text" if event.Type == EVENT_ACTION { typ = "m.emote" } err = mx.SendMessageAs(mx_room_id, typ, event.Text, mx_user_id) if err != nil { return err } if event.Attachments != nil { for _, file := range event.Attachments { mxfile, err := mx.UploadMedia(file) if err != nil { return err } content := map[string]interface{}{ "body": mxfile.Filename(), "filename": mxfile.Filename(), "url": fmt.Sprintf("mxc://%s/%s", mxfile.MxcServer, mxfile.MxcMediaId), } if sz := mxfile.ImageSize(); sz != nil { content["msgtype"] = "m.image" content["info"] = map[string]interface{}{ "mimetype": mxfile.Mimetype(), "size": mxfile.Size(), "w": sz.Width, "h": sz.Height, } } else { content["msgtype"] = "m.file" content["info"] = map[string]interface{}{ "mimetype": mxfile.Mimetype(), "size": mxfile.Size(), } } err = mx.SendAs(mx_room_id, "m.room.message", content, mx_user_id) if err != nil { return err } } } // Mark message as received in db if cache_key != "" { dbKvPutLocked(cache_key, "yes") } return nil } } // ---- func (a *Account) CacheGet(key string) string { cache_key := fmt.Sprintf("%s/account/%s/%s/%s", a.Protocol, a.MatrixUser, a.AccountName, key) return dbKvGet(cache_key) } func (a *Account) CachePut(key string, value string) { cache_key := fmt.Sprintf("%s/account/%s/%s/%s", a.Protocol, a.MatrixUser, a.AccountName, key) dbKvPut(cache_key, value) }