matterbridge/bridge/signald/signald.go

package bsignald

import (
	"bufio"
	"net"
	"encoding/json"
	"github.com/42wim/matterbridge/bridge"
	"github.com/42wim/matterbridge/bridge/config"
)

type JSONCMD map[string]interface{}

const (
	cfgNumber = "Number"
	cfgSocket = "UnixSocket"
	cfgGroupID = "GroupID"
)

type signaldMessage struct {
	ID    string
	Type  string
	Error json.RawMessage
	Data  json.RawMessage
}

type signaldUnexpectedError struct {
	Message string
}

type signaldMessageData struct {
	ID   string       `json:",omitempty"`
	Data signaldData  `json:",omitempty"`
	Type string       `json:",omitempty"`
}

type signaldData struct {
	CallMessage              json.RawMessage        `json:"callMessage,omitempty"`
	DataMessage              *signaldDataMessage    `json:"dataMessage,omitempty"`
	HasContent               bool                   `json:"hasContent,omitempty"`
	HasLegacyMessage         bool                   `json:"hasLegacyMessage,omitempty"`
	IsUnidentifiedSender     bool                   `json:"isUnidentifiedSender,omitempty"`
	Receipt                  json.RawMessage        `json:"receipt,omitempty"`
	Relay                    string                 `json:"relay,omitempty"`
	ServerDeliveredTimestamp int64                  `json:"serverDeliveredTimestamp,omitempty"`
	ServerTimestamp          int64                  `json:"serverTimestamp,omitempty"`
	Source                   *signaldAccount         `json:"source,omitempty"`
	SourceDevice             int32                  `json:"sourceDevice,omitempty"`
	SyncMessage              json.RawMessage        `json:"syncMessage,omitempty"`
	Timestamp                int64                  `json:"timestamp,omitempty"`
	TimestampISO             string                 `json:"timestampISO,omitempty"`
	Type                     string                 `json:"type,omitempty"`
	Typing                   json.RawMessage        `json:"typing,omitempty"`
	Username                 string                 `json:"username,omitempty"`
	UUID                     string                 `json:"uuid,omitempty"`
}

type signaldAccount struct {
	Number string `json:"number,omitempty"`
	Relay  string `json:"relay,omitempty"`
	UUID   string `json:"uuid,omitempty"`
}

type signaldDataMessage struct {
	Attachments      json.RawMessage     `json:"attachments,omitempty"`
	Body             string              `json:"body,omitempty"`
	Contacts         json.RawMessage     `json:"contacts,omitempty"`
	EndSession       bool                `json:"endSession,omitempty"`
	ExpiresInSeconds int32               `json:"expiresInSeconds,omitempty"`
	Group            *signaldGroupInfo   `json:"group,omitempty"`
	GroupV2          *signaldGroupV2Info `json:"groupV2,omitempty"`
	Mentions         json.RawMessage     `json:"mentions,omitempty"`
	Previews         json.RawMessage     `json:"previews,omitempty"`
	ProfileKeyUpdate bool                `json:"profileKeyUpdate,omitempty"`
	Quote            json.RawMessage     `json:"quote,omitempty"`
	Reaction         json.RawMessage     `json:"reaction,omitempty"`
	RemoteDelete     json.RawMessage     `json:"remoteDelete,omitempty"`
	Sticker          json.RawMessage     `json:"sticker,omitempty"`
	Timestamp        int64               `json:"timestamp,omitempty"`
	ViewOnce         bool                `json:"viewOnce,omitempty"`
}

type signaldGroupInfo struct {
	AvatarId int64           `json:"avatarId,omitempty"`
	ID       string          `json:"groupId,omitempty"`
	Members  json.RawMessage `json:"members,omitempty"`
	Name     string          `json:"name,omitempty"`
	Type     string          `json:"type,omitempty"`
}

