Presence/iq handling and rudimental telegram client

2 files changed, 107 insertions, 9 deletions

diff --git a/xmpp/component.go b/xmpp/component.go
index d55ed6b..1562224 100644
--- a/xmpp/component.go
+++ b/xmpp/component.go
@@ -1,16 +1,25 @@
 package xmpp
 
 import (
-	"log"
-
 	"dev.narayana.im/narayana/telegabber/config"
 
 	"gosrc.io/xmpp"
 )
 
+var jid *xmpp.Jid
+var tgConf config.TelegramConfig
+
 // NewComponent starts a new component and wraps it in
 // a stream manager that you should start yourself
-func NewComponent(conf config.XMPPConfig) *xmpp.StreamManager {
+func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig) (*xmpp.StreamManager, error) {
+	var err error
+	jid, err = xmpp.NewJid(conf.Jid)
+	if err != nil {
+		return nil, err
+	}
+
+	tgConf = tc
+
 	options := xmpp.ComponentOptions{
 		Address: conf.Host + ":" + conf.Port,
 		Domain:  conf.Jid,
@@ -19,14 +28,16 @@ func NewComponent(conf config.XMPPConfig) *xmpp.StreamManager {
 	}
 
 	router := xmpp.NewRouter()
+	router.HandleFunc("iq", HandleIq)
+	router.HandleFunc("presence", HandlePresence)
 	router.HandleFunc("message", HandleMessage)
 
 	component, err := xmpp.NewComponent(options, router)
 	if err != nil {
-		log.Fatalf("%+v", err)
+		return nil, err
 	}
 
 	cm := xmpp.NewStreamManager(component, nil)
 
-	return cm
+	return cm, nil
 }
diff --git a/xmpp/handlers.go b/xmpp/handlers.go
index 874af49..c7acdce 100644
--- a/xmpp/handlers.go
+++ b/xmpp/handlers.go
@@ -1,22 +1,109 @@
 package xmpp
 
 import (
-	"fmt"
-	"os"
+	"dev.narayana.im/narayana/telegabber/telegram"
 
+	log "github.com/sirupsen/logrus"
 	"gosrc.io/xmpp"
 	"gosrc.io/xmpp/stanza"
 )
 
+var sessions map[string]telegram.TelegramClient
+
+func logPacketType(p stanza.Packet) {
+	log.Warn("Ignoring packet: %T\n", p)
+}
+
+// HandleIq processes an incoming XMPP iq
+func HandleIq(s xmpp.Sender, p stanza.Packet) {
+	iq, ok := p.(stanza.IQ)
+	if !ok {
+		logPacketType(p)
+		return
+	}
+
+	log.Printf("Iq: %#v\n", iq)
+}
+
 // HandleMessage processes an incoming XMPP message
 func HandleMessage(s xmpp.Sender, p stanza.Packet) {
 	msg, ok := p.(stanza.Message)
 	if !ok {
-		_, _ = fmt.Fprintf(os.Stdout, "Ignoring packet: %T\n", p)
+		logPacketType(p)
 		return
 	}
 
-	_, _ = fmt.Fprintf(os.Stdout, "Body = %s - from = %s\n", msg.Body, msg.From)
+	log.Printf("Message: %#v\n", msg)
 	reply := stanza.Message{Attrs: stanza.Attrs{To: msg.From}, Body: msg.Body}
 	_ = s.Send(reply)
 }
+
+// HandlePresence processes an incoming XMPP presence
+func HandlePresence(s xmpp.Sender, p stanza.Packet) {
+	prs, ok := p.(stanza.Presence)
+	if !ok {
+		logPacketType(p)
+		return
+	}
+
+	if prs.Type == "subscribe" {
+		handleSubscription(s, prs)
+	} else if prs.To == jid.Bare() {
+		handlePresence(s, prs)
+	}
+}
+
+func handleSubscription(s xmpp.Sender, p stanza.Presence) {
+	log.WithFields(log.Fields{
+		"from": p.From,
+		"to":   p.To,
+	}).Warn("Subscription request")
+	log.Debugf("%#v", p)
+
+	reply := stanza.Presence{Attrs: stanza.Attrs{
+		From: p.To,
+		To:   p.From,
+		Id:   p.Id,
+		Type: "subscribed",
+	}}
+
+	_ = s.Send(reply)
+}
+
+func handlePresence(s xmpp.Sender, p stanza.Presence) {
+	presenceType := p.Type
+	if presenceType == "" {
+		presenceType = "online"
+	}
+
+	log.WithFields(log.Fields{
+		"type": presenceType,
+		"from": p.From,
+		"to":   p.To,
+	}).Warn("Presence")
+	log.Debugf("%#v", p)
+
+	fromJid, err := xmpp.NewJid(p.From)
+	if err != nil {
+		log.Error("Invalid from JID!")
+		return
+	}
+	bareFromJid := fromJid.Bare()
+	session, ok := sessions[bareFromJid]
+	if !ok {
+		client, err := telegram.NewClient(tgConf, bareFromJid)
+		if err != nil {
+			log.Error("Invalid from JID!")
+		}
+		sessions[bareFromJid] = client
+	}
+
+	switch p.Type {
+	case "unsubscribed":
+		delete(sessions, bareFromJid)
+	case "unavailable", "error":
+		session.Disconnect()
+	case "":
+		session.Connect()
+	}
+}