259 lines
7.3 KiB
Go
259 lines
7.3 KiB
Go
package appservice
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/gorilla/mux"
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"git.deuxfleurs.fr/Deuxfleurs/easybridge/connector"
|
|
"git.deuxfleurs.fr/Deuxfleurs/easybridge/mxlib"
|
|
)
|
|
|
|
type Config struct {
|
|
HttpBindAddr string
|
|
Server string
|
|
DbType string
|
|
DbPath string
|
|
MatrixDomain string
|
|
}
|
|
|
|
var registration *mxlib.Registration
|
|
var config *Config
|
|
|
|
var mx *mxlib.Client
|
|
|
|
func Start(r *mxlib.Registration, c *Config) (chan error, error) {
|
|
registration = r
|
|
config = c
|
|
|
|
mx = mxlib.NewClient(c.Server, r.AsToken)
|
|
|
|
err := InitDb()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = mx.RegisterUser(registration.SenderLocalpart)
|
|
if mxe, ok := err.(*mxlib.MxError); !ok || mxe.ErrCode != "M_USER_IN_USE" {
|
|
return nil, err
|
|
}
|
|
err = mx.ProfileDisplayname(ezbrMxId(), fmt.Sprintf("Easybridge (%s)", EASYBRIDGE_SYSTEM_PROTOCOL))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
router := mux.NewRouter()
|
|
router.HandleFunc("/_matrix/app/v1/transactions/{txnId}", handleTxn)
|
|
router.HandleFunc("/transactions/{txnId}", handleTxn)
|
|
|
|
errch := make(chan error)
|
|
go func() {
|
|
log.Printf("Starting HTTP server on %s", config.HttpBindAddr)
|
|
err := http.ListenAndServe(config.HttpBindAddr, checkTokenAndLog(router))
|
|
if err != nil {
|
|
errch <- err
|
|
}
|
|
}()
|
|
|
|
return errch, nil
|
|
}
|
|
|
|
func checkTokenAndLog(handler http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
r.ParseForm()
|
|
if strings.Join(r.Form["access_token"], "") != registration.HsToken {
|
|
http.Error(w, "Wrong or no token provided", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
log.Printf("%s %s %s\n", r.RemoteAddr, r.Method, r.URL)
|
|
handler.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func handleTxn(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == "PUT" {
|
|
var txn mxlib.Transaction
|
|
err := json.NewDecoder(r.Body).Decode(&txn)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
log.Warnf("JSON decode error: %s\n", err)
|
|
return
|
|
}
|
|
|
|
log.Debugf("Got transaction %#v\n", txn)
|
|
|
|
for i := range txn.Events {
|
|
ev := &txn.Events[i]
|
|
if strings.HasPrefix(ev.Sender, "@"+registration.SenderLocalpart) {
|
|
// Don't do anything with ezbr events that come back to us
|
|
continue
|
|
}
|
|
err = handleTxnEvent(ev)
|
|
if err != nil {
|
|
ezbrSystemSend(ev.Sender, fmt.Sprintf("Could not process %s (%s): %s", ev.Type, ev.Sender, err))
|
|
}
|
|
}
|
|
|
|
fmt.Fprintf(w, "{}\n")
|
|
} else {
|
|
http.Error(w, "Expected PUT request", http.StatusBadRequest)
|
|
}
|
|
}
|
|
|
|
func handleTxnEvent(e *mxlib.Event) error {
|
|
if e.Type == "m.room.message" {
|
|
ev := &connector.Event{
|
|
Type: connector.EVENT_MESSAGE,
|
|
Text: e.Content["body"].(string),
|
|
}
|
|
typ := e.Content["msgtype"].(string)
|
|
if typ == "m.emote" {
|
|
ev.Type = connector.EVENT_MESSAGE
|
|
}
|
|
|
|
if pm_room := dbIsPmRoom(e.RoomId); pm_room != nil {
|
|
if pm_room.Protocol == EASYBRIDGE_SYSTEM_PROTOCOL {
|
|
handleSystemMessage(e.Sender, e.Content["body"].(string))
|
|
return nil
|
|
}
|
|
// If this is a private message room
|
|
acct := FindAccount(pm_room.MxUserID, pm_room.AccountName)
|
|
if acct == nil {
|
|
return fmt.Errorf("Not connected to %s", pm_room.AccountName)
|
|
} else if e.Sender == pm_room.MxUserID {
|
|
ev.Author = acct.Conn.User()
|
|
ev.Recipient = pm_room.UserID
|
|
return acct.Conn.Send(ev)
|
|
}
|
|
} else if room := dbIsPublicRoom(e.RoomId); room != nil {
|
|
// If this is a regular room
|
|
acct := FindJoinedAccount(e.Sender, room.Protocol, room.RoomID)
|
|
if acct != nil {
|
|
ev.Author = acct.Conn.User()
|
|
ev.Room = room.RoomID
|
|
return acct.Conn.Send(ev)
|
|
} else {
|
|
mx.RoomKick(e.RoomId, e.Sender, fmt.Sprintf("Not present in %s on %s, please talk with Easybridge to rejoin", room.RoomID, room.Protocol))
|
|
return fmt.Errorf("not joined %s on %s", room.RoomID, room.Protocol)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("Room not bridged")
|
|
}
|
|
} else if e.Type == "m.room.member" {
|
|
ms := e.Content["membership"].(string)
|
|
if ms == "leave" {
|
|
if pm_room := dbIsPmRoom(e.RoomId); pm_room != nil {
|
|
// If leaving a PM room, we must delete it
|
|
them_mx := userMxId(pm_room.Protocol, pm_room.UserID)
|
|
mx.RoomLeaveAs(e.RoomId, them_mx)
|
|
db.Delete(pm_room)
|
|
return nil
|
|
} else if room := dbIsPublicRoom(e.RoomId); room != nil {
|
|
// If leaving a public room, leave from server as well
|
|
acct := FindJoinedAccount(e.Sender, room.Protocol, room.RoomID)
|
|
if acct != nil {
|
|
acct.Conn.Leave(room.RoomID)
|
|
return nil
|
|
// TODO: manage autojoin list, remove this room
|
|
} else {
|
|
mx.RoomKick(e.RoomId, e.Sender, fmt.Sprintf("Not present in %s on %s, please talk with Easybridge to rejoin", room.RoomID, room.Protocol))
|
|
return fmt.Errorf("not joined %s on %s", room.RoomID, room.Protocol)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("Room not bridged")
|
|
}
|
|
}
|
|
} else if e.Type == "m.room.topic" {
|
|
if room := dbIsPublicRoom(e.RoomId); room != nil {
|
|
acct := FindJoinedAccount(e.Sender, room.Protocol, room.RoomID)
|
|
if acct != nil {
|
|
return acct.Conn.SetRoomInfo(room.RoomID, &connector.RoomInfo{
|
|
Topic: e.Content["topic"].(string),
|
|
})
|
|
} else {
|
|
return fmt.Errorf("Could not find room account for %s %s %s", e.Sender, room.Protocol, room.RoomID)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func handleSystemMessage(mxid string, msg string) {
|
|
cmd := strings.Fields(msg)
|
|
switch cmd[0] {
|
|
case "help":
|
|
ezbrSystemSend(mxid, "Welcome to Easybridge! Here is a list of available commands:")
|
|
ezbrSystemSend(mxid, "- help: request help")
|
|
ezbrSystemSend(mxid, "- list: list accounts")
|
|
ezbrSystemSend(mxid, "- accounts: list accounts")
|
|
ezbrSystemSend(mxid, "- join <protocol or account> <room id>: join public chat room")
|
|
ezbrSystemSend(mxid, "- query <protocol or account> <user id>: open private buffer to contact")
|
|
case "list", "account", "accounts":
|
|
one := false
|
|
if accts, ok := registeredAccounts[mxid]; ok {
|
|
for name, acct := range accts {
|
|
one = true
|
|
ezbrSystemSendf(mxid, "- %s (%s)", name, acct.Protocol)
|
|
}
|
|
}
|
|
if !one {
|
|
ezbrSystemSendf(mxid, "No account currently configured")
|
|
}
|
|
case "join":
|
|
var account *Account
|
|
if accts, ok := registeredAccounts[mxid]; ok {
|
|
for name, acct := range accts {
|
|
if name == cmd[1] || acct.Protocol == cmd[1] {
|
|
account = acct
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if account != nil {
|
|
err := account.Conn.Join(connector.RoomID(cmd[2]))
|
|
if err != nil {
|
|
ezbrSystemSendf(mxid, "%s", err)
|
|
}
|
|
} else {
|
|
ezbrSystemSendf(mxid, "No account with name or using protocol %s", cmd[1])
|
|
}
|
|
case "query":
|
|
var account *Account
|
|
if accts, ok := registeredAccounts[mxid]; ok {
|
|
for name, acct := range accts {
|
|
if name == cmd[1] || acct.Protocol == cmd[1] {
|
|
account = acct
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if account != nil {
|
|
quser := connector.UserID(cmd[2])
|
|
err := account.Conn.Invite(quser, connector.RoomID(""))
|
|
if err != nil {
|
|
ezbrSystemSendf(mxid, "%s", err)
|
|
return
|
|
}
|
|
|
|
quser_mxid, err := dbGetMxUser(account.Protocol, quser)
|
|
if err != nil {
|
|
ezbrSystemSendf(mxid, "%s", err)
|
|
return
|
|
}
|
|
_, err = dbGetMxPmRoom(account.Protocol, quser, quser_mxid, mxid, account.AccountName)
|
|
if err != nil {
|
|
ezbrSystemSendf(mxid, "%s", err)
|
|
}
|
|
} else {
|
|
ezbrSystemSendf(mxid, "No account with name or using protocol %s", cmd[1])
|
|
}
|
|
default:
|
|
ezbrSystemSend(mxid, "Unrecognized command. Type `help` if you need some help!")
|
|
}
|
|
}
|