Makefile

@@ -2,7 +2,7 @@
 
 COMMIT := $(shell git rev-parse --short HEAD)
 TD_COMMIT := "5bbfc1cf5dab94f82e02f3430ded7241d4653551"
-VERSION := "v1.12.8"
+VERSION := "v1.12.2"
 MAKEOPTS := "-j4"
 
 all:

telegabber.go

@@ -16,7 +16,7 @@ import (
 	goxmpp "gosrc.io/xmpp"
 )
 
-var version string = "1.12.8"
+var version string = "1.12.2"
 var commit string
 
 var sm *goxmpp.StreamManager
@@ -68,7 +68,7 @@ func main() {
 
 	log.Infof("Starting telegabber version %v", version)
 
-	sm, component, err = xmpp.NewComponent(config.XMPP, config.Telegram, *idsPath, version)
+	sm, component, err = xmpp.NewComponent(config.XMPP, config.Telegram, *idsPath)
 	if err != nil {
 		log.Fatal(err)
 	}

telegram/cache/cache.go

@@ -16,8 +16,7 @@ type Status struct {
 // Cache allows operating the chats and users cache in
 // a thread-safe manner
 type Cache struct {
-	ownChats     map[int64]*client.Chat
+	chats        map[int64]*client.Chat
-	auxChats     map[int64]*client.Chat
 	users        map[int64]*client.User
 	statuses     map[int64]*Status
 	chatsLock    sync.Mutex
@@ -28,8 +27,7 @@ type Cache struct {
 // NewCache initializes a cache
 func NewCache() *Cache {
 	return &Cache{
-		ownChats: map[int64]*client.Chat{},
+		chats:    map[int64]*client.Chat{},
-		auxChats: map[int64]*client.Chat{},
 		users:    map[int64]*client.User{},
 		statuses: map[int64]*Status{},
 	}
@@ -42,23 +40,7 @@ func (cache *Cache) ChatsKeys() []int64 {
 	defer cache.chatsLock.Unlock()
 
 	var keys []int64
-	for id := range cache.ownChats {
+	for id := range cache.chats {
-		keys = append(keys, id)
-	}
-	for id := range cache.auxChats {
-		keys = append(keys, id)
-	}
-	return keys
-}
-
-// OwnChatsKeys grabs only own chat ids synchronously to avoid lockups
-// while they are used
-func (cache *Cache) OwnChatsKeys() []int64 {
-	cache.chatsLock.Lock()
-	defer cache.chatsLock.Unlock()
-
-	var keys []int64
-	for id := range cache.ownChats {
 		keys = append(keys, id)
 	}
 	return keys
@@ -102,10 +84,7 @@ func (cache *Cache) GetChat(id int64) (*client.Chat, bool) {
 	cache.chatsLock.Lock()
 	defer cache.chatsLock.Unlock()
 
-	chat, ok := cache.ownChats[id]
+	chat, ok := cache.chats[id]
-	if !ok {
-		chat, ok = cache.auxChats[id]
-	}
 	return chat, ok
 }
 
@@ -128,21 +107,11 @@ func (cache *Cache) GetStatus(id int64) (*Status, bool) {
 }
 
 // SetChat stores a chat in the cache
-func (cache *Cache) SetChat(id int64, chat *client.Chat, own bool) {
+func (cache *Cache) SetChat(id int64, chat *client.Chat) {
 	cache.chatsLock.Lock()
 	defer cache.chatsLock.Unlock()
 
-	if own {
+	cache.chats[id] = chat
-		cache.ownChats[id] = chat
-		// move from aux to own, but not vice versa
-		// (own: true means that presences for the chat are needed
-		// for sure, false means just "not necessarily")
-		if _, ok := cache.auxChats[id]; ok {
-			delete(cache.auxChats, id)
-		}
-	} else {
-		cache.auxChats[id] = chat
-	}
 }
 
 // SetUser stores a user in the cache

telegram/client.go

@@ -2,6 +2,7 @@ package telegram
 
 import (
 	"github.com/pkg/errors"
+	"hash/maphash"
 	"path/filepath"
 	"strconv"
 	"sync"
@@ -27,41 +28,6 @@ type HashedAvatar struct {
 	File int32
 }
 
-// NewId stores message ids and timestamps of their additions so old ones can be truncated to save memory
-type newId struct {
-	Id      int64
-	Ts      int64
-	lock    sync.Mutex
-	ownLock sync.Mutex
-	locked  bool
-	fired   bool
-}
-
-func newNewId() *newId {
-	return &newId{Ts: time.Now().Unix()}
-}
-
-func (i *newId) Lock() {
-	i.ownLock.Lock()
-	if i.fired {
-		i.ownLock.Unlock()
-		return
-	}
-	i.locked = true
-	i.ownLock.Unlock()
-	i.lock.Lock()
-}
-
-func (i *newId) Unlock() {
-	i.ownLock.Lock()
-	if i.locked {
-		i.lock.Unlock()
-		i.locked = false
-		i.fired = true
-	}
-	i.ownLock.Unlock()
-}
-
 // Client stores the metadata for lazily invoked TDlib instance
 type Client struct {
 	client     *client.Client
@@ -90,6 +56,7 @@ type Client struct {
 
 	lastMsgHashes map[int64]uint64
 	lastMsgIds    map[int64]string
+	msgHashSeed   maphash.Seed
 
 	LastBotCmdString string
 
@@ -99,9 +66,6 @@ type Client struct {
 	AvatarHashes     map[int64]*HashedAvatar
 	AvatarHashesLock sync.Mutex
 
-	MessageIdChanges     map[int64]map[int64]*newId
-	MessageIdChangesLock sync.Mutex
-
 	locks           clientLocks
 	SendMessageLock sync.Mutex
 }
@@ -185,9 +149,9 @@ func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component
 		DelayedStatuses:    make(map[int64]*DelayedStatus),
 		lastMsgHashes:      make(map[int64]uint64),
 		lastMsgIds:         make(map[int64]string),
+		msgHashSeed:        maphash.MakeSeed(),
 		XmppClientFeatures: make(map[string]*[]string),
 		AvatarHashes:       make(map[int64]*HashedAvatar),
-		MessageIdChanges:   make(map[int64]map[int64]*newId),
 		locks: clientLocks{
 			chatMessageLocks: make(map[int64]*sync.Mutex),
 		},

telegram/commands.go

@@ -51,23 +51,22 @@ var permissionsMember = client.ChatPermissions{
 var permissionsReadonly = client.ChatPermissions{}
 
 var transportCommands = map[string]command{
-	"help":        command{0, []string{}, "help", false, nil, false},
+	"help":        command{0, []string{}, "help", false, nil},
-	"login":       command{1, []string{"phone"}, "sign in", false, nil, false},
+	"login":       command{1, []string{"phone"}, "sign in", false, nil},
-	"logout":      command{0, []string{}, "sign out", true, nil, true},
+	"logout":      command{0, []string{}, "sign out", true, nil},
-	"cleanup":     command{0, []string{}, "unsubscribe from all known chats", false, nil, false},
+	"cancelauth":  command{0, []string{}, "quit the signin wizard", false, nil},
-	"cancelauth":  command{0, []string{}, "quit the signin wizard", false, nil, false},
+	"code":        command{1, []string{"xxxxx"}, "check one-time code", false, nil},
-	"code":        command{1, []string{"xxxxx"}, "check one-time code", false, nil, false},
+	"password":    command{1, []string{"********"}, "check 2fa password", false, nil},
-	"password":    command{1, []string{"********"}, "check 2fa password", false, nil, false},
+	"setusername": command{0, []string{"@username"}, "update @username", true, nil},
-	"setusername": command{0, []string{"@username"}, "update @username", true, nil, true},
+	"setname":     command{1, []string{"first", "last"}, "update name", true, nil},
-	"setname":     command{1, []string{"first", "last"}, "update name", true, nil, false},
+	"setbio":      command{0, []string{"Lorem ipsum"}, "update about", true, nil},
-	"setbio":      command{0, []string{"Lorem ipsum"}, "update about", true, nil, true},
+	"setpassword": command{0, []string{"old", "new"}, "set or remove password", true, nil},
-	"setpassword": command{0, []string{"old", "new"}, "set or remove password", true, nil, true},
+	"config":      command{0, []string{"param", "value"}, "view or update configuration options", false, nil},
-	"config":      command{0, []string{"param", "value"}, "view or update configuration options", false, nil, false},
+	"report":      command{2, []string{"chat", "comment"}, "report a chat by id or @username", true, nil},
-	"report":      command{2, []string{"chat", "comment"}, "report a chat by id or @username", true, nil, true},
+	"add":         command{1, []string{"@username"}, "add @username to your chat list", true, nil},
-	"add":         command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
+	"join":        command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil},
-	"join":        command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
+	"supergroup":  command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil},
-	"supergroup":  command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
+	"channel":     command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil},
-	"channel":     command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
 }
 
 var notForGroups = []ChatType{ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}
@@ -76,38 +75,38 @@ var notForPMAndBasic = []ChatType{ChatTypePrivate, ChatTypeSecret, ChatTypeBasic
 var onlyForSecret = []ChatType{ChatTypePrivate, ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}
 
 var chatCommands = map[string]command{
-	"help":       command{0, []string{}, "help", false, nil, false},
+	"help":       command{0, []string{}, "help", false, nil},
-	"d":          command{0, []string{"n"}, "delete your last message(s)", true, nil, true},
+	"d":          command{0, []string{"n"}, "delete your last message(s)", true, nil},
-	"s":          command{1, []string{"edited message"}, "edit your last message", true, nil, true},
+	"s":          command{1, []string{"edited message"}, "edit your last message", true, nil},
-	"silent":     command{1, []string{"message"}, "send a message without sound", true, nil, true},
+	"silent":     command{1, []string{"message"}, "send a message without sound", true, nil},
-	"schedule":   command{2, []string{"{online | 2006-01-02T15:04:05 | 15:04:05}", "message"}, "schedules a message either to timestamp or to whenever the user goes online", true, nil, true},
+	"schedule":   command{2, []string{"{online | 2006-01-02T15:04:05 | 15:04:05}", "message"}, "schedules a message either to timestamp or to whenever the user goes online", true, nil},
-	"raw":        command{1, []string{"message"}, "send a raw message not interpeted as a transport command (e.g. a bot command)", true, nil, true},
+	"raw":        command{1, []string{"message"}, "send a raw message not interpeted as a transport command (e.g. a bot command)", true, nil},
-	"forward":    command{2, []string{"message_id", "target_chat"}, "forwards a message", true, nil, true},
+	"forward":    command{2, []string{"message_id", "target_chat"}, "forwards a message", true, nil},
-	"vcard":      command{0, []string{}, "print vCard as text", true, nil, true},
+	"vcard":      command{0, []string{}, "print vCard as text", true, nil},
-	"add":        command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
+	"add":        command{1, []string{"@username"}, "add @username to your chat list", true, nil},
-	"join":       command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
+	"join":       command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil},
-	"group":      command{1, []string{"title"}, "create groupchat «title» with current user", true, &notForGroups, true},
+	"group":      command{1, []string{"title"}, "create groupchat «title» with current user", true, &notForGroups},
-	"supergroup": command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
+	"supergroup": command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil},
-	"channel":    command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
+	"channel":    command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil},
-	"secret":     command{0, []string{}, "create secretchat with current user", true, &notForGroups, true},
+	"secret":     command{0, []string{}, "create secretchat with current user", true, &notForGroups},
-	"search":     command{0, []string{"string", "[limit]"}, "search <string> in current chat", true, nil, true},
+	"search":     command{0, []string{"string", "[limit]"}, "search <string> in current chat", true, nil},
-	"history":    command{0, []string{"limit"}, "get last [limit] messages from current chat", true, nil, true},
+	"history":    command{0, []string{"limit"}, "get last [limit] messages from current chat", true, nil},
-	"block":      command{0, []string{}, "blacklist current user", true, &notForGroups, true},
+	"block":      command{0, []string{}, "blacklist current user", true, &notForGroups},
-	"unblock":    command{0, []string{}, "unblacklist current user", true, &notForGroups, true},
+	"unblock":    command{0, []string{}, "unblacklist current user", true, &notForGroups},
-	"invite":     command{1, []string{"id or @username"}, "add user to current chat", true, &notForPM, true},
+	"invite":     command{1, []string{"id or @username"}, "add user to current chat", true, &notForPM},
-	"link":       command{0, []string{}, "get invite link for current chat", true, &notForPM, true},
+	"link":       command{0, []string{}, "get invite link for current chat", true, &notForPM},
-	"kick":       command{1, []string{"id or @username"}, "remove user from current chat", true, &notForPM, true},
+	"kick":       command{1, []string{"id or @username"}, "remove user from current chat", true, &notForPM},
-	"mute":       command{0, []string{"id or @username", "hours"}, "mute the whole chat or a user in current chat", true, &notForPMAndBasic, true},
+	"mute":       command{0, []string{"id or @username", "hours"}, "mute the whole chat or a user in current chat", true, &notForPMAndBasic},
-	"unmute":     command{0, []string{"id or @username"}, "unmute the whole chat or a user in the current chat", true, &notForPMAndBasic, true},
+	"unmute":     command{0, []string{"id or @username"}, "unmute the whole chat or a user in the current chat", true, &notForPMAndBasic},
-	"ban":        command{1, []string{"id or @username", "hours"}, "restrict @username from current chat for [hours] or forever", true, &notForPM, true},
+	"ban":        command{1, []string{"id or @username", "hours"}, "restrict @username from current chat for [hours] or forever", true, &notForPM},
-	"unban":      command{1, []string{"id or @username"}, "unbans @username in current chat (and devotes from admins)", true, &notForPM, true},
+	"unban":      command{1, []string{"id or @username"}, "unbans @username in current chat (and devotes from admins)", true, &notForPM},
-	"promote":    command{1, []string{"id or @username", "title"}, "promote user to admin in current chat", true, &notForPM, true},
+	"promote":    command{1, []string{"id or @username", "title"}, "promote user to admin in current chat", true, &notForPM},
-	"leave":      command{0, []string{}, "leave current chat", true, &notForPM, true},
+	"leave":      command{0, []string{}, "leave current chat", true, &notForPM},
-	"leave!":     command{0, []string{}, "leave current chat (for owners)", true, &notForPM, true},
+	"leave!":     command{0, []string{}, "leave current chat (for owners)", true, &notForPM},
-	"ttl":        command{0, []string{"seconds"}, "set secret chat messages TTL before self-destroying", true, &onlyForSecret, true},
+	"ttl":        command{0, []string{"seconds"}, "set secret chat messages TTL before self-destroying", true, &onlyForSecret},
-	"close":      command{0, []string{}, "close current secret chat", true, &onlyForSecret, true},
+	"close":      command{0, []string{}, "close current secret chat", true, &onlyForSecret},
-	"delete":     command{0, []string{}, "delete current chat from chat list", true, nil, true},
+	"delete":     command{0, []string{}, "delete current chat from chat list", true, nil},
-	"members":    command{0, []string{"query"}, "search members [by optional query] in current chat (requires admin rights)", true, nil, true},
+	"members":    command{0, []string{"query"}, "search members [by optional query] in current chat (requires admin rights)", true, nil},
 }
 
 var transportConfigurationOptions = map[string]configurationOption{
@@ -129,7 +128,6 @@ type command struct {
 	Description  string
 	LoginOnly    bool
 	NotFor       *[]ChatType
-	OnlineOnly   bool
 }
 type configurationOption struct {
 	arguments   string
@@ -144,15 +142,6 @@ const (
 	CommandTypeChat
 )
 
-// OnlineFilter is a tri-state condition for commands selection
-type OnlineFilter int
-
-const (
-	OnlineFilterOnline OnlineFilter = iota
-	OnlineFilterNotOnline
-	OnlineFilterAny
-)
-
 // GetCommands exposes the set of commands
 func GetCommands(typ CommandType) map[string]command {
 	var commandMap map[string]command
@@ -175,20 +164,14 @@ func GetCommand(typ CommandType, cmd string) (command, bool) {
 }
 
 // SortedCommandKeys sorts a slice with command keys
-func SortedCommandKeys(commandMap map[string]command, onlineFilter OnlineFilter) []string {
+func SortedCommandKeys(commandMap map[string]command) []string {
 	keys := make([]string, len(commandMap))
 
 	i := 0
 	for k := range commandMap {
-		command := commandMap[k]
-		if (onlineFilter == OnlineFilterOnline && !command.OnlineOnly) || (onlineFilter == OnlineFilterNotOnline && command.OnlineOnly) {
-			continue
-		}
-
 		keys[i] = k
 		i++
 	}
-	keys = keys[:i]
 
 	sort.Strings(keys)
 
@@ -231,32 +214,24 @@ func IsCommandForChatType(cmd command, chatType ChatType) bool {
 	return true
 }
 
-func commandsToHelpString(str *strings.Builder, chatType ChatType, onlineFilter OnlineFilter, commandMap map[string]command) {
+func (c *Client) helpString(typ CommandType, chatId int64) string {
-	for _, name := range SortedCommandKeys(commandMap, onlineFilter) {
+	var str strings.Builder
+
+	commandMap := GetCommands(typ)
+	chatType, chatTypeErr := c.GetChatType(chatId)
+
+	str.WriteString("Available commands:\n")
+	for _, name := range SortedCommandKeys(commandMap) {
 		command := commandMap[name]
-		if !IsCommandForChatType(command, chatType) {
+		if chatTypeErr == nil && !IsCommandForChatType(command, chatType) {
 			continue
 		}
 		str.WriteString(CommandToHelpString(name, command))
 		str.WriteString("\n")
 	}
-}
-
-func (c *Client) helpString(typ CommandType, chatId int64) string {
-	var str strings.Builder
-
-	commandMap := GetCommands(typ)
-	chatType, _ := c.GetChatType(chatId, true)
-
-	str.WriteString("Available commands:\n")
 
 	if typ == CommandTypeTransport {
-		commandsToHelpString(&str, chatType, OnlineFilterNotOnline, commandMap)
+		str.WriteString("Configuration options\n")
-
-		str.WriteString("\nOnline-only commands:\n")
-		commandsToHelpString(&str, chatType, OnlineFilterOnline, commandMap)
-
-		str.WriteString("\nConfiguration options\n")
 		for _, name := range persistence.ConfigKeys {
 			option := transportConfigurationOptions[name]
 			str.WriteString(name)
@@ -266,8 +241,6 @@ func (c *Client) helpString(typ CommandType, chatId int64) string {
 			str.WriteString(option.description)
 			str.WriteString("\n")
 		}
-	} else if typ == CommandTypeChat {
-		commandsToHelpString(&str, chatType, OnlineFilterAny, commandMap)
 	}
 	str.WriteString("\nYou may use ! instead of / if it conflicts with internal commands of a client")
 
@@ -306,12 +279,6 @@ func (c *Client) unsubscribe(chatID int64) error {
 	return c.sendPresence(args...)
 }
 
-func (c *Client) unsubscribeFromAll() {
-	for _, id := range c.cache.ChatsKeys() {
-		c.unsubscribe(id)
-	}
-}
-
 func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message) {
 	for i := len(messages) - 1; i >= 0; i-- {
 		message := messages[i]
@@ -362,9 +329,6 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 	if len(args) < command.RequiredArgs {
 		return notEnoughArguments, false
 	}
-	if command.OnlineOnly && !c.Online() {
-		return notOnline, false
-	}
 
 	switch cmd {
 	case "login", "code", "password":
@@ -403,20 +367,22 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 				c.authorizer.Password <- args[0]
 			}
 		}
-		return "", true
 	// sign out
 	case "logout":
+		if !c.Online() {
+			return notOnline, false
+		}
+
 		_, err := c.client.LogOut()
 		if err != nil {
 			return errors.Wrap(err, "Logout error").Error(), false
 		}
 
-		c.unsubscribeFromAll()
+		for _, id := range c.cache.ChatsKeys() {
+			c.unsubscribe(id)
+		}
 
 		c.Session.Login = ""
-	// cleanup
-	case "cleanup":
-		c.unsubscribeFromAll()
 	// cancel auth
 	case "cancelauth":
 		if c.Online() {
@@ -426,6 +392,10 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		return "Cancelled", true
 	// set @username
 	case "setusername":
+		if !c.Online() {
+			return notOnline, false
+		}
+
 		var username string
 		if len(args) > 0 {
 			username = args[0]
@@ -470,6 +440,10 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}
 	// set About
 	case "setbio":
+		if !c.Online() {
+			return notOnline, false
+		}
+
 		_, err := c.client.SetBio(&client.SetBioRequest{
 			Bio: rawCmdArguments(cmdline, 0),
 		})
@@ -478,6 +452,10 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 		}
 	// set password
 	case "setpassword":
+		if !c.Online() {
+			return notOnline, false
+		}
+
 		var oldPassword string
 		var newPassword string
 		if len(args) > 0 {
@@ -527,7 +505,7 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 
 		return strings.Join(entries, "\n"), true
 	case "report":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), false
 		}
@@ -564,6 +542,10 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) (strin
 // ProcessChatCommand executes a command sent in a mapped chat
 // and returns a response, the status of command support and the execution success result
 func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool, bool) {
+	if !c.Online() {
+		return notOnline, true, false
+	}
+
 	cmd, args := parseCommand(cmdline)
 	command, ok := chatCommands[cmd]
 	if !ok {
@@ -572,12 +554,8 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	if len(args) < command.RequiredArgs {
 		return notEnoughArguments, true, false
 	}
-	if command.OnlineOnly && !c.Online() {
-		return notOnline, true, false
-	}
 
-
+	chatType, chatTypeErr := c.GetChatType(chatID)
-	chatType, chatTypeErr := c.GetChatType(chatID, true)
 	if chatTypeErr == nil && !IsCommandForChatType(command, chatType) {
 		return "Not applicable for this chat type", true, false
 	}
@@ -621,7 +599,6 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		if err != nil {
 			return err.Error(), true, false
 		}
-		return "", true, true
 	// edit message
 	case "s":
 		if c.me == nil {
@@ -655,7 +632,6 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		} else {
 			return "Message processing error", true, false
 		}
-		return "", true, true
 	// send without sound
 	case "silent":
 		content := c.PrepareOutgoingMessageContent(rawCmdArguments(cmdline, 0))
@@ -683,7 +659,11 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 			state = &client.MessageSchedulingStateSendWhenOnline{}
 			result = due
 		} else {
-			due += c.GetTZD()
+			if c.Session.Timezone == "" {
+				due += "Z"
+			} else {
+				due += c.Session.Timezone
+			}
 
 			switch 0 {
 			default:
@@ -761,7 +741,6 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		} else {
 			return "Message processing error", true, false
 		}
-		return "", true, true
 	// forward a message to chat
 	case "forward":
 		messageId, err := strconv.ParseInt(args[0], 10, 64)
@@ -856,7 +835,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// invite @username to current groupchat
 	case "invite":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -883,7 +862,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		return link.InviteLink, true, true
 	// kick @username from current group chat
 	case "kick":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -902,7 +881,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	// mute [@username [n hours]]
 	case "mute":
 		if len(args) > 0 {
-			contact, _, err := c.GetContactByUsername(args[0], false)
+			contact, _, err := c.GetContactByUsername(args[0])
 			if err != nil {
 				return err.Error(), true, false
 			}
@@ -939,7 +918,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 	// unmute [@username]
 	case "unmute":
 		if len(args) > 0 {
-			contact, _, err := c.GetContactByUsername(args[0], false)
+			contact, _, err := c.GetContactByUsername(args[0])
 			if err != nil {
 				return err.Error(), true, false
 			}
@@ -967,7 +946,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// ban @username from current chat [for N hours]
 	case "ban":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -995,7 +974,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// unban @username
 	case "unban":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -1013,7 +992,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// promote @username to admin
 	case "promote":
-		contact, _, err := c.GetContactByUsername(args[0], false)
+		contact, _, err := c.GetContactByUsername(args[0])
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -1085,7 +1064,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 	// close secret chat
 	case "close":
-		chat, _, err := c.GetContactByID(chatID, nil, true)
+		chat, _, err := c.GetContactByID(chatID, nil)
 		if err != nil {
 			return err.Error(), true, false
 		}
@@ -1144,7 +1123,6 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 
 		c.sendMessagesReverse(chatID, messages.Messages)
-		return "", true, true
 	// get latest entries from history
 	case "history":
 		var limit int32 = 10
@@ -1181,7 +1159,6 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		}
 
 		c.sendMessagesReverse(chatID, messages)
-		return "", true, true
 	// chat members
 	case "members":
 		var query string
@@ -1211,7 +1188,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool,
 		return "", false, false
 	}
 
-	return "Success", true, true
+	return "", true, true
 }
 
 func (c *Client) cmdAdd(args []string) (string, bool) {
@@ -1227,7 +1204,7 @@ func (c *Client) cmdAdd(args []string) (string, bool) {
 
 	c.subscribeToID(chat.Id, chat)
 
-	return "Subscription sent", true
+	return "", true
 }
 
 func (c *Client) cmdJoin(args []string) (string, bool) {
@@ -1256,7 +1233,7 @@ func (c *Client) cmdJoin(args []string) (string, bool) {
 		}
 	}
 
-	return "Joined", true
+	return "", true
 }
 
 func (c *Client) cmdSupergroup(args []string, cmdline string) (string, bool) {
@@ -1268,7 +1245,7 @@ func (c *Client) cmdSupergroup(args []string, cmdline string) (string, bool) {
 		return err.Error(), false
 	}
 
-	return "Created", true
+	return "", true
 }
 
 func (c *Client) cmdChannel(args []string, cmdline string) (string, bool) {
@@ -1281,5 +1258,5 @@ func (c *Client) cmdChannel(args []string, cmdline string) (string, bool) {
 		return err.Error(), false
 	}
 
-	return "Created", true
+	return "", true
 }

telegram/connect.go

@@ -153,13 +153,11 @@ func (c *Client) Connect(resource string) error {
 	c.addResource(resource)
 
 	go func() {
-		chats, err := c.client.GetChats(&client.GetChatsRequest{
+		_, err = c.client.GetChats(&client.GetChatsRequest{
 			Limit: chatsLimit,
 		})
 		if err != nil {
 			log.Errorf("Could not retrieve chats: %v", err)
-		} else {
-			log.Infof("Obtained ≈%v chats for initialization", chats.TotalCount)
 		}
 
 		gateway.SubscribeToTransport(c.xmpp, c.jid)
@@ -231,7 +229,7 @@ func (c *Client) Disconnect(resource string, quit bool) bool {
 	log.Warn("Disconnecting from Telegram network...")
 
 	// we're offline (unsubscribe if logout)
-	for _, id := range c.cache.OwnChatsKeys() {
+	for _, id := range c.cache.ChatsKeys() {
 		args := gateway.SimplePresence(id, "unavailable")
 		c.sendPresence(args...)
 	}

telegram/handlers.go

@@ -186,13 +186,13 @@ func (c *Client) updateHandler() {
 func (c *Client) updateUser(update *client.UpdateUser) {
 	c.cache.SetUser(update.User.Id, update.User)
 	show, status, presenceType := c.userStatusToText(update.User.Status, update.User.Id)
-	go c.ProcessStatusUpdate(update.User.Id, status, show, false, gateway.SPType(presenceType))
+	go c.ProcessStatusUpdate(update.User.Id, status, show, gateway.SPType(presenceType))
 }
 
 // user status changed
 func (c *Client) updateUserStatus(update *client.UpdateUserStatus) {
 	show, status, presenceType := c.userStatusToText(update.Status, update.UserId)
-	go c.ProcessStatusUpdate(update.UserId, status, show, false, gateway.SPImmed(false), gateway.SPType(presenceType))
+	go c.ProcessStatusUpdate(update.UserId, status, show, gateway.SPImmed(false), gateway.SPType(presenceType))
 }
 
 // new chat discovered
@@ -206,14 +206,14 @@ func (c *Client) updateNewChat(update *client.UpdateNewChat) {
 			}
 		}
 
-		c.cache.SetChat(update.Chat.Id, update.Chat, true)
+		c.cache.SetChat(update.Chat.Id, update.Chat)
 
 		if update.Chat.Positions != nil && len(update.Chat.Positions) > 0 {
 			c.subscribeToID(update.Chat.Id, update.Chat)
 		}
 
 		if update.Chat.Id < 0 {
-			c.ProcessStatusUpdate(update.Chat.Id, update.Chat.Title, "chat", true)
+			c.ProcessStatusUpdate(update.Chat.Id, update.Chat.Title, "chat")
 		}
 	}()
 }
@@ -245,6 +245,8 @@ func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
 		lock.Lock()
 		defer lock.Unlock()
 
+		c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
+
 		var forceCmd bool
 		if c.LastBotCmdString != "" && update.Message.IsOutgoing {
 			if update.Message.Content.MessageContentType() == client.TypeMessageText {
@@ -281,6 +283,8 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 
 	markupFunction := c.getFormatter()
 
+	defer c.updateLastMessageHash(update.ChatId, update.MessageId, update.NewContent)
+
 	log.Debugf("newContent: %#v", update.NewContent)
 
 	lock := c.getChatMessageLock(update.ChatId)
@@ -304,7 +308,7 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 		return
 	}
 
-	if update.NewContent.MessageContentType() == client.TypeMessageText {
+	if update.NewContent.MessageContentType() == client.TypeMessageText && c.hasLastMessageHashChanged(update.ChatId, update.MessageId, update.NewContent) {
 		textContent := update.NewContent.(*client.MessageText)
 		log.Debugf("textContent: %#v", textContent.Text)
 
@@ -312,104 +316,68 @@ func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
 		sId := strconv.FormatInt(update.MessageId, 10)
 		var isCarbon bool
 
-		go func() {
+		// use XEP-0308 edits only if the last message is edited for sure, fallback otherwise
-			message, messageErr := c.client.GetMessage(&client.GetMessageRequest{
+		if c.Session.NativeEdits {
-				ChatId:    update.ChatId,
+			lastXmppId, ok := c.getLastChatMessageId(update.ChatId)
-				MessageId: update.MessageId,
+			if xmppIdErr != nil {
-			})
+				xmppId = sId
-			if messageErr != nil {
-				// odnako za vremya puti
-				// sobaka mogla podrasti
-				c.MessageIdChangesLock.Lock()
-				idsMap, idsMapOk := c.MessageIdChanges[update.ChatId]
-				hadNoId := false
-				if idsMapOk {
-					newId, newIdOk := idsMap[update.MessageId]
-					if newIdOk {
-						if newId.Id == 0 {
-							hadNoId = true
-							c.MessageIdChangesLock.Unlock()
-							newId.Lock()
-						}
-						log.Infof("falling back to updated message id: %v/%v->%v", update.ChatId, update.MessageId, newId.Id)
-						message, messageErr = c.client.GetMessage(&client.GetMessageRequest{
-							ChatId:    update.ChatId,
-							MessageId: newId.Id,
-						})
-					}
-				}
-				if !hadNoId {
-					c.MessageIdChangesLock.Unlock()
-				}
 			}
-			var prefix string
+			if ok && lastXmppId == xmppId {
-			if messageErr == nil {
+				replaceId = xmppId
-				if message.EditDate == 0 {
-					return
-				}
-				log.Debugf("editDate: %v", message.EditDate)
-
-				isCarbon = c.isCarbonsEnabled() && message.IsOutgoing
-				// reply correction support in clients is suboptimal yet, so cut them out for now
-				prefix, _ = c.messageToPrefix(message, "", "", true)
 			} else {
-				log.Errorf("No message %v/%v found, cannot reliably determine if it is a carbon and if it is edited: %v", update.ChatId, update.MessageId, messageErr.Error())
+				log.Infof("Mismatching message ids: %v %v, falling back to separate edit message", lastXmppId, xmppId)
 			}
+		}
 
-			// use XEP-0308 edits only if the last message is edited for sure, fallback otherwise
+		message, messageErr := c.client.GetMessage(&client.GetMessageRequest{
-			if c.Session.NativeEdits {
+			ChatId:    update.ChatId,
-				lastXmppId, ok := c.getLastChatMessageId(update.ChatId)
+			MessageId: update.MessageId,
-				if xmppIdErr != nil {
+		})
-					xmppId = sId
+		var prefix string
-				}
+		if messageErr == nil {
-				if ok && lastXmppId == xmppId {
+			isCarbon = c.isCarbonsEnabled() && message.IsOutgoing
-					replaceId = xmppId
+			// reply correction support in clients is suboptimal yet, so cut them out for now
-				} else {
+			prefix, _ = c.messageToPrefix(message, "", "", true)
-					log.Infof("Mismatching message ids: %v %v, falling back to separate edit message", lastXmppId, xmppId)
+		} else {
-				}
+			log.Errorf("No message %v/%v found, cannot reliably determine if it's a carbon", update.ChatId, update.MessageId)
+		}
+
+		var text strings.Builder
+
+		if replaceId == "" {
+			var editChar string
+			if c.Session.AsciiArrows {
+				editChar = "e"
+			} else {
+				editChar = "✎"
 			}
+			text.WriteString(fmt.Sprintf("%s %v | ", editChar, update.MessageId))
+		} else if prefix != "" {
+			text.WriteString(prefix)
+			text.WriteString(c.getPrefixSeparator(update.ChatId))
+		}
 
-			var text strings.Builder
+		text.WriteString(formatter.Format(
+			textContent.Text.Text,
+			textContent.Text.Entities,
+			markupFunction,
+		))
 
-			if replaceId == "" {
+		sChatId := strconv.FormatInt(update.ChatId, 10)
-				var editChar string
+		for _, jid := range jids {
-				if c.Session.AsciiArrows {
+			gateway.SendMessage(jid, sChatId, text.String(), "e"+sId, c.xmpp, nil, replaceId, isCarbon, false)
-					editChar = "e"
+		}
-				} else {
-					editChar = "✎"
-				}
-				text.WriteString(fmt.Sprintf("%s %v | ", editChar, update.MessageId))
-			} else if prefix != "" {
-				text.WriteString(prefix)
-				text.WriteString(c.getPrefixSeparator(update.ChatId))
-			}
-
-			text.WriteString(formatter.Format(
-				textContent.Text.Text,
-				textContent.Text.Entities,
-				markupFunction,
-			))
-
-			sChatId := strconv.FormatInt(update.ChatId, 10)
-			for _, jid := range jids {
-				gateway.SendMessage(jid, sChatId, text.String(), "e"+sId, c.xmpp, nil, replaceId, isCarbon, false)
-			}
-		}()
 	}
 }
 
 // message(s) deleted
 func (c *Client) updateDeleteMessages(update *client.UpdateDeleteMessages) {
 	if update.IsPermanent {
-		for _, deleteId := range update.MessageIds {
-			c.tryUnlockMessageId(update.ChatId, deleteId)
-		}
-
 		if c.Session.IsChatIgnored(update.ChatId) {
 			return
 		}
 		if c.Session.IgnoreGroupDeletions {
-			chatType, chatTypeErr := c.GetChatType(update.ChatId, false)
+			chatType, chatTypeErr := c.GetChatType(update.ChatId)
 			if chatTypeErr == nil && (chatType == ChatTypeBasicGroup || chatType == ChatTypeSupergroup) {
 				return
 			}
@@ -443,19 +411,7 @@ func (c *Client) updateMessageSendSucceeded(update *client.UpdateMessageSendSucc
 		log.Errorf("failed to replace %v with %v: %v", update.OldMessageId, update.Message.Id, err.Error())
 	}
 
-	c.MessageIdChangesLock.Lock()
+	c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
-	idsMap, ok := c.MessageIdChanges[update.Message.ChatId]
-	if !ok {
-		idsMap = make(map[int64]*newId)
-		c.MessageIdChanges[update.Message.ChatId] = idsMap
-	}
-	id, ok := idsMap[update.OldMessageId]
-	if !ok {
-		id = newNewId()
-		idsMap[update.OldMessageId] = id
-	}
-	id.Id = update.Message.Id
-	c.MessageIdChangesLock.Unlock()
 
 	c.sendMarker(update.Message.ChatId, update.Message.Id, gateway.MarkerTypeReceived)
 
@@ -466,8 +422,6 @@ func (c *Client) updateMessageSendSucceeded(update *client.UpdateMessageSendSucc
 	}
 }
 func (c *Client) updateMessageSendFailed(update *client.UpdateMessageSendFailed) {
-	c.tryUnlockMessageId(update.Message.ChatId, update.OldMessageId)
-
 	// clean uploaded files
 	file, _ := c.contentToFile(update.Message.Content)
 	if file != nil && file.Local != nil {
@@ -480,9 +434,9 @@ func (c *Client) updateChatTitle(update *client.UpdateChatTitle) {
 	gateway.SetNickname(c.jid, strconv.FormatInt(update.ChatId, 10), update.Title, c.xmpp)
 
 	// set also the status (for group chats only)
-	chat, user, _ := c.GetContactByID(update.ChatId, nil, false)
+	chat, user, _ := c.GetContactByID(update.ChatId, nil)
 	if user == nil {
-		c.ProcessStatusUpdate(update.ChatId, update.Title, "chat", false, gateway.SPImmed(true))
+		c.ProcessStatusUpdate(update.ChatId, update.Title, "chat", gateway.SPImmed(true))
 	}
 
 	// update chat title in the cache
@@ -494,15 +448,3 @@ func (c *Client) updateChatTitle(update *client.UpdateChatTitle) {
 func (c *Client) updateChatReadOutbox(update *client.UpdateChatReadOutbox) {
 	c.sendMarker(update.ChatId, update.LastReadOutboxMessageId, gateway.MarkerTypeDisplayed)
 }
-
-func (c *Client) tryUnlockMessageId(chatId, messageId int64) {
-	c.MessageIdChangesLock.Lock()
-	idsMap, ok := c.MessageIdChanges[chatId]
-	if ok {
-		id, ok := idsMap[messageId]
-		if ok {
-			id.Unlock()
-		}
-	}
-	c.MessageIdChangesLock.Unlock()
-}

telegram/utils.go

@@ -4,8 +4,10 @@ import (
 	"bytes"
 	"crypto/sha1"
 	"encoding/base64"
+	"encoding/binary"
 	"fmt"
 	"github.com/pkg/errors"
+	"hash/maphash"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -91,10 +93,8 @@ const (
 	MembersListBannedAndAdministrators
 )
 
-const AVATAR_SIZE_LIMIT int64 = 128 * 1024
-
 // GetContactByUsername resolves username to user id retrieves user and chat information
-func (c *Client) GetContactByUsername(username string, own bool) (*client.Chat, *client.User, error) {
+func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.User, error) {
 	if !c.Online() {
 		return nil, nil, errOffline
 	}
@@ -119,11 +119,11 @@ func (c *Client) GetContactByUsername(username string, own bool) (*client.Chat,
 		}
 	}
 
-	return c.GetContactByID(userID, chat, own)
+	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, own bool) (*client.Chat, *client.User, error) {
+func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *client.User, error) {
 	if !c.Online() || id == 0 {
 		return nil, nil, errOffline
 	}
@@ -158,9 +158,9 @@ func (c *Client) GetContactByID(id int64, chat *client.Chat, own bool) (*client.
 				return nil, nil, err
 			}
 
-			c.cache.SetChat(id, cacheChat, own)
+			c.cache.SetChat(id, cacheChat)
 		} else {
-			c.cache.SetChat(id, chat, own)
+			c.cache.SetChat(id, chat)
 		}
 	}
 	if chat == nil {
@@ -171,7 +171,7 @@ func (c *Client) GetContactByID(id int64, chat *client.Chat, own bool) (*client.
 }
 
 // GetChatType obtains chat type from its information
-func (c *Client) GetChatType(id int64, own bool) (ChatType, error) {
+func (c *Client) GetChatType(id int64) (ChatType, error) {
 	if !c.Online() || id == 0 {
 		return ChatTypeUnknown, errOffline
 	}
@@ -187,7 +187,7 @@ func (c *Client) GetChatType(id int64, own bool) (ChatType, error) {
 			return ChatTypeUnknown, err
 		}
 
-		c.cache.SetChat(id, chat, own)
+		c.cache.SetChat(id, chat)
 	}
 
 	chatType := chat.Type.ChatTypeType()
@@ -209,8 +209,8 @@ func (c *Client) GetChatType(id int64, own bool) (ChatType, error) {
 }
 
 // IsPM checks if a chat is PM
-func (c *Client) IsPM(id int64, own bool) (bool, error) {
+func (c *Client) IsPM(id int64) (bool, error) {
-	typ, err := c.GetChatType(id, own)
+	typ, err := c.GetChatType(id)
 	if err != nil {
 		return false, err
 	}
@@ -222,8 +222,8 @@ func (c *Client) IsPM(id int64, own bool) (bool, error) {
 }
 
 // IsBot checks if a chat is a bot
-func (c *Client) IsBot(id int64, own bool) (bool, error) {
+func (c *Client) IsBot(id int64) (bool, error) {
-	_, user, err := c.GetContactByID(id, nil, own)
+	_, user, err := c.GetContactByID(id, nil)
 	if err != nil {
 		return false, err
 	}
@@ -317,12 +317,6 @@ func (c *Client) getFileData(tgFile *client.File, typ byte) string {
 		priority = 32
 	}
 
-	// avoid not-well-formed stanza errors
-	if typ == typeFileDataBase64 && c.GetPhotoSize(tgFile) > AVATAR_SIZE_LIMIT {
-		log.Warnf("Photo %v skipped as it's too huge", tgFile.Id)
-		return ""
-	}
-
 	file, path, err := c.ForceOpenFile(tgFile, priority)
 	if err == nil {
 		defer file.Close()
@@ -365,16 +359,16 @@ func (c *Client) SetEmptyAvatarHash(chatId int64) {
 	c.AvatarHashesLock.Unlock()
 }
 
-// GetPhotoSize return at least a rough size
+// GetPhotoSha1AndSize obtains data for PEP
-func (c *Client) GetPhotoSize(photo *client.File) int64 {
+func (c *Client) GetPhotoSha1AndSize(photo *client.File, chatId int64) (string, int64) {
-	if photo == nil {
+	sha1 := c.GetPhotoSha1(photo, chatId)
-		return 0
+
-	}
 	size := photo.Size
 	if size == 0 {
 		size = photo.ExpectedSize
 	}
-	return size
+
+	return sha1, size
 }
 
 // GetPhotoSha1 computes the photo hash
@@ -395,7 +389,7 @@ func (c *Client) GetPhotoBase64(photo *client.File) string {
 }
 
 // ProcessStatusUpdate sets contact status
-func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, own bool, oldArgs ...args.V) error {
+func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, oldArgs ...args.V) error {
 	if !c.Online() {
 		return nil
 	}
@@ -404,7 +398,7 @@ func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, o
 		"chat_id": chatID,
 	}).Info("Status update for")
 
-	chat, user, err := c.GetContactByID(chatID, nil, own)
+	chat, user, err := c.GetContactByID(chatID, nil)
 	if err != nil {
 		return err
 	}
@@ -470,7 +464,7 @@ func (c *Client) FormatContact(chatID int64) string {
 		return ""
 	}
 
-	chat, user, err := c.GetContactByID(chatID, nil, false)
+	chat, user, err := c.GetContactByID(chatID, nil)
 	if err != nil {
 		return "unknown contact: " + err.Error()
 	}
@@ -1091,7 +1085,7 @@ func (c *Client) isCarbonsEnabled() bool {
 }
 
 func (c *Client) messageToPrefix(message *client.Message, previewString string, fileString string, suppressReply bool) (string, *gateway.Reply) {
-	isPM, err := c.IsPM(message.ChatId, true)
+	isPM, err := c.IsPM(message.ChatId)
 	if err != nil {
 		log.Errorf("Could not determine if chat is PM: %v", err)
 	}
@@ -1215,15 +1209,14 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
 			ChatId: chatId,
 		})
 		if err == nil {
-			c.cache.SetChat(chatId, chat, true)
+			c.cache.SetChat(chatId, chat)
-			go c.ProcessStatusUpdate(chatId, "", "", true, gateway.SPImmed(true))
+			go c.ProcessStatusUpdate(chatId, "", "", gateway.SPImmed(true))
 			text = "<Chat photo has changed>"
 
 			if chat.Photo == nil {
 				c.SetEmptyAvatarHash(chatId)
 			} else {
-				sha1 := c.GetPhotoSha1(chat.Photo.Small, chatId)
+				sha1, size := c.GetPhotoSha1AndSize(chat.Photo.Small, chatId)
-				size := c.GetPhotoSize(chat.Photo.Small)
 
 				for resource := range c.resourcesRange() {
 					features, ok := c.XmppClientFeatures[resource]
@@ -1258,7 +1251,7 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
 			var ignorePrefix bool
 			if oobSwap {
 				if text == "" || message.Content.MessageContentType() == client.TypeMessageSticker {
-					chatType, err := c.GetChatType(chatId, true)
+					chatType, err := c.GetChatType(chatId)
 					ignorePrefix = err == nil && (chatType != ChatTypeBasicGroup && chatType != ChatTypeSupergroup) && c.isCarbonsEnabled()
 				}
 			}
@@ -1273,11 +1266,7 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
 
 				if text != "" {
 					if prefix != "" {
-						separator := c.getPrefixSeparator(chatId)
+						newText.WriteString(c.getPrefixSeparator(chatId))
-						newText.WriteString(separator)
-						if reply != nil {
-							reply.End += uint64(len(separator))
-						}
 					}
 					newText.WriteString(text)
 				}
@@ -1460,9 +1449,9 @@ func (c *Client) prepareOutgoingMessageContent(text string, file *client.InputFi
 	return content
 }
 
-// OwnChatsKeys proxies the following function from unexported cache
+// ChatsKeys proxies the following function from unexported cache
-func (c *Client) OwnChatsKeys() []int64 {
+func (c *Client) ChatsKeys() []int64 {
-	return c.cache.OwnChatsKeys()
+	return c.cache.ChatsKeys()
 }
 
 // StatusesRange proxies the following function from unexported cache
@@ -1519,8 +1508,8 @@ func (c *Client) roster(resource string) {
 
 	log.Warnf("Sending roster for %v", resource)
 
-	for _, chat := range c.cache.OwnChatsKeys() {
+	for _, chat := range c.cache.ChatsKeys() {
-		c.ProcessStatusUpdate(chat, "", "", true)
+		c.ProcessStatusUpdate(chat, "", "")
 	}
 
 	c.sendPresence(gateway.SPStatus("Logged in as: " + c.Session.Login))
@@ -1634,7 +1623,7 @@ func (c *Client) subscribeToID(id int64, chat *client.Chat) {
 	args := gateway.SimplePresence(id, "subscribe")
 
 	if chat == nil {
-		chat, _, _ = c.GetContactByID(id, nil, true)
+		chat, _, _ = c.GetContactByID(id, nil)
 	}
 	if chat != nil {
 		args = append(args, gateway.SPNickname(chat.Title))
@@ -1664,7 +1653,7 @@ func (c *Client) prepareDiskSpace(size uint64) {
 
 func (c *Client) GetVcardInfo(toID int64) (VCardInfo, error) {
 	var info VCardInfo
-	chat, user, err := c.GetContactByID(toID, nil, false)
+	chat, user, err := c.GetContactByID(toID, nil)
 	if err != nil {
 		return info, err
 	}
@@ -1691,7 +1680,7 @@ func (c *Client) GetVcardInfo(toID int64) (VCardInfo, error) {
 }
 
 func (c *Client) UpdateChatNicknames() {
-	for _, id := range c.cache.OwnChatsKeys() {
+	for _, id := range c.cache.ChatsKeys() {
 		chat, ok := c.cache.GetChat(id)
 		if ok {
 			newArgs := []args.V{
@@ -1769,6 +1758,61 @@ func (c *Client) getCarbonFullJids(isOutgoing bool, ignoredResource string) []st
 	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) UpdateLastChatMessageId(chatId int64, messageId string) {
 	c.locks.lastMsgIdsLock.Lock()
 	defer c.locks.lastMsgIdsLock.Unlock()
@@ -1796,13 +1840,6 @@ func (c *Client) usernamesToString(usernames []string) string {
 	return strings.Join(atUsernames, ", ")
 }
 
-func (c *Client) GetTZD() string {
-	if c.Session.Timezone == "" {
-		return "Z"
-	}
-	return c.Session.Timezone
-}
-
 // GetChatMembers retrieves a list of chat members. "Limited" mode works only if there are no more than 20 members at all
 func (c *Client) GetChatMembers(chatID int64, limited bool, query string, membersList MembersList) ([]*client.ChatMember, error) {
 	var filters []client.ChatMembersFilter
@@ -1821,7 +1858,7 @@ func (c *Client) GetChatMembers(chatID int64, limited bool, query string, member
 	if limited {
 		limit = 20
 
-		chat, _, err := c.GetContactByID(chatID, nil, true)
+		chat, _, err := c.GetContactByID(chatID, nil)
 		if err != nil {
 			return nil, err
 		} else if chat == nil {

xmpp/component.go

@@ -39,11 +39,10 @@ var sizeRegex = regexp.MustCompile("\\A([0-9]+) ?([KMGTPE]?B?)\\z")
 
 // NewComponent starts a new component and wraps it in
 // a stream manager that you should start yourself
-func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig, idsPath string, version string) (*xmpp.StreamManager, *xmpp.Component, error) {
+func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig, idsPath string) (*xmpp.StreamManager, *xmpp.Component, error) {
 	var err error
 
 	gateway.Jid, err = stanza.NewJid(conf.Jid)
-	gateway.Version = version
 	if err != nil {
 		return nil, nil, err
 	}
@@ -142,24 +141,11 @@ func heartbeat(component *xmpp.Component) {
 						chatID,
 						session.LastSeenStatus(delayedStatus.TimestampOnline),
 						"away",
-						true,
 					)
 					delete(session.DelayedStatuses, chatID)
 				}
 			}
 			session.DelayedStatusesLock.Unlock()
-
-			// shrink message id maps
-			session.MessageIdChangesLock.Lock()
-			for _, idsMap := range session.MessageIdChanges {
-				for oldMessageId, newId := range idsMap {
-					if newId.Ts < now - 60 {
-						newId.Unlock()
-						delete(idsMap, oldMessageId)
-					}
-				}
-			}
-			session.MessageIdChangesLock.Unlock()
 		}
 		sessionLock.Unlock()
 

xmpp/extensions/extensions.go

@@ -213,20 +213,6 @@ type QueryRegisterRemove struct {
 	XMLName xml.Name `xml:"remove"`
 }
 
-// EntityTime is from XEP-0202
-type EntityTime struct {
-	XMLName   xml.Name          `xml:"urn:xmpp:time time"`
-	Tzo       string            `xml:"tzo"`
-	Utc       string            `xml:"utc"`
-	ResultSet *stanza.ResultSet `xml:"set,omitempty"`
-}
-
-// AttachTo is from XEP-0367
-type AttachTo struct {
-	XMLName xml.Name `xml:"urn:xmpp:message-attaching:1 attach-to"`
-	Id      string   `xml:"id,attr"`
-}
-
 // Namespace is a namespace!
 func (c PresenceNickExtension) Namespace() string {
 	return c.XMLName.Space
@@ -292,26 +278,11 @@ func (c QueryRegister) GetSet() *stanza.ResultSet {
 	return c.ResultSet
 }
 
-// Namespace is a namespace!
-func (c EntityTime) Namespace() string {
-	return c.XMLName.Space
-}
-
-// GetSet getsets!
-func (c EntityTime) GetSet() *stanza.ResultSet {
-	return c.ResultSet
-}
-
 // Name is a packet name
 func (ClientMessage) Name() string {
 	return "message"
 }
 
-// Namespace is a namespace!
-func (c AttachTo) Namespace() string {
-	return c.XMLName.Space
-}
-
 // NewReplyFallback initializes a fallback range
 func NewReplyFallback(start uint64, end uint64) Fallback {
 	return Fallback{
@@ -391,16 +362,4 @@ func init() {
 		"jabber:iq:register",
 		"query",
 	}, QueryRegister{})
-
-	// entity time
-	stanza.TypeRegistry.MapExtension(stanza.PKTIQ, xml.Name{
-		"urn:xmpp:time",
-		"time",
-	}, EntityTime{})
-
-	// attach-to
-	stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
-		"urn:xmpp:message-attaching:1",
-		"attach-to",
-	}, AttachTo{})
 }

xmpp/gateway/gateway.go

@@ -50,9 +50,6 @@ var QueueLock = sync.Mutex{}
 // Jid stores the component's JID object
 var Jid *stanza.Jid
 
-// Version stores this software's version
-var Version string
-
 // IdsDB provides a disk-backed bidirectional dictionary of Telegram and XMPP ids
 var IdsDB badger.IdsDB
 

xmpp/handlers.go

@@ -7,8 +7,6 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"sync"
-	"time"
 
 	"dev.narayana.im/narayana/telegabber/persistence"
 	"dev.narayana.im/narayana/telegabber/telegram"
@@ -27,10 +25,6 @@ const (
 	TypeVCard4
 )
 
-// kludge for client resuming after the transport restart (by full jids)
-var probeFired = make(map[string]bool)
-var probeFiredLock = sync.Mutex{}
-
 func logPacketType(p stanza.Packet) {
 	log.Warnf("Ignoring packet: %T\n", p)
 }
@@ -76,16 +70,6 @@ func HandleIq(s xmpp.Sender, p stanza.Packet) {
 			go handleGetQueryRegister(s, iq)
 			return
 		}
-		_, ok = iq.Payload.(*stanza.Version)
-		if ok {
-			go handleGetVersion(s, iq)
-			return
-		}
-		_, ok = iq.Payload.(*extensions.EntityTime)
-		if ok {
-			go handleGetEntityTime(s, iq)
-			return
-		}
 	} else if iq.Type == stanza.IQTypeSet {
 		query, ok := iq.Payload.(*extensions.QueryRegister)
 		if ok {
@@ -149,15 +133,12 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
 			var reply extensions.Reply
 			var fallback extensions.Fallback
 			var replace extensions.Replace
-			var attachTo extensions.AttachTo
 			msg.Get(&reply)
 			msg.Get(&fallback)
 			msg.Get(&replace)
-			msg.Get(&attachTo)
 			log.Debugf("reply: %#v", reply)
 			log.Debugf("fallback: %#v", fallback)
 			log.Debugf("replace: %#v", replace)
-			log.Debugf("attachTo: %#v", attachTo)
 
 			var replyId int64
 			var err error
@@ -233,16 +214,12 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
 					} */
 					session.AddToEditOutbox(replace.Id, resource)
 				} else {
-					messageId := msg.Id
+					err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessageId, msg.Id)
-					if attachTo.Id != "" {
-						messageId = attachTo.Id
-					}
-					err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessageId, messageId)
 					if err == nil {
 						// session.AddToOutbox(msg.Id, resource)
-						session.UpdateLastChatMessageId(toID, messageId)
+						session.UpdateLastChatMessageId(toID, msg.Id)
 					} else {
-						log.Errorf("Failed to save ids %v/%v %v", toID, tgMessageId, messageId)
+						log.Errorf("Failed to save ids %v/%v %v", toID, tgMessageId, msg.Id)
 					}
 				}
 			} else {
@@ -381,7 +358,7 @@ func handleSubscription(s xmpp.Sender, p stanza.Presence) {
 	if !ok {
 		return
 	}
-	go session.ProcessStatusUpdate(toID, "", "", true, gateway.SPImmed(false))
+	go session.ProcessStatusUpdate(toID, "", "", gateway.SPImmed(false))
 }
 
 func handlePresence(s xmpp.Sender, p stanza.Presence) {
@@ -433,32 +410,23 @@ func handlePresence(s xmpp.Sender, p stanza.Presence) {
 			if err != nil {
 				log.Error(errors.Wrap(err, "TDlib connection failure"))
 			} else {
-				var probeFiredForFrom bool
+				for status := range session.StatusesRange() {
-				probeFiredLock.Lock()
+					show, description, typ := status.Destruct()
-				_, probeFiredForFrom = probeFired[p.From]
+					newArgs := []args.V{
-				probeFired[p.From] = true
+						gateway.SPImmed(false),
-				probeFiredLock.Unlock()
-
-				if p.Type != "probe" || !probeFiredForFrom {
-					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,
-							true,
-							newArgs...,
-						)
 					}
-					probeClientFeatures(p.From, component)
+					if typ != "" {
-					session.UpdateChatNicknames()
+						newArgs = append(newArgs, gateway.SPType(typ))
+					}
+					go session.ProcessStatusUpdate(
+						status.ID,
+						description,
+						show,
+						newArgs...,
+					)
 				}
+				probeClientFeatures(p.From, component)
+				session.UpdateChatNicknames()
 			}
 		}()
 	}
@@ -567,7 +535,7 @@ func handleGetAvatarDataIq(s xmpp.Sender, iq *stanza.IQ, pubsub *stanza.PubSubGe
 	if !ok {
 		log.Info("Could not find avatar in cache, fetching immediately")
 
-		chat, _, err := session.GetContactByID(chatId, nil, true)
+		chat, _, err := session.GetContactByID(chatId, nil)
 		if err != nil || chat == nil || chat.Photo == nil {
 			return
 		}
@@ -628,7 +596,7 @@ func getTelegramChatType(from string, to string) (telegram.ChatType, error) {
 		if ok {
 			session, ok := sessions[bare]
 			if ok {
-				return session.GetChatType(toId, true)
+				return session.GetChatType(toId)
 			}
 		}
 	}
@@ -661,8 +629,6 @@ func handleGetDiscoInfo(s xmpp.Sender, iq *stanza.IQ, di *stanza.DiscoInfo) {
 			disco.AddFeatures("jabber:iq:register")
 		}
 		disco.AddFeatures(gateway.NSCommand)
-		disco.AddFeatures("jabber:iq:version")
-		disco.AddFeatures("urn:xmpp:time")
 	} else {
 		chatType, chatTypeErr := getTelegramChatType(iq.From, iq.To)
 
@@ -734,7 +700,7 @@ func handleGetDiscoItems(s xmpp.Sender, iq *stanza.IQ, di *stanza.DiscoItems) {
 				isOnline = session.Online()
 
 				if toOk {
-					isBot, err := session.IsBot(toID, true)
+					isBot, err := session.IsBot(toID)
 					if err == nil && isBot {
 						di.AddItem(iq.To, "botmenu", "Bot Menu")
 					}
@@ -747,7 +713,7 @@ func handleGetDiscoItems(s xmpp.Sender, iq *stanza.IQ, di *stanza.DiscoItems) {
 		}
 
 		commands := telegram.GetCommands(cmdType)
-		for _, name := range telegram.SortedCommandKeys(commands, telegram.OnlineFilterAny) {
+		for _, name := range telegram.SortedCommandKeys(commands) {
 			command := commands[name]
 			if chatTypeErr == nil && !telegram.IsCommandForChatType(command, chatType) {
 				continue
@@ -821,77 +787,6 @@ func handleGetQueryRegister(s xmpp.Sender, iq *stanza.IQ) {
 	}
 }
 
-func handleGetVersion(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
-	}
-
-	answer.Version().SetInfo(gateway.Jid.Resource, gateway.Version, "")
-
-	log.Debugf("%#v", answer.Payload)
-
-	_ = gateway.ResumableSend(component, answer)
-}
-
-func handleGetEntityTime(s xmpp.Sender, iq *stanza.IQ) {
-	component, ok := s.(*xmpp.Component)
-	if !ok {
-		log.Error("Not a component")
-		return
-	}
-
-	// separate declaration is crucial for passing as pointer to defer
-	var answer *stanza.IQ
-	var err error
-	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)
-
-	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
-	}
-
-	entityTime := extensions.EntityTime{
-		Tzo: session.GetTZD(),
-		Utc: time.Now().UTC().Format(time.RFC3339),
-	}
-	answer.Payload = &entityTime
-
-	log.Debugf("%#v", entityTime)
-}
-
 func handleSetQueryRegister(s xmpp.Sender, iq *stanza.IQ, query *extensions.QueryRegister) {
 	component, ok := s.(*xmpp.Component)
 	if !ok {
@@ -1469,8 +1364,8 @@ func sendPubSubAvatarNotifications(s xmpp.Sender, jid string, session *telegram.
 		return
 	}
 
-	for _, chatId := range session.OwnChatsKeys() {
+	for _, chatId := range session.ChatsKeys() {
-		chat, _, err := session.GetContactByID(chatId, nil, true)
+		chat, _, err := session.GetContactByID(chatId, nil)
 		if err != nil || chat == nil {
 			continue
 		}
@@ -1480,8 +1375,7 @@ func sendPubSubAvatarNotifications(s xmpp.Sender, jid string, session *telegram.
 			continue
 		}
 
-		sha1 := session.GetPhotoSha1(chat.Photo.Small, chat.Id)
+		sha1, size := session.GetPhotoSha1AndSize(chat.Photo.Small, chat.Id)
-		size := session.GetPhotoSize(chat.Photo.Small)
 
 		gateway.SendPubSubAvatarNotification(component, jid, chat.Id, sha1, size)
 	}