package xmpp import ( "bytes" "encoding/base64" "encoding/xml" "fmt" "github.com/pkg/errors" "io" "strconv" "strings" "dev.narayana.im/narayana/telegabber/persistence" "dev.narayana.im/narayana/telegabber/telegram" "dev.narayana.im/narayana/telegabber/xmpp/extensions" "dev.narayana.im/narayana/telegabber/xmpp/gateway" log "github.com/sirupsen/logrus" "github.com/soheilhy/args" "gosrc.io/xmpp" "gosrc.io/xmpp/stanza" ) const ( TypeVCardTemp byte = iota TypeVCard4 ) const NodeVCard4 string = "urn:xmpp:vcard4" type discoType int const ( discoTypeInfo discoType = iota discoTypeItems ) 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 handleGetVcardIq(s, iq, TypeVCardTemp) return } pubsub, ok := iq.Payload.(*stanza.PubSubGeneric) if ok { if pubsub.Items != nil && pubsub.Items.Node == NodeVCard4 { go handleGetVcardIq(s, iq, TypeVCard4) return } } _, ok = iq.Payload.(*stanza.DiscoInfo) if ok { go handleGetDisco(discoTypeInfo, s, iq) return } _, ok = iq.Payload.(*stanza.DiscoItems) if ok { go handleGetDisco(discoTypeItems, s, iq) return } _, ok = iq.Payload.(*extensions.QueryRegister) if ok { go handleGetQueryRegister(s, iq) return } } else if iq.Type == "set" { query, ok := iq.Payload.(*extensions.QueryRegister) if ok { go handleSetQueryRegister(s, iq, query) 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 := gateway.SplitJID(msg.From) if !ok { return } gatewayJid := gateway.Jid.Bare() session, ok := sessions[bare] if !ok { if msg.To == gatewayJid { gateway.SubscribeToTransport(component, msg.From) } else { log.Error("Message from stranger") } return } toID, ok := toToID(msg.To) if ok { var reply extensions.Reply var fallback extensions.Fallback var replace extensions.Replace msg.Get(&reply) msg.Get(&fallback) msg.Get(&replace) log.Debugf("reply: %#v", reply) log.Debugf("fallback: %#v", fallback) log.Debugf("replace: %#v", replace) var replyId int64 var err error text := msg.Body if len(reply.Id) > 0 { chatId, msgId, err := gateway.IdsDB.GetByXmppId(session.Session.Login, bare, reply.Id) if err == nil { if chatId != toID { log.Warnf("Chat mismatch: %v ≠ %v", chatId, toID) } else { replyId = msgId log.Debugf("replace tg: %#v %#v", chatId, msgId) } } else { id := reply.Id if id[0] == 'e' { id = id[1:] } replyId, err = strconv.ParseInt(id, 10, 64) if err != nil { log.Warn(errors.Wrap(err, "Failed to parse message ID!")) } } if replyId != 0 && fallback.For == "urn:xmpp:reply:0" && len(fallback.Body) > 0 { body := fallback.Body[0] var start, end int64 start, err = strconv.ParseInt(body.Start, 10, 64) if err != nil { log.WithFields(log.Fields{ "start": body.Start, }).Warn(errors.Wrap(err, "Failed to parse fallback start!")) } end, err = strconv.ParseInt(body.End, 10, 64) if err != nil { log.WithFields(log.Fields{ "end": body.End, }).Warn(errors.Wrap(err, "Failed to parse fallback end!")) } fullRunes := []rune(text) cutRunes := make([]rune, 0, len(text)-int(end-start)) cutRunes = append(cutRunes, fullRunes[:start]...) cutRunes = append(cutRunes, fullRunes[end:]...) text = string(cutRunes) } } var replaceId int64 if replace.Id != "" { chatId, msgId, err := gateway.IdsDB.GetByXmppId(session.Session.Login, bare, replace.Id) if err == nil { if chatId != toID { gateway.SendTextMessage(msg.From, strconv.FormatInt(toID, 10), "", component) return } replaceId = msgId log.Debugf("replace tg: %#v %#v", chatId, msgId) } else { gateway.SendTextMessage(msg.From, strconv.FormatInt(toID, 10), "", component) return } } isGroupchat := msg.Type == "groupchat" session.SendMessageLock.Lock() defer session.SendMessageLock.Unlock() tgMessage := session.ProcessOutgoingMessage(toID, text, msg.From, replyId, replaceId, isGroupchat) if tgMessage != nil { if replaceId != 0 { // not needed (is it persistent among clients though?) /* err = gateway.IdsDB.ReplaceIdPair(session.Session.Login, bare, replace.Id, msg.Id, tgMessageId) if err != nil { log.Errorf("Failed to replace id %v with %v %v", replace.Id, msg.Id, tgMessageId) } */ session.AddToOutbox(replace.Id, resource) } else { err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessage.Id, msg.Id) if err != nil { log.Errorf("Failed to save ids %v/%v %v", toID, tgMessage.Id, msg.Id) } } // pong groupchat messages back if isGroupchat { toJid, err := stanza.NewJid(msg.To) if err == nil && toJid.Resource == "" { session.SendMessageToGateway( toID, tgMessage, msg.Id, false, msg.To + "/" + session.GetMUCNickname(session.GetSenderId(tgMessage)), []string{msg.From}, ) } } } else { /* // if a message failed to edit on Telegram side, match new XMPP ID with old Telegram ID anyway if replaceId != 0 { err = gateway.IdsDB.ReplaceXmppId(session.Session.Login, bare, replace.Id, msg.Id) if err != nil { log.Errorf("Failed to replace id %v with %v", replace.Id, msg.Id) } } */ } 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.SendServiceMessage(msg.From, response, component) } return } } log.Warn("Unknown purpose of the message, skipping") } if msg.Body == "" { var privilege1 extensions.ComponentPrivilege1 if ok := msg.Get(&privilege1); ok { log.Debugf("privilege1: %#v", privilege1) } for _, perm := range privilege1.Perms { if perm.Access == "message" && perm.Type == "outgoing" { gateway.MessageOutgoingPermissionVersion = 1 } } var privilege2 extensions.ComponentPrivilege2 if ok := msg.Get(&privilege2); ok { log.Debugf("privilege2: %#v", privilege2) } for _, perm := range privilege2.Perms { if perm.Access == "message" && perm.Type == "outgoing" { gateway.MessageOutgoingPermissionVersion = 2 } } } if msg.Type == "error" { log.Errorf("MESSAGE ERROR: %#v", p) if msg.XMLName.Space == "jabber:component:accept" && msg.Error.Code == 401 { suffix := "@" + msg.From for bare := range sessions { if strings.HasSuffix(bare, suffix) { gateway.SendServiceMessage(bare, "Your server \""+msg.From+"\" does not allow to send carbons", component) } } } } } // 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) return } var mucExt stanza.MucPresence prs.Get(&mucExt) if mucExt.XMLName.Space != "" { handleMUCPresence(s, prs, mucExt) } } 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 := gateway.SplitJID(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 := gateway.SplitJID(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() { show, description, typ := status.Destruct() newArgs := []args.V{ gateway.SPImmed(false), } if typ != "" { newArgs = append(newArgs, gateway.SPType(typ)) } go session.ProcessStatusUpdate( status.ID, description, show, newArgs..., ) } session.UpdateChatNicknames() } }() } } func handleMUCPresence(s xmpp.Sender, p stanza.Presence, mucExt stanza.MucPresence) { log.WithFields(log.Fields{ "type": p.Type, "from": p.From, "to": p.To, }).Warn("MUC presence") log.Debugf("%#v", p) if p.Type == "" { toBare, nickname, ok := gateway.SplitJID(p.To) if ok { component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } // separate declaration is crucial for passing as pointer to defer var reply *stanza.Presence reply = &stanza.Presence{Attrs: stanza.Attrs{ From: toBare, To: p.From, Id: p.Id, }} defer gateway.ResumableSend(component, reply) if nickname == "" { presenceReplySetError(reply, 400) return } chatId, ok := toToID(toBare) if !ok { presenceReplySetError(reply, 404) return } fromBare, fromResource, ok := gateway.SplitJID(p.From) if !ok { presenceReplySetError(reply, 400) return } session, ok := sessions[fromBare] if !ok || !session.Session.MUC { presenceReplySetError(reply, 407) return } chat, _, err := session.GetContactByID(chatId, nil) if err != nil || !session.IsGroup(chat) { presenceReplySetError(reply, 404) return } limit, ok := mucExt.History.MaxStanzas.Get() if !ok { limit = 20 } session.JoinMUC(chatId, fromResource, int32(limit)) } } } func handleGetVcardIq(s xmpp.Sender, iq *stanza.IQ, typ byte) { 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 } info, err := session.GetVcardInfo(toID) if err != nil { log.Error(err) return } answer := stanza.IQ{ Attrs: stanza.Attrs{ From: iq.To, To: iq.From, Id: iq.Id, Type: "result", }, Payload: makeVCardPayload(typ, iq.To, info, session), } log.Debugf("%#v", answer) component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } _ = gateway.ResumableSend(component, &answer) } func handleGetDisco(dt discoType, 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 } if dt == discoTypeInfo { disco := answer.DiscoInfo() toID, toOk := toToID(iq.To) if !toOk { disco.AddIdentity("Telegram Gateway", "gateway", "telegram") disco.AddFeatures("jabber:iq:register") } var isMuc bool bare, _, fromOk := gateway.SplitJID(iq.From) if fromOk { session, sessionOk := sessions[bare] if sessionOk && session.Session.MUC { if toOk { chat, _, err := session.GetContactByID(toID, nil) if err == nil && session.IsGroup(chat) { isMuc = true disco.AddIdentity(chat.Title, "conference", "text") disco.AddFeatures( "http://jabber.org/protocol/muc", "muc_persistent", "muc_hidden", "muc_membersonly", "muc_unmoderated", "muc_nonanonymous", "muc_unsecured", "http://jabber.org/protocol/muc#stable_id", ) fields := []*stanza.Field{ &stanza.Field{ Var: "FORM_TYPE", Type: "hidden", ValuesList: []string{"http://jabber.org/protocol/muc#roominfo"}, }, &stanza.Field{ Var: "muc#roominfo_description", Label: "Description", ValuesList: []string{session.GetChatDescription(chat)}, }, &stanza.Field{ Var: "muc#roominfo_occupants", Label: "Number of occupants", ValuesList: []string{strconv.FormatInt(int64(session.GetChatMemberCount(chat)), 10)}, }, } disco.Form = stanza.NewForm(fields, "result") } } else { disco.AddFeatures( stanza.NSDiscoItems, "http://jabber.org/protocol/muc#stable_id", ) disco.AddIdentity("Telegram group chats", "conference", "text") } } } if toOk && !isMuc { disco.AddIdentity("", "account", "registered") } answer.Payload = disco } else if dt == discoTypeItems { disco := answer.DiscoItems() _, ok := toToID(iq.To) if !ok { bare, _, ok := gateway.SplitJID(iq.From) if ok { // raw access, no need to create a new instance if not connected session, ok := sessions[bare] if ok && session.Session.MUC { bareJid := gateway.Jid.Bare() disco.AddItem(bareJid, "", "Telegram group chats") for _, chat := range session.GetGroupChats() { jid := strconv.FormatInt(chat.Id, 10) + "@" + bareJid disco.AddItem(jid, "", chat.Title) } } } } 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 handleGetQueryRegister(s xmpp.Sender, iq *stanza.IQ) { component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } 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 } var login string bare, _, ok := gateway.SplitJID(iq.From) if ok { session, ok := sessions[bare] if ok { login = session.Session.Login } } var query stanza.IQPayload if login == "" { query = extensions.QueryRegister{ Instructions: fmt.Sprintf("Authorization in Telegram is a multi-step process, so please accept %v to your contacts and follow further instructions (provide the authentication code there, etc.).\nFor now, please provide your login.", iq.To), } } else { query = extensions.QueryRegister{ Instructions: "Already logged in", Username: login, Registered: &extensions.QueryRegisterRegistered{}, } } answer.Payload = query log.Debugf("%#v", query) _ = gateway.ResumableSend(component, answer) if login == "" { gateway.SubscribeToTransport(component, iq.From) } } func handleSetQueryRegister(s xmpp.Sender, iq *stanza.IQ, query *extensions.QueryRegister) { component, ok := s.(*xmpp.Component) if !ok { log.Error("Not a component") return } 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 } defer gateway.ResumableSend(component, answer) if query.Remove != nil { iqAnswerSetError(answer, query, 405) return } var login string var session *telegram.Client bare, resource, ok := gateway.SplitJID(iq.From) if ok { session, ok = sessions[bare] if ok { login = session.Session.Login } } if login == "" { if !ok { session, ok = getTelegramInstance(bare, &persistence.Session{}, component) if !ok { iqAnswerSetError(answer, query, 500) return } } err := session.TryLogin(resource, query.Username) if err != nil { if err.Error() == telegram.TelegramAuthDone { iqAnswerSetError(answer, query, 406) } else { iqAnswerSetError(answer, query, 500) } return } err = session.SetPhoneNumber(query.Username) if err != nil { iqAnswerSetError(answer, query, 500) return } // everything okay, the response should be empty with no payload/error at this point gateway.SubscribeToTransport(component, iq.From) } else { iqAnswerSetError(answer, query, 406) } } func iqAnswerSetError(answer *stanza.IQ, payload *extensions.QueryRegister, code int) { answer.Type = stanza.IQTypeError answer.Payload = *payload switch code { case 400: answer.Error = &stanza.Err{ Code: code, Type: stanza.ErrorTypeModify, Reason: "bad-request", } case 405: answer.Error = &stanza.Err{ Code: code, Type: stanza.ErrorTypeCancel, Reason: "not-allowed", Text: "Logging out is dangerous. If you are sure you would be able to receive the authentication code again, issue the /logout command to the transport", } case 406: answer.Error = &stanza.Err{ Code: code, Type: stanza.ErrorTypeModify, Reason: "not-acceptable", Text: "Phone number already provided, chat with the transport for further instruction", } case 500: answer.Error = &stanza.Err{ Code: code, Type: stanza.ErrorTypeWait, Reason: "internal-server-error", } default: log.Error("Unknown error code, falling back with empty reason") answer.Error = &stanza.Err{ Code: code, Type: stanza.ErrorTypeCancel, Reason: "undefined-condition", } } } func presenceReplySetError(reply *stanza.Presence, code int) { reply.Type = stanza.PresenceTypeError reply.Error = stanza.Err{ Code: code, } switch code { case 400: reply.Error.Type = stanza.ErrorTypeModify reply.Error.Reason = "jid-malformed" case 407: reply.Error.Type = stanza.ErrorTypeAuth reply.Error.Reason = "registration-required" case 404: reply.Error.Type = stanza.ErrorTypeCancel reply.Error.Reason = "item-not-found" default: log.Error("Unknown error code, falling back with empty reason") reply.Error.Type = stanza.ErrorTypeCancel reply.Error.Reason = "undefined-condition" } } 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 } func makeVCardPayload(typ byte, id string, info telegram.VCardInfo, session *telegram.Client) stanza.IQPayload { var base64Photo string if info.Photo != nil { file, path, err := session.ForceOpenFile(info.Photo, 32) if err == nil { defer file.Close() buf := new(bytes.Buffer) binval := base64.NewEncoder(base64.StdEncoding, buf) _, err = io.Copy(binval, file) binval.Close() if err == nil { base64Photo = buf.String() } else { log.Errorf("Error calculating base64: %v", path) } } else if path != "" { log.Errorf("Photo does not exist: %v", path) } else { log.Errorf("PHOTO: %#v", err.Error()) } } if typ == TypeVCardTemp { vcard := &extensions.IqVcardTemp{} vcard.Fn.Text = info.Fn if base64Photo != "" { vcard.Photo.Type.Text = "image/jpeg" vcard.Photo.Binval.Text = base64Photo } vcard.Nickname.Text = strings.Join(info.Nicknames, ",") vcard.N.Given.Text = info.Given vcard.N.Family.Text = info.Family vcard.Tel.Number.Text = info.Tel vcard.Desc.Text = info.Info return vcard } else if typ == TypeVCard4 { nodes := []stanza.Node{} if info.Fn != "" { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "fn"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "text"}, Content: info.Fn, }, }, }) } if base64Photo != "" { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "photo"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "uri"}, Content: "data:image/jpeg;base64," + base64Photo, }, }, }) } for _, nickname := range info.Nicknames { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "nickname"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "text"}, Content: nickname, }, }, }, stanza.Node{ XMLName: xml.Name{Local: "impp"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "uri"}, Content: "https://t.me/" + nickname, }, }, }) } if info.Family != "" || info.Given != "" { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "n"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "surname"}, Content: info.Family, }, stanza.Node{ XMLName: xml.Name{Local: "given"}, Content: info.Given, }, }, }) } if info.Tel != "" { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "tel"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "uri"}, Content: "tel:" + info.Tel, }, }, }) } if info.Info != "" { nodes = append(nodes, stanza.Node{ XMLName: xml.Name{Local: "note"}, Nodes: []stanza.Node{ stanza.Node{ XMLName: xml.Name{Local: "text"}, Content: info.Info, }, }, }) } pubsub := &stanza.PubSubGeneric{ Items: &stanza.Items{ Node: NodeVCard4, List: []stanza.Item{ stanza.Item{ Id: id, Any: &stanza.Node{ XMLName: xml.Name{Local: "vcard"}, Attrs: []xml.Attr{ xml.Attr{ Name: xml.Name{Local: "xmlns"}, Value: "urn:ietf:params:xml:ns:vcard-4.0", }, }, Nodes: nodes, }, }, }, }, } return pubsub } return nil }