package telegram import ( "crypto/sha1" "encoding/binary" "fmt" "github.com/pkg/errors" "hash/maphash" "io" "io/ioutil" "net/http" "os" osUser "os/user" "path/filepath" "regexp" "strconv" "strings" "time" "dev.narayana.im/narayana/telegabber/telegram/cache" "dev.narayana.im/narayana/telegabber/telegram/formatter" "dev.narayana.im/narayana/telegabber/xmpp/gateway" log "github.com/sirupsen/logrus" "github.com/soheilhy/args" "github.com/zelenin/go-tdlib/client" ) type VCardInfo struct { Fn string Photo *client.File Nicknames []string Given string Family string Tel string Info string } var errOffline = errors.New("TDlib instance is offline") var spaceRegex = regexp.MustCompile(`\s+`) var replyRegex = regexp.MustCompile("\\A>>? ?([0-9]+)\\n") const newlineChar string = "\n" const messageHeaderSeparator string = " | " const ( ChatTypeOther byte = iota ChatTypePM ChatTypeGroup ) // GetContactByUsername resolves username to user id retrieves user and chat information func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.User, error) { if !c.Online() { return nil, nil, errOffline } var chat *client.Chat var err error var userID int64 if strings.HasPrefix(username, "@") { chat, err = c.client.SearchPublicChat(&client.SearchPublicChatRequest{ Username: username, }) if err != nil { return nil, nil, err } userID = chat.Id } else { userID, err = strconv.ParseInt(username, 10, 64) if err != nil { return nil, nil, err } } return c.GetContactByID(userID, chat) } // GetContactByID gets user and chat information from cache (or tries to retrieve it, if missing) func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *client.User, error) { if !c.Online() || id == 0 { return nil, nil, errOffline } var user *client.User var cacheChat *client.Chat var ok bool var err error user, ok = c.cache.GetUser(id) if !ok && id > 0 { user, err = c.client.GetUser(&client.GetUserRequest{ UserId: id, }) if err == nil { c.cache.SetUser(id, user) } } cacheChat, ok = c.cache.GetChat(id) if !ok { if chat == nil { cacheChat, err = c.client.GetChat(&client.GetChatRequest{ ChatId: id, }) if err != nil { // error is irrelevant if the user was found successfully if user != nil { return nil, user, nil } return nil, nil, err } c.cache.SetChat(id, cacheChat) } else { c.cache.SetChat(id, chat) } } if chat == nil { chat = cacheChat } return chat, user, nil } // GetChatType checks if a chat is PM or group func (c *Client) GetChatType(id int64) (byte, error) { if !c.Online() || id == 0 { return ChatTypeOther, errOffline } var err error chat, ok := c.cache.GetChat(id) if !ok { chat, err = c.client.GetChat(&client.GetChatRequest{ ChatId: id, }) if err != nil { return ChatTypeOther, err } c.cache.SetChat(id, chat) } chatType := chat.Type.ChatTypeType() if chatType == client.TypeChatTypePrivate || chatType == client.TypeChatTypeSecret { return ChatTypePM, nil } if c.IsGroup(chat) { return ChatTypeGroup, nil } return ChatTypeOther, nil } func (c *Client) userStatusToText(status client.UserStatus, chatID int64) (string, string, string) { var show, textStatus, presenceType string switch status.UserStatusType() { case client.TypeUserStatusOnline: onlineStatus, _ := status.(*client.UserStatusOnline) c.DelayedStatusesLock.Lock() c.DelayedStatuses[chatID] = &DelayedStatus{ TimestampOnline: time.Now().Unix(), TimestampExpired: int64(onlineStatus.Expires), } c.DelayedStatusesLock.Unlock() textStatus = "Online" case client.TypeUserStatusRecently: show, textStatus = "dnd", "Last seen recently" c.DelayedStatusesLock.Lock() delete(c.DelayedStatuses, chatID) c.DelayedStatusesLock.Unlock() case client.TypeUserStatusLastWeek: show, textStatus = "xa", "Last seen last week" case client.TypeUserStatusLastMonth: show, textStatus = "xa", "Last seen last month" case client.TypeUserStatusEmpty: presenceType, textStatus = "unavailable", "Last seen a long time ago" case client.TypeUserStatusOffline: offlineStatus, _ := status.(*client.UserStatusOffline) // this will stop working in 2038 O\ wasOnline := int64(offlineStatus.WasOnline) elapsed := time.Now().Unix() - wasOnline if elapsed < 3600 { show = "away" } else { show = "xa" } textStatus = c.LastSeenStatus(wasOnline) c.DelayedStatusesLock.Lock() delete(c.DelayedStatuses, chatID) c.DelayedStatusesLock.Unlock() } return show, textStatus, presenceType } // LastSeenStatus formats a timestamp to a "Last seen at" string func (c *Client) LastSeenStatus(timestamp int64) string { return time.Unix(int64(timestamp), 0). In(c.Session.TimezoneToLocation()). Format("Last seen at 15:04 02/01/2006") } // ProcessStatusUpdate sets contact status func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, oldArgs ...args.V) error { if !c.Online() { return nil } log.WithFields(log.Fields{ "chat_id": chatID, }).Info("Status update for") chat, user, err := c.GetContactByID(chatID, nil) if err != nil { return err } if chat != nil && c.Session.MUC && c.IsGroup(chat) { return nil } var photo string if chat != nil && chat.Photo != nil { file, path, err := c.ForceOpenFile(chat.Photo.Small, 1) if err == nil { defer file.Close() hash := sha1.New() _, err = io.Copy(hash, file) if err == nil { photo = fmt.Sprintf("%x", hash.Sum(nil)) } else { log.Errorf("Error calculating hash: %v", path) } } else if path != "" { log.Errorf("Photo does not exist: %v", path) } } var presenceType string if gateway.SPType.IsSet(oldArgs) { presenceType = gateway.SPType.Get(oldArgs) } cachedStatus, ok := c.cache.GetStatus(chatID) if status == "" { if ok { var typ string show, status, typ = cachedStatus.Destruct() if presenceType == "" { presenceType = typ } log.WithFields(log.Fields{ "show": show, "status": status, "presenceType": presenceType, }).Debug("Cached status") } else if user != nil && user.Status != nil { show, status, presenceType = c.userStatusToText(user.Status, chatID) log.WithFields(log.Fields{ "show": show, "status": status, "presenceType": presenceType, }).Debug("Status to text") } else { show, status = "chat", chat.Title } } cacheShow := show if presenceType == "unavailable" { cacheShow = presenceType } c.cache.SetStatus(chatID, cacheShow, status) newArgs := []args.V{ gateway.SPFrom(strconv.FormatInt(chatID, 10)), gateway.SPShow(show), gateway.SPStatus(status), gateway.SPPhoto(photo), gateway.SPResource(gateway.Jid.Resource), gateway.SPImmed(gateway.SPImmed.Get(oldArgs)), } if presenceType != "" { newArgs = append(newArgs, gateway.SPType(presenceType)) } return gateway.SendPresence( c.xmpp, c.jid, newArgs..., ) } // JoinMUC saves MUC join fact and sends initialization data func (c *Client) JoinMUC(chatId int64, resource string, limit int32) { // save the nickname in this MUC, also as a marker of join c.locks.mucResourcesLock.Lock() oldMap, ok := c.mucResources[chatId] if ok { _, ok := oldMap[resource] if ok { // already joined, initializing anyway } else { oldMap[resource] = true } } else { newMap := make(map[string]bool) newMap[resource] = true c.mucResources[chatId] = newMap } c.locks.mucResourcesLock.Unlock() c.sendMUCStatuses(chatId) messages, err := c.getNLastMessages(chatId, limit) if err == nil { c.sendMessagesReverse(chatId, messages, false, c.jid+"/"+resource) } c.sendMUCSubject(chatId, resource) } func (c *Client) sendMUCStatuses(chatID int64) { sChatId := strconv.FormatInt(chatID, 10) myNickname := "me" if c.me != nil { myNickname := c.me.FirstName if c.me.LastName != "" { myNickname = myNickname + " " + c.me.LastName } } myAffiliation := "member" members, err := c.client.SearchChatMembers(&client.SearchChatMembersRequest{ ChatId: chatID, Limit: 200, Filter: &client.ChatMembersFilterMembers{}, }) if err == nil { gatewayJidSuffix := "@" + gateway.Jid.Full() for _, member := range members.Members { var senderId int64 switch member.MemberId.MessageSenderType() { case client.TypeMessageSenderUser: memberUser, _ := member.MemberId.(*client.MessageSenderUser) senderId = memberUser.UserId case client.TypeMessageSenderChat: memberChat, _ := member.MemberId.(*client.MessageSenderChat) senderId = memberChat.ChatId } nickname := c.GetMUCNickname(senderId) affiliation := c.memberStatusToAffiliation(member.Status) if c.me != nil && senderId == c.me.Id { myNickname = nickname myAffiliation = affiliation continue } gateway.SendPresence( c.xmpp, c.jid, gateway.SPFrom(sChatId), gateway.SPResource(nickname), gateway.SPImmed(true), gateway.SPMUCAffiliation(affiliation), gateway.SPMUCJid(strconv.FormatInt(senderId, 10) + gatewayJidSuffix), ) } } // according to the spec, own member entry should be sent the last gateway.SendPresence( c.xmpp, c.jid, gateway.SPFrom(sChatId), gateway.SPResource(myNickname), gateway.SPImmed(true), gateway.SPMUCAffiliation(myAffiliation), gateway.SPMUCStatusCodes([]uint16{100, 110, 210}), ) } func (c *Client) sendMUCSubject(chatID int64, resource string) { pin, err := c.client.GetChatPinnedMessage(&client.GetChatPinnedMessageRequest{ ChatId: chatID, }) mucJid := strconv.FormatInt(chatID, 10) + "@" + gateway.Jid.Bare() toJid := c.jid + "/" + resource if err == nil { gateway.SendSubjectMessage( toJid, mucJid + "/" + c.GetMUCNickname(c.GetSenderId(pin)), c.messageToText(pin, false), strconv.FormatInt(pin.Id, 10), c.xmpp, int64(pin.Date), ) } else { gateway.SendSubjectMessage(toJid, mucJid, "", "", c.xmpp, 0) } } // GetMUCNickname generates a unique nickname for a MUC member func (c *Client) GetMUCNickname(chatID int64) string { return c.formatContact(chatID) } func (c *Client) formatContact(chatID int64) string { if chatID == 0 { return "" } chat, user, err := c.GetContactByID(chatID, nil) if err != nil { return "unknown contact: " + err.Error() } var str string if chat != nil { str = fmt.Sprintf("%s (%v)", chat.Title, chat.Id) } else if user != nil { var usernames string if user.Usernames != nil { usernames = c.usernamesToString(user.Usernames.ActiveUsernames) } if usernames == "" { usernames = strconv.FormatInt(user.Id, 10) } str = fmt.Sprintf("%s %s (%v)", user.FirstName, user.LastName, usernames) } else { str = strconv.FormatInt(chatID, 10) } str = spaceRegex.ReplaceAllString(str, " ") return str } // GetSenderId extracts a sender id from a message func (c *Client) GetSenderId(message *client.Message) (senderId int64) { if message.SenderId != nil { switch message.SenderId.MessageSenderType() { case client.TypeMessageSenderUser: senderUser, _ := message.SenderId.(*client.MessageSenderUser) senderId = senderUser.UserId case client.TypeMessageSenderChat: senderChat, _ := message.SenderId.(*client.MessageSenderChat) senderId = senderChat.ChatId } } return } func (c *Client) formatSender(message *client.Message) string { return c.formatContact(c.GetSenderId(message)) } func (c *Client) getMessageReply(message *client.Message) (reply *gateway.Reply, replyMsg *client.Message) { if message.ReplyToMessageId != 0 { var err error replyMsg, err = c.client.GetMessage(&client.GetMessageRequest{ ChatId: message.ChatId, MessageId: message.ReplyToMessageId, }) if err != nil { log.Errorf("", err.Error()) return } replyId, err := gateway.IdsDB.GetByTgIds(c.Session.Login, c.jid, message.ChatId, message.ReplyToMessageId) if err != nil { replyId = strconv.FormatInt(message.ReplyToMessageId, 10) } reply = &gateway.Reply{ Author: fmt.Sprintf("%v@%s", c.GetSenderId(replyMsg), gateway.Jid.Full()), Id: replyId, } } return } func (c *Client) formatMessage(chatID int64, messageID int64, preview bool, message *client.Message) string { var err error if message == nil { message, err = c.client.GetMessage(&client.GetMessageRequest{ ChatId: chatID, MessageId: messageID, }) if err != nil { return fmt.Sprintf("", err.Error()) } } if message == nil { return "" } var str strings.Builder // add messageid and sender str.WriteString(fmt.Sprintf("%v | %s | ", message.Id, c.formatSender(message))) // add date if !preview { str.WriteString( time.Unix(int64(message.Date), 0). In(c.Session.TimezoneToLocation()). Format("02 Jan 2006 15:04:05 | "), ) } // text message var text string if message.Content != nil { text = c.messageToText(message, preview) } if text != "" { if !preview { str.WriteString(text) } else { newlinePos := strings.Index(text, newlineChar) if newlinePos == -1 { str.WriteString(text) } else { str.WriteString(text[0:newlinePos]) } } } return str.String() } func (c *Client) formatForward(fwd *client.MessageForwardInfo) string { switch fwd.Origin.MessageForwardOriginType() { case client.TypeMessageForwardOriginUser: originUser := fwd.Origin.(*client.MessageForwardOriginUser) return c.formatContact(originUser.SenderUserId) case client.TypeMessageForwardOriginChat: originChat := fwd.Origin.(*client.MessageForwardOriginChat) var signature string if originChat.AuthorSignature != "" { signature = fmt.Sprintf(" (%s)", originChat.AuthorSignature) } return c.formatContact(originChat.SenderChatId) + signature case client.TypeMessageForwardOriginHiddenUser: originUser := fwd.Origin.(*client.MessageForwardOriginHiddenUser) return originUser.SenderName case client.TypeMessageForwardOriginChannel: channel := fwd.Origin.(*client.MessageForwardOriginChannel) var signature string if channel.AuthorSignature != "" { signature = fmt.Sprintf(" (%s)", channel.AuthorSignature) } return c.formatContact(channel.ChatId) + signature case client.TypeMessageForwardOriginMessageImport: originImport := fwd.Origin.(*client.MessageForwardOriginMessageImport) return originImport.SenderName } return "Unknown forward type" } func (c *Client) formatFile(file *client.File, compact bool) (string, string) { if file == nil { return "", "" } src, link := c.PermastoreFile(file, false) if compact { return link, link } else { return fmt.Sprintf("%s (%v kbytes) | %s", filepath.Base(src), file.Size/1024, link), link } } // PermastoreFile steals a file out of TDlib control into an independent shared directory func (c *Client) PermastoreFile(file *client.File, clone bool) (string, string) { log.Debugf("file: %#v", file) if file == nil || file.Local == nil || file.Remote == nil { return "", "" } gateway.StorageLock.Lock() defer gateway.StorageLock.Unlock() var link string var src string if c.content.Path != "" && c.content.Link != "" { src = file.Local.Path // source path _, err := os.Stat(src) if err != nil { log.Errorf("Cannot access source file: %v", err) return "", "" } size64 := uint64(file.Size) c.prepareDiskSpace(size64) basename := file.Remote.UniqueId + filepath.Ext(src) dest := c.content.Path + "/" + basename // destination path link = c.content.Link + "/" + basename // download link if clone { file, path, err := c.ForceOpenFile(file, 1) if err == nil { defer file.Close() // mode mode := os.FileMode(0644) fi, err := os.Stat(path) if err == nil { mode = fi.Mode().Perm() } // create destination tempFile, err := os.OpenFile(dest, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode) if err != nil { pathErr := err.(*os.PathError) if pathErr.Err.Error() == "file exists" { log.Warn(err.Error()) return src, link } else { log.Errorf("File creation error: %v", err) return "", "" } } defer tempFile.Close() // copy _, err = io.Copy(tempFile, file) if err != nil { log.Errorf("File copying error: %v", err) return "", "" } } else if path != "" { log.Errorf("Source file does not exist: %v", path) return "", "" } else { log.Errorf("PHOTO: %#v", err.Error()) return "", "" } } else { // move err = os.Rename(src, dest) if err != nil { linkErr := err.(*os.LinkError) if linkErr.Err.Error() == "file exists" { log.Warn(err.Error()) } else { log.Errorf("File moving error: %v", err) return "", "" } } } // chown if c.content.User != "" { user, err := osUser.Lookup(c.content.User) if err == nil { uid, err := strconv.ParseInt(user.Uid, 10, 0) if err == nil { err = os.Chown(dest, int(uid), -1) if err != nil { log.Errorf("Chown error: %v", err) } } else { log.Errorf("Broken uid: %v", err) } } else { log.Errorf("Wrong user name for chown: %v", err) } } // copy or move should have succeeded at this point gateway.CachedStorageSize += size64 } return src, link } func (c *Client) formatBantime(hours int64) int32 { var until int32 if hours > 0 { until = int32(time.Now().Unix() + hours*3600) } return until } func (c *Client) formatLocation(location *client.Location) string { return fmt.Sprintf( "coordinates: %v,%v | https://www.google.com/maps/search/%v,%v/", location.Latitude, location.Longitude, location.Latitude, location.Longitude, ) } func (c *Client) messageToText(message *client.Message, preview bool) string { if message.Content == nil { log.Warnf("Unknown message: %#v", message) return "" } markupFunction := c.getFormatter() switch message.Content.MessageContentType() { case client.TypeMessageSticker: sticker, _ := message.Content.(*client.MessageSticker) return sticker.Sticker.Emoji case client.TypeMessageAnimatedEmoji: animatedEmoji, _ := message.Content.(*client.MessageAnimatedEmoji) return animatedEmoji.Emoji case client.TypeMessageBasicGroupChatCreate, client.TypeMessageSupergroupChatCreate: return "has created chat" case client.TypeMessageChatJoinByLink: return "joined chat via invite link" case client.TypeMessageChatAddMembers: addMembers, _ := message.Content.(*client.MessageChatAddMembers) text := "invited " if len(addMembers.MemberUserIds) > 0 { text += c.formatContact(addMembers.MemberUserIds[0]) } return text case client.TypeMessageChatDeleteMember: deleteMember, _ := message.Content.(*client.MessageChatDeleteMember) return "kicked " + c.formatContact(deleteMember.UserId) case client.TypeMessagePinMessage: pinMessage, _ := message.Content.(*client.MessagePinMessage) return "pinned message: " + c.formatMessage(message.ChatId, pinMessage.MessageId, preview, nil) case client.TypeMessageChatChangeTitle: changeTitle, _ := message.Content.(*client.MessageChatChangeTitle) return "chat title set to: " + changeTitle.Title case client.TypeMessageLocation: location, _ := message.Content.(*client.MessageLocation) return c.formatLocation(location.Location) case client.TypeMessageVenue: venue, _ := message.Content.(*client.MessageVenue) if preview { return venue.Venue.Title } else { return fmt.Sprintf( "*%s*\n%s\n%s", venue.Venue.Title, venue.Venue.Address, c.formatLocation(venue.Venue.Location), ) } case client.TypeMessagePhoto: photo, _ := message.Content.(*client.MessagePhoto) if preview { return photo.Caption.Text } else { return formatter.Format( photo.Caption.Text, photo.Caption.Entities, markupFunction, ) } case client.TypeMessageAudio: audio, _ := message.Content.(*client.MessageAudio) if preview { return audio.Caption.Text } else { return formatter.Format( audio.Caption.Text, audio.Caption.Entities, markupFunction, ) } case client.TypeMessageVideo: video, _ := message.Content.(*client.MessageVideo) if preview { return video.Caption.Text } else { return formatter.Format( video.Caption.Text, video.Caption.Entities, markupFunction, ) } case client.TypeMessageDocument: document, _ := message.Content.(*client.MessageDocument) if preview { return document.Caption.Text } else { return formatter.Format( document.Caption.Text, document.Caption.Entities, markupFunction, ) } case client.TypeMessageText: text, _ := message.Content.(*client.MessageText) if preview { return text.Text.Text } else { return formatter.Format( text.Text.Text, text.Text.Entities, markupFunction, ) } case client.TypeMessageVoiceNote: voice, _ := message.Content.(*client.MessageVoiceNote) if preview { return voice.Caption.Text } else { return formatter.Format( voice.Caption.Text, voice.Caption.Entities, markupFunction, ) } case client.TypeMessageVideoNote: return "" case client.TypeMessageAnimation: animation, _ := message.Content.(*client.MessageAnimation) if preview { return animation.Caption.Text } else { return formatter.Format( animation.Caption.Text, animation.Caption.Entities, markupFunction, ) } case client.TypeMessageContact: contact, _ := message.Content.(*client.MessageContact) if preview { return contact.Contact.FirstName + " " + contact.Contact.LastName } else { var jid string if contact.Contact.UserId != 0 { jid = fmt.Sprintf("%v@%s", contact.Contact.UserId, gateway.Jid.Bare()) } return fmt.Sprintf( "*%s %s*\n%s\n%s\n%s", contact.Contact.FirstName, contact.Contact.LastName, contact.Contact.PhoneNumber, contact.Contact.Vcard, jid, ) } case client.TypeMessageDice: dice, _ := message.Content.(*client.MessageDice) return fmt.Sprintf("%s 1d6: [%v]", dice.Emoji, dice.Value) case client.TypeMessagePoll: poll, _ := message.Content.(*client.MessagePoll) if preview { return poll.Poll.Question } else { rows := []string{} rows = append(rows, fmt.Sprintf("*%s*", poll.Poll.Question)) for _, option := range poll.Poll.Options { var tick string if option.IsChosen { tick = "x" } else { tick = " " } rows = append(rows, fmt.Sprintf( "[%s] %s | %v%% | %v vote", tick, option.Text, option.VotePercentage, option.VoterCount, )) } return strings.Join(rows, "\n") } case client.TypeMessageChatSetMessageAutoDeleteTime: ttl, _ := message.Content.(*client.MessageChatSetMessageAutoDeleteTime) name := c.formatContact(ttl.FromUserId) if name == "" { if ttl.MessageAutoDeleteTime == 0 { return "The self-destruct timer was disabled" } else { return fmt.Sprintf("The self-destruct timer was set to %v seconds", ttl.MessageAutoDeleteTime) } } else { if ttl.MessageAutoDeleteTime == 0 { return fmt.Sprintf("%s disabled the self-destruct timer", name) } else { return fmt.Sprintf("%s set the self-destruct timer to %v seconds", name, ttl.MessageAutoDeleteTime) } } } return fmt.Sprintf("unknown message (%s)", message.Content.MessageContentType()) } func (c *Client) contentToFile(content client.MessageContent) (*client.File, *client.File) { if content == nil { return nil, nil } switch content.MessageContentType() { case client.TypeMessageSticker: sticker, _ := content.(*client.MessageSticker) file := sticker.Sticker.Sticker if sticker.Sticker.Format.StickerFormatType() == client.TypeStickerFormatTgs && sticker.Sticker.Thumbnail != nil && sticker.Sticker.Thumbnail.File != nil { file = sticker.Sticker.Thumbnail.File } return file, nil case client.TypeMessageVoiceNote: voice, _ := content.(*client.MessageVoiceNote) return voice.VoiceNote.Voice, nil case client.TypeMessageVideoNote: video, _ := content.(*client.MessageVideoNote) var preview *client.File if video.VideoNote.Thumbnail != nil { preview = video.VideoNote.Thumbnail.File } return video.VideoNote.Video, preview case client.TypeMessageAnimation: animation, _ := content.(*client.MessageAnimation) var preview *client.File if animation.Animation.Thumbnail != nil { preview = animation.Animation.Thumbnail.File } return animation.Animation.Animation, preview case client.TypeMessagePhoto: photo, _ := content.(*client.MessagePhoto) sizes := photo.Photo.Sizes if len(sizes) >= 1 { file := sizes[len(sizes)-1].Photo return file, nil } return nil, nil case client.TypeMessageAudio: audio, _ := content.(*client.MessageAudio) var preview *client.File if audio.Audio.AlbumCoverThumbnail != nil { preview = audio.Audio.AlbumCoverThumbnail.File } return audio.Audio.Audio, preview case client.TypeMessageVideo: video, _ := content.(*client.MessageVideo) var preview *client.File if video.Video.Thumbnail != nil { preview = video.Video.Thumbnail.File } return video.Video.Video, preview case client.TypeMessageDocument: document, _ := content.(*client.MessageDocument) var preview *client.File if document.Document.Thumbnail != nil { preview = document.Document.Thumbnail.File } return document.Document.Document, preview } return nil, nil } func (c *Client) countCharsInLines(lines *[]string) (count int) { for _, line := range *lines { count += len(line) } return } func (c *Client) messageToPrefix(message *client.Message, previewString string, fileString string, replyMsg *client.Message) (string, int, int) { chatType, err := c.GetChatType(message.ChatId) if err != nil { log.Errorf("Could not determine chat type: %v", err) } isCarbonsEnabled := gateway.MessageOutgoingPermissionVersion > 0 && c.Session.Carbons // with carbons, hide for all messages in PM and only for outgoing in group chats hideSender := (isCarbonsEnabled && (message.IsOutgoing || chatType == ChatTypePM)) || (c.Session.MUC && chatType == ChatTypeGroup) var replyStart, replyEnd int prefix := []string{} // message direction var directionChar string if !hideSender { if c.Session.AsciiArrows { if message.IsOutgoing { directionChar = "> " } else { directionChar = "< " } } else { if message.IsOutgoing { directionChar = "➡ " } else { directionChar = "⬅ " } } } if (chatType != ChatTypePM && !c.Session.MUC) || !c.Session.HideIds { prefix = append(prefix, directionChar+strconv.FormatInt(message.Id, 10)) } // show sender in group chats if !hideSender { sender := c.formatSender(message) if sender != "" { prefix = append(prefix, sender) } } // reply to if message.ReplyToMessageId != 0 { if len(prefix) > 0 { replyStart = c.countCharsInLines(&prefix) + (len(prefix)-1)*len(messageHeaderSeparator) } replyLine := "reply: " + c.formatMessage(message.ChatId, message.ReplyToMessageId, true, replyMsg) prefix = append(prefix, replyLine) replyEnd = replyStart + len(replyLine) if len(prefix) > 0 { replyEnd += len(messageHeaderSeparator) } } if message.ForwardInfo != nil { prefix = append(prefix, "fwd: "+c.formatForward(message.ForwardInfo)) } // preview if previewString != "" { prefix = append(prefix, "preview: "+previewString) } // file if fileString != "" { prefix = append(prefix, "file: "+fileString) } return strings.Join(prefix, messageHeaderSeparator), replyStart, replyEnd } func (c *Client) ensureDownloadFile(file *client.File) *client.File { gateway.StorageLock.Lock() defer gateway.StorageLock.Unlock() if file != nil { c.prepareDiskSpace(uint64(file.Size)) newFile, err := c.DownloadFile(file.Id, 1, true) if err == nil { return newFile } } return file } // ProcessIncomingMessage is a legacy wrapper for SendMessageToGateway aiming only PM messages func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) { c.SendMessageToGateway(chatId, message, "", false, "", []string{}) } // SendMessageToGateway transfers a message to XMPP side and marks it as read on Telegram side func (c *Client) SendMessageToGateway(chatId int64, message *client.Message, id string, delay bool, groupChatFrom string, groupChatTos []string) { var isCarbon bool var jids []string var isGroupchat bool var originalFrom string if len(groupChatTos) == 0 { isCarbon = gateway.MessageOutgoingPermissionVersion > 0 && c.Session.Carbons && message.IsOutgoing jids = c.getCarbonFullJids(isCarbon, "") } else { isGroupchat = true jids = groupChatTos senderId := c.GetSenderId(message) if senderId != 0 { originalFrom = strconv.FormatInt(senderId, 10) + "@" + gateway.Jid.Full() } } var text, oob, auxText string reply, replyMsg := c.getMessageReply(message) content := message.Content if content != nil && content.MessageContentType() == client.TypeMessageChatChangePhoto { chat, err := c.client.GetChat(&client.GetChatRequest{ ChatId: chatId, }) if err == nil { c.cache.SetChat(chatId, chat) go c.ProcessStatusUpdate(chatId, "", "", gateway.SPImmed(true)) text = "" } } else { text = c.messageToText(message, false) // OTR support (I do not know why would you need it, seriously) if !(strings.HasPrefix(text, "?OTR") || (c.Session.RawMessages && !c.Session.OOBMode)) { file, preview := c.contentToFile(content) // download file and preview (if present) file = c.ensureDownloadFile(file) preview = c.ensureDownloadFile(preview) previewName, _ := c.formatFile(preview, true) fileName, link := c.formatFile(file, false) oob = link if c.Session.OOBMode && oob != "" { typ := message.Content.MessageContentType() if typ != client.TypeMessageSticker { auxText = text } text = oob } else if !c.Session.RawMessages { var newText strings.Builder prefix, replyStart, replyEnd := c.messageToPrefix(message, previewName, fileName, replyMsg) newText.WriteString(prefix) if reply != nil { reply.Start = uint64(replyStart) reply.End = uint64(replyEnd) } if text != "" { // \n if it is groupchat and message is not empty if prefix != "" { if chatId < 0 { newText.WriteString("\n") } else if chatId > 0 { newText.WriteString(" | ") } } newText.WriteString(text) } text = newText.String() } } } // mark message as read c.client.ViewMessages(&client.ViewMessagesRequest{ ChatId: chatId, MessageIds: []int64{message.Id}, ForceRead: true, }) // forward message to XMPP var sId string if id == "" { sId = strconv.FormatInt(message.Id, 10) } else { sId = id } var from string if groupChatFrom == "" { from = strconv.FormatInt(chatId, 10) } else { from = groupChatFrom } var timestamp int64 if delay { timestamp = int64(message.Date) } for _, jid := range jids { gateway.SendMessageWithOOB(jid, from, text, sId, c.xmpp, reply, timestamp, oob, isCarbon, isGroupchat, originalFrom) if auxText != "" { gateway.SendMessage(jid, from, auxText, sId, c.xmpp, reply, timestamp, isCarbon, isGroupchat, originalFrom) } } } // PrepareMessageContent creates a simple text message func (c *Client) PrepareOutgoingMessageContent(text string) client.InputMessageContent { return c.prepareOutgoingMessageContent(text, nil) } // ProcessOutgoingMessage executes commands or sends messages to mapped chats, returns message id func (c *Client) ProcessOutgoingMessage(chatID int64, text string, returnJid string, replyId int64, replaceId int64, isGroupchat bool) *client.Message { if !c.Online() { // we're offline return nil } if replaceId == 0 && (strings.HasPrefix(text, "/") || strings.HasPrefix(text, "!")) { // try to execute commands response, isCommand := c.ProcessChatCommand(chatID, text) if response != "" { c.returnMessage(returnJid, chatID, response, 0, isGroupchat) } // do not send on success if isCommand { return nil } } log.Warnf("Sending message to chat %v", chatID) // quotations var reply int64 if replaceId == 0 && replyId == 0 { replySlice := replyRegex.FindStringSubmatch(text) if len(replySlice) > 1 { reply, _ = strconv.ParseInt(replySlice[1], 10, 64) } } else { reply = replyId } // attach a file var file *client.InputFileLocal if c.content.Upload != "" && strings.HasPrefix(text, c.content.Upload) { response, err := http.Get(text) if err != nil { c.returnError(returnJid, chatID, "Failed to fetch the uploaded file", err, 500, isGroupchat) } if response != nil && response.Body != nil { defer response.Body.Close() if response.StatusCode != 200 { c.returnMessage(returnJid, chatID, fmt.Sprintf("Received status code %v", response.StatusCode), response.StatusCode, isGroupchat) return nil } tempDir, err := ioutil.TempDir("", "telegabber-*") if err != nil { c.returnError(returnJid, chatID, "Failed to create a temporary directory", err, 500, isGroupchat) return nil } tempFile, err := os.Create(filepath.Join(tempDir, filepath.Base(text))) if err != nil { c.returnError(returnJid, chatID, "Failed to create a temporary file", err, 500, isGroupchat) return nil } _, err = io.Copy(tempFile, response.Body) if err != nil { c.returnError(returnJid, chatID, "Failed to write a temporary file", err, 500, isGroupchat) return nil } file = &client.InputFileLocal{ Path: tempFile.Name(), } } } // remove first line from text if file != nil || (reply != 0 && replyId == 0) { newlinePos := strings.Index(text, newlineChar) if newlinePos != -1 { text = text[newlinePos+1:] } else { text = "" } } content := c.prepareOutgoingMessageContent(text, file) if replaceId != 0 { tgMessage, err := c.client.EditMessageText(&client.EditMessageTextRequest{ ChatId: chatID, MessageId: replaceId, InputMessageContent: content, }) if err != nil { c.returnError(returnJid, chatID, "Not edited", err, 400, isGroupchat) return nil } return tgMessage } tgMessage, err := c.client.SendMessage(&client.SendMessageRequest{ ChatId: chatID, ReplyToMessageId: reply, InputMessageContent: content, }) if err != nil { c.returnError(returnJid, chatID, "Not sent", err, 400, isGroupchat) return nil } return tgMessage } func (c *Client) returnMessage(returnJid string, chatID int64, text string, code int, isGroupchat bool) { sChatId := strconv.FormatInt(chatID, 10) if isGroupchat { gateway.SendErrorMessage(returnJid, sChatId + "@" + gateway.Jid.Bare(), text, code, isGroupchat, c.xmpp) } else { gateway.SendTextMessage(returnJid, sChatId, text, c.xmpp) } } func (c *Client) returnError(returnJid string, chatID int64, msg string, err error, code int, isGroupchat bool) { responseError, ok := err.(client.ResponseError) log.Debugf("responseError: %#v", responseError) if ok && responseError.Err != nil { if responseError.Err.Message == "Have no write access to the chat" { code = 403 } } c.returnMessage(returnJid, chatID, fmt.Sprintf("%s: %s", msg, err.Error()), code, isGroupchat) } func (c *Client) prepareOutgoingMessageContent(text string, file *client.InputFileLocal) client.InputMessageContent { formattedText := &client.FormattedText{ Text: text, } var content client.InputMessageContent if file != nil { // we can try to send a document content = &client.InputMessageDocument{ Document: file, Caption: formattedText, } } else { // compile our message content = &client.InputMessageText{ Text: formattedText, } } return content } // StatusesRange proxies the following function from unexported cache func (c *Client) StatusesRange() chan *cache.Status { return c.cache.StatusesRange() } func (c *Client) addResource(resource string) { if resource == "" { return } c.locks.resourcesLock.Lock() defer c.locks.resourcesLock.Unlock() c.resources[resource] = true } func (c *Client) deleteResource(resource string) { c.locks.resourcesLock.Lock() defer c.locks.resourcesLock.Unlock() if _, ok := c.resources[resource]; ok { delete(c.resources, resource) } } func (c *Client) resourcesRange() chan string { c.locks.resourcesLock.Lock() resourceChan := make(chan string, 1) go func() { defer func() { c.locks.resourcesLock.Unlock() close(resourceChan) }() for resource := range c.resources { resourceChan <- resource } }() return resourceChan } // resend statuses to (to another resource, for example) func (c *Client) roster(resource string) { c.locks.resourcesLock.Lock() if _, ok := c.resources[resource]; ok { c.locks.resourcesLock.Unlock() return // we know it } c.locks.resourcesLock.Unlock() log.Warnf("Sending roster for %v", resource) for _, chat := range c.cache.ChatsKeys() { c.ProcessStatusUpdate(chat, "", "") } gateway.SendPresence(c.xmpp, c.jid, gateway.SPStatus("Logged in as: "+c.Session.Login)) c.addResource(resource) } // get last messages from specified chat func (c *Client) getLastMessages(id int64, query string, from int64, count int32) (*client.FoundChatMessages, error) { return c.client.SearchChatMessages(&client.SearchChatMessagesRequest{ ChatId: id, Query: query, SenderId: &client.MessageSenderUser{UserId: from}, Filter: &client.SearchMessagesFilterEmpty{}, Limit: count, }) } func (c *Client) getNLastMessages(chatID int64, limit int32) ([]*client.Message, error) { var newMessages *client.Messages var messages []*client.Message var err error var fromId int64 for _ = range make([]struct{}, limit) { // safety limit if len(messages) > 0 { fromId = messages[len(messages)-1].Id } newMessages, err = c.client.GetChatHistory(&client.GetChatHistoryRequest{ ChatId: chatID, FromMessageId: fromId, Limit: limit, }) if err != nil { return nil, err } messages = append(messages, newMessages.Messages...) if len(newMessages.Messages) == 0 || len(messages) >= int(limit) { break } } return messages, nil } // DownloadFile actually obtains a file by id given by TDlib func (c *Client) DownloadFile(id int32, priority int32, synchronous bool) (*client.File, error) { return c.client.DownloadFile(&client.DownloadFileRequest{ FileId: id, Priority: priority, Synchronous: synchronous, }) } // ForceOpenFile reliably obtains a file if possible func (c *Client) ForceOpenFile(tgFile *client.File, priority int32) (*os.File, string, error) { if tgFile == nil { return nil, "", errors.New("File not found") } path := tgFile.Local.Path file, err := os.Open(path) if err == nil { return file, path, nil } else // obtain the photo right now if still not downloaded if !tgFile.Local.IsDownloadingCompleted { tdFile, tdErr := c.DownloadFile(tgFile.Id, priority, true) if tdErr == nil { path = tdFile.Local.Path file, err = os.Open(path) return file, path, err } } // give up return nil, path, err } // GetChatDescription obtains bio or description according to the chat type func (c *Client) GetChatDescription(chat *client.Chat) string { chatType := chat.Type.ChatTypeType() if chatType == client.TypeChatTypePrivate { privateType, _ := chat.Type.(*client.ChatTypePrivate) fullInfo, err := c.client.GetUserFullInfo(&client.GetUserFullInfoRequest{ UserId: privateType.UserId, }) if err == nil { if fullInfo.Bio != nil && fullInfo.Bio.Text != "" { return formatter.Format( fullInfo.Bio.Text, fullInfo.Bio.Entities, c.getFormatter(), ) } else if fullInfo.BotInfo != nil { if fullInfo.BotInfo.ShortDescription != "" { return fullInfo.BotInfo.ShortDescription } else { return fullInfo.BotInfo.Description } } } else { log.Warnf("Couldn't retrieve private chat info: %v", err.Error()) } } else if chatType == client.TypeChatTypeBasicGroup { basicGroupType, _ := chat.Type.(*client.ChatTypeBasicGroup) fullInfo, err := c.client.GetBasicGroupFullInfo(&client.GetBasicGroupFullInfoRequest{ BasicGroupId: basicGroupType.BasicGroupId, }) if err == nil { return fullInfo.Description } else { log.Warnf("Couldn't retrieve basic group info: %v", err.Error()) } } else if chatType == client.TypeChatTypeSupergroup { supergroupType, _ := chat.Type.(*client.ChatTypeSupergroup) fullInfo, err := c.client.GetSupergroupFullInfo(&client.GetSupergroupFullInfoRequest{ SupergroupId: supergroupType.SupergroupId, }) if err == nil { return fullInfo.Description } else { log.Warnf("Couldn't retrieve supergroup info: %v", err.Error()) } } return "" } // GetChatMemberCount obtains the member count depending on the chat type func (c *Client) GetChatMemberCount(chat *client.Chat) int32 { chatType := chat.Type.ChatTypeType() if chatType == client.TypeChatTypePrivate { return 2 } else if chatType == client.TypeChatTypeBasicGroup { basicGroupType, _ := chat.Type.(*client.ChatTypeBasicGroup) basicGroup, err := c.client.GetBasicGroup(&client.GetBasicGroupRequest{ BasicGroupId: basicGroupType.BasicGroupId, }) if err == nil { return basicGroup.MemberCount } else { log.Warnf("Couldn't retrieve basic group: %v", err.Error()) } } else if chatType == client.TypeChatTypeSupergroup { supergroupType, _ := chat.Type.(*client.ChatTypeSupergroup) supergroup, err := c.client.GetSupergroup(&client.GetSupergroupRequest{ SupergroupId: supergroupType.SupergroupId, }) if err == nil { return supergroup.MemberCount } else { log.Warnf("Couldn't retrieve supergroup: %v", err.Error()) } } return 0 } // GetGroupChats obtains all group chats func (c *Client) GetGroupChats() []*client.Chat { var groupChats []*client.Chat chats, err := c.client.GetChats(&client.GetChatsRequest{ Limit: chatsLimit, }) if err == nil { for _, id := range chats.ChatIds { chat, _, _ := c.GetContactByID(id, nil) if chat != nil && c.IsGroup(chat) { groupChats = append(groupChats, chat) } } } else { log.Errorf("Could not retrieve chats: %v", err) } return groupChats } // IsGroup determines if a chat is eligible to be represented as MUC func (c *Client) IsGroup(chat *client.Chat) bool { typ := chat.Type.ChatTypeType() return typ == client.TypeChatTypeBasicGroup } // subscribe to a Telegram ID func (c *Client) subscribeToID(id int64, chat *client.Chat) { var args []args.V args = append(args, gateway.SPFrom(strconv.FormatInt(id, 10))) args = append(args, gateway.SPType("subscribe")) if chat == nil { chat, _, _ = c.GetContactByID(id, nil) } if chat != nil { if c.Session.MUC && c.IsGroup(chat) { return } args = append(args, gateway.SPNickname(chat.Title)) gateway.SetNickname(c.jid, strconv.FormatInt(id, 10), chat.Title, c.xmpp) } gateway.SendPresence( c.xmpp, c.jid, args..., ) } func (c *Client) prepareDiskSpace(size uint64) { if gateway.StorageQuota > 0 && c.content.Path != "" { var loweredQuota uint64 if gateway.StorageQuota >= size { loweredQuota = gateway.StorageQuota - size } if gateway.CachedStorageSize >= loweredQuota { log.Warn("Storage is rapidly clogged") gateway.CleanOldFiles(c.content.Path, loweredQuota) } } } func (c *Client) GetVcardInfo(toID int64) (VCardInfo, error) { var info VCardInfo chat, user, err := c.GetContactByID(toID, nil) if err != nil { return info, err } if chat != nil { info.Fn = chat.Title if chat.Photo != nil { info.Photo = chat.Photo.Small } info.Info = c.GetChatDescription(chat) } if user != nil { if user.Usernames != nil { info.Nicknames = make([]string, len(user.Usernames.ActiveUsernames)) copy(info.Nicknames, user.Usernames.ActiveUsernames) } info.Given = user.FirstName info.Family = user.LastName info.Tel = user.PhoneNumber } return info, nil } func (c *Client) UpdateChatNicknames() { for _, id := range c.cache.ChatsKeys() { chat, ok := c.cache.GetChat(id) if ok { if c.Session.MUC && c.IsGroup(chat) { continue } newArgs := []args.V{ gateway.SPFrom(strconv.FormatInt(id, 10)), gateway.SPNickname(chat.Title), } cachedStatus, ok := c.cache.GetStatus(id) if ok { show, status, typ := cachedStatus.Destruct() newArgs = append(newArgs, gateway.SPShow(show), gateway.SPStatus(status)) if typ != "" { newArgs = append(newArgs, gateway.SPType(typ)) } } gateway.SendPresence( c.xmpp, c.jid, newArgs..., ) gateway.SetNickname(c.jid, strconv.FormatInt(id, 10), chat.Title, c.xmpp) } } } // AddToOutbox remembers the resource from which a message with given ID was sent func (c *Client) AddToOutbox(xmppId, resource string) { c.locks.outboxLock.Lock() defer c.locks.outboxLock.Unlock() c.outbox[xmppId] = resource } func (c *Client) popFromOutbox(xmppId string) string { c.locks.outboxLock.Lock() defer c.locks.outboxLock.Unlock() resource, ok := c.outbox[xmppId] if ok { delete(c.outbox, xmppId) } else { log.Warnf("No %v xmppId in outbox", xmppId) } return resource } func (c *Client) getCarbonFullJids(isOutgoing bool, ignoredResource string) []string { var jids []string if isOutgoing { for resource := range c.resourcesRange() { if ignoredResource == "" || resource != ignoredResource { jids = append(jids, c.jid+"/"+resource) } } } else { jids = []string{c.jid} } return jids } func (c *Client) calculateMessageHash(messageId int64, content client.MessageContent) uint64 { var h maphash.Hash h.SetSeed(c.msgHashSeed) buf8 := make([]byte, 8) binary.BigEndian.PutUint64(buf8, uint64(messageId)) h.Write(buf8) if content != nil && content.MessageContentType() == client.TypeMessageText { textContent, ok := content.(*client.MessageText) if !ok { uhOh() } if textContent.Text != nil { h.WriteString(textContent.Text.Text) for _, entity := range textContent.Text.Entities { buf4 := make([]byte, 4) binary.BigEndian.PutUint32(buf4, uint32(entity.Offset)) h.Write(buf4) binary.BigEndian.PutUint32(buf4, uint32(entity.Length)) h.Write(buf4) h.WriteString(entity.Type.TextEntityTypeType()) } } } return h.Sum64() } func (c *Client) updateLastMessageHash(chatId, messageId int64, content client.MessageContent) { c.locks.lastMsgHashesLock.Lock() defer c.locks.lastMsgHashesLock.Unlock() c.lastMsgHashes[chatId] = c.calculateMessageHash(messageId, content) } func (c *Client) hasLastMessageHashChanged(chatId, messageId int64, content client.MessageContent) bool { c.locks.lastMsgHashesLock.Lock() defer c.locks.lastMsgHashesLock.Unlock() oldHash, ok := c.lastMsgHashes[chatId] newHash := c.calculateMessageHash(messageId, content) if !ok { log.Warnf("Last message hash for chat %v does not exist", chatId) } log.WithFields(log.Fields{ "old hash": oldHash, "new hash": newHash, }).Info("Message hashes") return !ok || oldHash != newHash } func (c *Client) getFormatter() func(*client.TextEntity) (*formatter.Insertion, *formatter.Insertion) { return formatter.EntityToXEP0393 } func (c *Client) usernamesToString(usernames []string) string { var atUsernames []string for _, username := range usernames { atUsernames = append(atUsernames, "@"+username) } return strings.Join(atUsernames, ", ") } func (c *Client) memberStatusToAffiliation(memberStatus client.ChatMemberStatus) string { switch memberStatus.ChatMemberStatusType() { case client.TypeChatMemberStatusCreator: return "owner" case client.TypeChatMemberStatusAdministrator: return "admin" case client.TypeChatMemberStatusMember: return "member" case client.TypeChatMemberStatusRestricted: return "outcast" case client.TypeChatMemberStatusLeft: return "none" case client.TypeChatMemberStatusBanned: return "outcast" } return "member" } func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message, plain bool, toJid string) { sChatId := strconv.FormatInt(chatID, 10) var mucJid string if toJid != "" { mucJid = sChatId + "@" + gateway.Jid.Bare() } for i := len(messages) - 1; i >= 0; i-- { message := messages[i] if plain { reply, _ := c.getMessageReply(message) gateway.SendMessage( c.jid, sChatId, c.formatMessage(0, 0, false, message), strconv.FormatInt(message.Id, 10), c.xmpp, reply, 0, false, false, "", ) } else { c.SendMessageToGateway( chatID, message, "", true, mucJid + "/" + c.GetMUCNickname(c.GetSenderId(message)), []string{toJid}, ) } } }