type signaldGroupV2Info struct {
	AccessControl       json.RawMessage  `json:"accessControl,omitempty"`
	Avatar              string           `json:"avatar,omitempty"`
	ID                  string           `json:"id,omitempty"`
	InviteLink          string           `json:"inviteLink,omitempty"`
	MemberDetail        json.RawMessage  `json:"memberDetail,omitempty"`
	Members             json.RawMessage  `json:"members,omitempty"`
	PendingMemberDetail json.RawMessage  `json:"pendingMemberDetail,omitempty"`
	PendingMembers      json.RawMessage  `json:"pendingMembers,omitempty"`
	RequestingMembers   json.RawMessage  `json:"requestingMembers,omitempty"`
	Revision            int32            `json:"revision,omitempty"`
	Timer               int32            `json:"timer,omitempty"`
	Title               string           `son:"title,omitempty"`
}

type signaldSendMessage struct {
	Type             string `json:"type,omitempty"`
	Username         string `json:"username,omitempty"`
	RecipientGroupId string `json:"recipientGroupId,omitempty"`
	MessageBody      string `json:"messageBody,omitempty"`
}

type signaldContact struct {
	Name                  string          `json:"name,omitempty"`
	ProfileName           string          `json:"profile_name,omitempty"`
	Account               *signaldAccount `json:"address,omitempty"`
	Avatar                string          `json:"avatar,omitempty"`
	Color                 string          `json:"color,omitempty"`
	ProfileKey            string          `json:"profileKey,omitempty"`
	MessageExpirationTime int32           `json:"messageExpirationTime,omitempty"`
	InboxPosition         int32           `json:"inboxPosition,omitempty"`
}

type Bsignald struct {
	*bridge.Config
	socketpath string
	socket     net.Conn
	subscribed bool
	reader     *bufio.Scanner
	groupid   string
	contacts  map[string]signaldContact
}

func New(cfg *bridge.Config) bridge.Bridger {
	number := cfg.GetString(cfgNumber)
	if number == "" {
		cfg.Log.Fatalf("Missing configuration for Signald bridge: Number")
	}

	socketpath := cfg.GetString(cfgSocket)
	if socketpath == "" {
		socketpath = "/var/run/signald/signald.sock"
	}

	return &Bsignald{
		Config: cfg,
		socketpath: socketpath,
		subscribed: false,
		contacts: make(map[string]signaldContact),
	}
}

func (b *Bsignald) Connect() error {
	b.Log.Infof("Connecting %s", b.socketpath)

	s, err := net.Dial("unix", b.socketpath)
	if err != nil {
		b.Log.Fatalf(err.Error())
	}
	b.socket = s
	r := bufio.NewScanner(s)
	b.reader = r
	go b.Listen()
	go b.Login()
	return nil
}

func (b *Bsignald) JoinChannel(channel config.ChannelInfo) error {
	b.groupid = channel.Name
	return nil
}

func (b *Bsignald) HandleUnexpectedErrorMessage(msg signaldMessage) {
	var errorResponse signaldUnexpectedError
	if err := json.Unmarshal(msg.Data, &errorResponse); err != nil {
		b.Log.Errorln("Error unmarshaling error response:", err.Error())
	}
	b.Log.Errorln("Unexpected error from signald: ", errorResponse.Message)
}

func (b *Bsignald) HandleSubscribeMessage() {
	b.Log.Debugln("subscribe successful", b.GetString(cfgNumber))
	b.subscribed = true
	go b.GetContacts()
}

func (b *Bsignald) HandleListenStoppedMessage() {
	b.Log.Errorln("got listen stopped, trying to re-subscribe")
	b.subscribed = false
	go b.Login()
}

func (b *Bsignald) HandleContactList(msg signaldMessage) {
	var contacts []signaldContact
	if err := json.Unmarshal(msg.Data, &contacts); err != nil {
		b.Log.Errorln("failed to parse contact_list: ", err)
	} else {
		for _, contact := range contacts {
			b.contacts[contact.Account.UUID] = contact
		}
	}
}

