package xmpp import ( "bytes" "encoding/base64" "github.com/pkg/errors" "io" "os" "strconv" "strings" "dev.narayana.im/narayana/telegabber/persistence" "dev.narayana.im/narayana/telegabber/xmpp/extensions" "dev.narayana.im/narayana/telegabber/xmpp/gateway" log "github.com/sirupsen/logrus" "gosrc.io/xmpp" "gosrc.io/xmpp/stanza" ) func logPacketType(p stanza.Packet) { log.Warnf("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.Debugf("%#v", iq) if iq.Type == "get" { _, ok := iq.Payload.(*extensions.IqVcardTemp) if ok { go handleGetVcardTempIq(s, iq) return } _, ok = iq.Payload.(*stanza.DiscoInfo) if ok { go handleGetDiscoInfo(s, iq) return } } } // HandleMessage processes an incoming XMPP message func HandleMessage(s xmpp.Sender, p stanza.Packet) { msg, ok := p.(stanza.Message) if !ok { logPacketType(p) return } component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } if msg.Type != "error" && msg.Body != "" { log.WithFields(log.Fields{ "from": msg.From, "to": msg.To, }).Warn("Message") log.Debugf("%#v", msg) bare, resource, ok := splitFrom(msg.From) if !ok { return } gatewayJid := gateway.Jid.Bare() session, ok := sessions[bare] if !ok { if msg.To == gatewayJid { gateway.SendPresence(component, msg.From, gateway.SPType("subscribe")) gateway.SendPresence(component, msg.From, gateway.SPType("subscribed")) } else { log.Error("Message from stranger") return } } toID, ok := toToID(msg.To) if ok { session.ProcessOutgoingMessage(toID, msg.Body, msg.From) return } else { toJid, err := stanza.NewJid(msg.To) if err == nil && toJid.Bare() == gatewayJid && (strings.HasPrefix(msg.Body, "/") || strings.HasPrefix(msg.Body, "!")) { response := session.ProcessTransportCommand(msg.Body, resource) if response != "" { gateway.SendMessage(msg.From, "", response, component) } return } } log.Warn("Unknown purpose of the message, skipping") } } // 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) } if prs.To == gateway.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", }} component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } _ = gateway.ResumableSend(component, reply) toID, ok := toToID(p.To) if !ok { return } bare, _, ok := splitFrom(p.From) if !ok { return } session, ok := getTelegramInstance(bare, &persistence.Session{}, component) if !ok { return } go session.ProcessStatusUpdate(toID, "", "", gateway.SPImmed(false)) } func handlePresence(s xmpp.Sender, p stanza.Presence) { presenceType := p.Type if presenceType == "" { presenceType = "online" } component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } log.WithFields(log.Fields{ "type": presenceType, "from": p.From, "to": p.To, }).Warn("Presence") log.Debugf("%#v", p) // create session bare, resource, ok := splitFrom(p.From) if !ok { return } session, ok := getTelegramInstance(bare, &persistence.Session{}, component) if !ok { return } switch p.Type { // destroy session case "unsubscribed", "unsubscribe": if session.Disconnect(resource, false) { sessionLock.Lock() delete(sessions, bare) sessionLock.Unlock() } // go offline case "unavailable", "error": session.Disconnect(resource, false) // go online case "probe", "", "online", "subscribe": // due to the weird implementation of go-tdlib wrapper, it won't // return the client instance until successful authorization go func() { err := session.Connect(resource) if err != nil { log.Error(errors.Wrap(err, "TDlib connection failure")) } else { for status := range session.StatusesRange() { go session.ProcessStatusUpdate( status.ID, status.Description, status.XMPP, gateway.SPImmed(false), ) } } }() } } func handleGetVcardTempIq(s xmpp.Sender, iq *stanza.IQ) { log.WithFields(log.Fields{ "from": iq.From, "to": iq.To, }).Warn("VCard request") fromJid, err := stanza.NewJid(iq.From) if err != nil { log.Error("Invalid from JID!") return } session, ok := sessions[fromJid.Bare()] if !ok { log.Error("IQ from stranger") return } toParts := strings.Split(iq.To, "@") toID, err := strconv.ParseInt(toParts[0], 10, 64) if err != nil { log.Error("Invalid IQ to") return } chat, user, err := session.GetContactByID(toID, nil) if err != nil { log.Error(err) return } vcard := extensions.IqVcardTemp{} if chat != nil { vcard.Fn.Text = chat.Title if chat.Photo != nil { path := chat.Photo.Small.Local.Path file, err := os.Open(path) // obtain the photo right now if still not downloaded if err != nil && !chat.Photo.Small.Local.IsDownloadingCompleted { tdFile, tdErr := session.DownloadFile(chat.Photo.Small.Id, 32, true) if tdErr == nil { path = tdFile.Local.Path file, err = os.Open(path) } } if err == nil { defer file.Close() buf := new(bytes.Buffer) binval := base64.NewEncoder(base64.StdEncoding, buf) _, err = io.Copy(binval, file) if err == nil { vcard.Photo.Type.Text = "image/jpeg" vcard.Photo.Binval.Text = buf.String() } else { log.Errorf("Error calculating hash: %v", path) } } else if path != "" { log.Errorf("Photo does not exist: %v", path) } else { log.Errorf("PHOTO: %#v", err.Error()) } } } if user != nil { vcard.Nickname.Text = user.Username vcard.N.Given.Text = user.FirstName vcard.N.Family.Text = user.LastName vcard.Tel.Number.Text = user.PhoneNumber } answer := stanza.IQ{ Attrs: stanza.Attrs{ From: iq.To, To: iq.From, Id: iq.Id, Type: "result", }, Payload: vcard, } log.Debugf("%#v", answer) component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } _ = gateway.ResumableSend(component, &answer) } func handleGetDiscoInfo(s xmpp.Sender, iq *stanza.IQ) { answer, err := stanza.NewIQ(stanza.Attrs{ Type: stanza.IQTypeResult, From: iq.To, To: iq.From, Id: iq.Id, Lang: "en", }) if err != nil { log.Errorf("Failed to create answer IQ: %v", err) return } disco := answer.DiscoInfo() _, ok := toToID(iq.To) if ok { disco.AddIdentity("", "account", "registered") } else { disco.AddIdentity("Telegram Gateway", "gateway", "telegram") } answer.Payload = disco log.Debugf("%#v", answer) component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } _ = gateway.ResumableSend(component, answer) } func splitFrom(from string) (string, string, bool) { fromJid, err := stanza.NewJid(from) if err != nil { log.WithFields(log.Fields{ "from": from, }).Error(errors.Wrap(err, "Invalid from JID!")) return "", "", false } return fromJid.Bare(), fromJid.Resource, true } func toToID(to string) (int64, bool) { toParts := strings.Split(to, "@") if len(toParts) < 2 { return 0, false } toID, err := strconv.ParseInt(toParts[0], 10, 64) if err != nil { log.WithFields(log.Fields{ "to": to, }).Error(errors.Wrap(err, "Invalid to JID!")) return 0, false } return toID, true }