func (b *Bsignald) GetUsername(uuid string) string {
	username := ""
	if v, found := b.contacts[uuid]; found {
		if "" != v.ProfileName {
			username = v.ProfileName
		} else if "" != v.Name {
			username = v.Name
		}
	}
	return username
}

func (b *Bsignald) HandleMessage(msg signaldMessage) {
	response := signaldMessageData{ID: msg.ID, Type: msg.Type}
	if err := json.Unmarshal(msg.Data, &response.Data); err != nil {
		b.Log.Errorln("receive error: ", err)
		return
	}

	if nil == response.Data.DataMessage {
		return
	}

	groupMatched := false
	if response.Data.DataMessage.GroupV2 != nil {
		if b.groupid == response.Data.DataMessage.GroupV2.ID {
			groupMatched = true
		}
	} else if response.Data.DataMessage.Group != nil {
		if b.groupid == response.Data.DataMessage.Group.ID {
			groupMatched = true
		}
	}

	if false == groupMatched {
		b.Log.Debugln("skipping non-group message")
		return
	}

	username := b.GetUsername(response.Data.Source.UUID)
	if "" == username {
		username = response.Data.Source.Number
	}

	rmsg := config.Message{
		UserID:   response.Data.Source.UUID,
		Username: username,
		Text:     response.Data.DataMessage.Body,
		Channel:  b.groupid,
		Account:  b.Account,
		Protocol: b.Protocol,
	}

	b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
	b.Log.Debugf("<= Message is %#v", rmsg)
	b.Remote <- rmsg

}

func (b *Bsignald) Listen() {
	for {
		for b.reader.Scan() {
			var err error
			if err = b.reader.Err(); err != nil {
				b.Log.Errorf(err.Error())
				continue
			}

			raw := b.reader.Text()

			var msg signaldMessage
			if err = json.Unmarshal([]byte(raw), &msg); err != nil {
				b.Log.Errorln("Error unmarshaling raw response:", err.Error())
				continue
			}

			switch msg.Type {
				case "unexpected_error":
					b.HandleUnexpectedErrorMessage(msg)
				case "subscribed":
					b.HandleSubscribeMessage()
				case "listen_stopped":
					b.HandleListenStoppedMessage()
				case "contact_list":
					b.HandleContactList(msg)
				case "message":
					b.HandleMessage(msg)
				default:
					b.Log.Debugln("unsupported signald data received, skipping it");
			}
		}
	}
}

func (b *Bsignald) GetContacts() error {
	cmd := JSONCMD{
		"type": "list_contacts",
		"username": b.GetString(cfgNumber),
	}
	return b.SendRawJSON(cmd)
}

func (b *Bsignald) Login() error {
	var err error
	if ! b.subscribed {
		cmd := JSONCMD{
			"type": "subscribe",
			"username": b.GetString(cfgNumber),
		}
		err = b.SendRawJSON(cmd)
	}
	return err
}

func (b *Bsignald) SendRawJSON(cmd JSONCMD) (error) {
	err := json.NewEncoder(b.socket).Encode(cmd)
	if err != nil {
		b.Log.Errorln(err.Error())
	}
	return err
}

func (b *Bsignald) Disconnect() error {
	b.Log.Debugln("Disconnecting..")
	b.socket.Close()
	return nil
}

func (b *Bsignald) Send(msg config.Message) (string, error) {
	b.Log.Debugf("message to forward into signal: %#v", msg)

	msgJSON := signaldSendMessage {
		Type: "send",
		Username: b.GetString(cfgNumber),
		RecipientGroupId: b.groupid,
		MessageBody: msg.Username + msg.Text,
	}

	err := json.NewEncoder(b.socket).Encode(msgJSON)
	if err != nil {
		b.Log.Errorln(err.Error())
	}
	return "", err
}