Release v1.14.0-rc1

This checks if we get a topic change < 5 seconds after connection.
If that's the case, ignore it.
Also this PR makes the topic change an actual EventTopicChange.

.golangci.yaml

@@ -132,6 +132,7 @@ linters-settings:
     # ifElseChain regexpMust singleCaseSwitch sloppyLen switchTrue typeSwitchVar underef
     # unlambda unslice rangeValCopy defaultCaseOrder];
     # all checks list: https://github.com/go-critic/checkers
+    # disabled for now - hugeParam
     enabled-checks:
       - appendAssign
       - assignOp
@@ -147,7 +148,6 @@ linters-settings:
       - dupSubExpr
       - elseif
       - emptyFallthrough
-      - hugeParam
       - ifElseChain
       - importShadow
       - indexAlloc

.travis.yml

@@ -12,7 +12,7 @@ git:
 env:
   global:
     - GOOS=linux GOARCH=amd64
-    - GOLANGCI_VERSION="v1.12.3"
+    - GOLANGCI_VERSION="v1.14.0"
 
 matrix:
   # It's ok if our code fails on unstable development versions of Go.
@@ -54,4 +54,4 @@ deploy:
   file: ci/deploy.json
   user: 42wim
   key:
-     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="
+     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="

README.md

@@ -5,7 +5,7 @@
 ![Matterbridge Logo](img/matterbridge-notext.gif)<br />
    **A simple chat bridge**<br />
    Letting people be where they want to be.<br />
-   <sub>Bridges between a growing number of protocols. Click below to demo.</sub>
+   <sub>Bridges between a growing number of protocols. Click below to demo or join the development chat.</sub>
 
    <sup>
 
@@ -15,9 +15,12 @@
       [Matrix][mb-matrix] |
       [Slack][mb-slack] |
       [Mattermost][mb-mattermost] |
+      [Rocket.Chat][mb-rocketchat] |
       [XMPP][mb-xmpp] |
       [Twitch][mb-twitch] |
+      [WhatsApp][mb-whatsapp] |
       [Zulip][mb-zulip] |
+      [Telegram][mb-telegram] |
       And more...
    </sup>
 
@@ -34,8 +37,10 @@
 
 ### Table of Contents
  * [Features](https://github.com/42wim/matterbridge/wiki/Features)
+   * [Natively supported](#natively-supported)
+   * [3rd party via matterbridge api](#3rd-party-via-matterbridge-api)
    * [API](#API)
- * [Requirements](#requirements)
+ * [Chat with us](#chat-with-us)
  * [Screenshots](https://github.com/42wim/matterbridge/wiki/)
  * [Installing](#installing)
    * [Binaries](#binaries)
@@ -61,18 +66,8 @@
 * [Private groups](https://github.com/42wim/matterbridge/wiki/Features#private-groups)
 * [API](https://github.com/42wim/matterbridge/wiki/Features#api)
 
-### API
-The API is very basic at the moment.   
-More info and examples on the [wiki](https://github.com/42wim/matterbridge/wiki/Api).
+### Natively supported
 
-Used by at least 3 projects. Feel free to make a PR to add your project to this list.
-
-* [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
-* [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
-* [Mattereddit](https://github.com/bonehurtingjuice/mattereddit) (Reddit chat support)
-
-## Requirements
-Accounts to one of the supported bridges
 * [Mattermost](https://github.com/mattermost/mattermost-server/) 4.x, 5.x
 * [IRC](http://www.mirc.com/servers.html)
 * [XMPP](https://xmpp.org)
@@ -86,21 +81,54 @@ Accounts to one of the supported bridges
 * [Steam](https://store.steampowered.com/)
 * [Twitch](https://twitch.tv)
 * [Ssh-chat](https://github.com/shazow/ssh-chat)
+* [WhatsApp](https://www.whatsapp.com/)
 * [Zulip](https://zulipchat.com)
 
+### 3rd party via matterbridge api
+* [Minecraft](https://github.com/elytra/MatterLink)
+* [Reddit](https://github.com/bonehurtingjuice/mattereddit)
+* [Facebook messenger](https://github.com/VictorNine/fbridge)
+
+### API
+The API is very basic at the moment.   
+More info and examples on the [wiki](https://github.com/42wim/matterbridge/wiki/Api).
+
+Used by the projects below. Feel free to make a PR to add your project to this list.
+
+* [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
+* [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
+* [Mattereddit](https://github.com/bonehurtingjuice/mattereddit) (Reddit chat support)
+* [fbridge](https://github.com/VictorNine/fbridge) (Facebook messenger support)
+
+## Chat with us
+
+Questions or want to test on your favorite platform? Join below:
+
+* [Gitter][mb-gitter]
+* [IRC][mb-irc]
+* [Discord][mb-discord]
+* [Matrix][mb-matrix]
+* [Slack][mb-slack]
+* [Mattermost][mb-mattermost]
+* [Rocket.Chat][mb-rocketchat]
+* [XMPP][mb-xmpp]
+* [Twitch][mb-twitch]
+* [Zulip][mb-zulip]
+* [Telegram][mb-telegram]
+
 ## Screenshots
 See https://github.com/42wim/matterbridge/wiki
 
 ## Installing
 ### Binaries
-* Latest stable release [v1.12.2](https://github.com/42wim/matterbridge/releases/latest)
+* Latest stable release [v1.13.1](https://github.com/42wim/matterbridge/releases/latest)
 * Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)
 
 ### Packages
 * [Overview](https://repology.org/metapackage/matterbridge/versions)
 
 ### Building
-Go 1.8+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH](https://golang.org/doc/code.html#GOPATH).
+Go 1.9+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH](https://golang.org/doc/code.html#GOPATH).
 
 After Go is setup, download matterbridge to your $GOPATH directory.
 
@@ -222,6 +250,7 @@ Want to tip ?
 * [matterlink](https://github.com/elytra/MatterLink)
 * [mattermost-plugin](https://github.com/matterbridge/mattermost-plugin) - Run matterbridge as a plugin in mattermost
 * [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
+* [fbridge](https://github.com/VictorNine/fbridge) (Facebook messenger support)
 
 ## Articles
 * [matterbridge on kubernetes](https://medium.freecodecamp.org/using-kubernetes-to-deploy-a-chat-gateway-or-when-technology-works-like-its-supposed-to-a169a8cd69a3)
@@ -232,6 +261,7 @@ Want to tip ?
 * https://www.algoo.fr/blog/2018/01/19/recouvrez-votre-liberte-en-quittant-slack-pour-un-mattermost-auto-heberge/
 * https://kopano.com/blog/matterbridge-bridging-mattermost-chat/
 * https://www.stitcher.com/s/?eid=52382713
+* https://daniele.tech/2019/02/how-to-use-matterbridge-to-connect-2-different-slack-workspaces/
 
 ## Thanks
 [![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
@@ -245,11 +275,14 @@ Matterbridge wouldn't exist without these libraries:
 * irc - https://github.com/lrstanley/girc
 * mattermost - https://github.com/mattermost/mattermost-server
 * matrix - https://github.com/matrix-org/gomatrix
+* sshchat - https://github.com/shazow/ssh-chat
 * slack - https://github.com/nlopes/slack
 * steam - https://github.com/Philipp15b/go-steam
 * telegram - https://github.com/go-telegram-bot-api/telegram-bot-api
 * xmpp - https://github.com/mattn/go-xmpp
+* whatsapp - https://github.com/Rhymen/go-whatsapp/
 * zulip - https://github.com/ifo/gozulipbot
+* tengo - https://github.com/d5/tengo
 
 <!-- Links -->
 
@@ -259,6 +292,9 @@ Matterbridge wouldn't exist without these libraries:
    [mb-matrix]: https://riot.im/app/#/room/#matterbridge:matrix.org
    [mb-slack]: https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA
    [mb-mattermost]: https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e
+   [mb-rocketchat]: https://open.rocket.chat/channel/matterbridge
    [mb-xmpp]: https://inverse.chat/
    [mb-twitch]: https://www.twitch.tv/matterbridge
+   [mb-whatsapp]: https://www.whatsapp.com/
    [mb-zulip]: https://matterbridge.zulipchat.com/register/
+   [mb-telegram]: https://t.me/Matterbridge

bridge/bridge.go

@@ -2,10 +2,10 @@ package bridge
 
 import (
 	"strings"
+	"sync"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/sirupsen/logrus"
-	"sync"
 )
 
 type Bridger interface {
@@ -17,6 +17,8 @@ type Bridger interface {
 
 type Bridge struct {
 	Bridger
+	*sync.RWMutex
+
 	Name           string
 	Account        string
 	Protocol       string
@@ -26,37 +28,34 @@ type Bridge struct {
 	Log            *logrus.Entry
 	Config         config.Config
 	General        *config.Protocol
-	*sync.RWMutex
 }
 
 type Config struct {
-	//	General *config.Protocol
-	Remote chan config.Message
-	Log    *logrus.Entry
 	*Bridge
+
+	Remote chan config.Message
 }
 
 // Factory is the factory function to create a bridge
 type Factory func(*Config) Bridger
 
 func New(bridge *config.Bridge) *Bridge {
-	b := &Bridge{
-		Channels: make(map[string]config.ChannelInfo),
-		RWMutex:  new(sync.RWMutex),
-		Joined:   make(map[string]bool),
-	}
 	accInfo := strings.Split(bridge.Account, ".")
 	protocol := accInfo[0]
 	name := accInfo[1]
-	b.Name = name
-	b.Protocol = protocol
-	b.Account = bridge.Account
-	return b
+
+	return &Bridge{
+		RWMutex:  new(sync.RWMutex),
+		Channels: make(map[string]config.ChannelInfo),
+		Name:     name,
+		Protocol: protocol,
+		Account:  bridge.Account,
+		Joined:   make(map[string]bool),
+	}
 }
 
 func (b *Bridge) JoinChannels() error {
-	err := b.joinChannels(b.Channels, b.Joined)
-	return err
+	return b.joinChannels(b.Channels, b.Joined)
 }
 
 // SetChannelMembers sets the newMembers to the bridge ChannelMembers

bridge/config/config.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/fsnotify/fsnotify"
-	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
 )
@@ -129,6 +128,7 @@ type Protocol struct {
 	SkipTLSVerify          bool       // IRC, mattermost
 	StripNick              bool       // all protocols
 	SyncTopic              bool       // slack
+	TengoModifyMessage     string     // general
 	Team                   string     // mattermost
 	Token                  string     // gitter, slack, discord, api
 	Topic                  string     // zulip
@@ -136,6 +136,7 @@ type Protocol struct {
 	UseAPI                 bool       // mattermost, slack
 	UseSASL                bool       // IRC
 	UseTLS                 bool       // IRC
+	UseDiscriminator       bool       // discord
 	UseFirstName           bool       // telegram
 	UseUserName            bool       // discord
 	UseInsecureURL         bool       // telegram
@@ -146,6 +147,7 @@ type Protocol struct {
 type ChannelOptions struct {
 	Key        string // irc, xmpp
 	WebhookURL string // discord
+	Topic      string // zulip
 }
 
 type Bridge struct {
@@ -184,6 +186,7 @@ type BridgeValues struct {
 	Telegram           map[string]Protocol
 	Rocketchat         map[string]Protocol
 	SSHChat            map[string]Protocol
+	WhatsApp           map[string]Protocol // TODO is this struct used? Search for "SlackLegacy" for example didn't return any results
 	Zulip              map[string]Protocol
 	General            Protocol
 	Gateway            []Gateway
@@ -200,63 +203,58 @@ type Config interface {
 }
 
 type config struct {
-	v *viper.Viper
 	sync.RWMutex
 
-	cv *BridgeValues
+	logger *logrus.Entry
+	v      *viper.Viper
+	cv     *BridgeValues
 }
 
-func NewConfig(cfgfile string) Config {
-	logrus.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false})
-	flog := logrus.WithFields(logrus.Fields{"prefix": "config"})
+// NewConfig instantiates a new configuration based on the specified configuration file path.
+func NewConfig(rootLogger *logrus.Logger, cfgfile string) Config {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "config"})
+
 	viper.SetConfigFile(cfgfile)
-	input, err := getFileContents(cfgfile)
+	input, err := ioutil.ReadFile(cfgfile)
 	if err != nil {
-		logrus.Fatal(err)
+		logger.Fatalf("Failed to read configuration file: %#v", err)
 	}
-	mycfg := newConfigFromString(input)
+
+	mycfg := newConfigFromString(logger, input)
 	if mycfg.cv.General.MediaDownloadSize == 0 {
 		mycfg.cv.General.MediaDownloadSize = 1000000
 	}
 	viper.WatchConfig()
 	viper.OnConfigChange(func(e fsnotify.Event) {
-		flog.Println("Config file changed:", e.Name)
+		logger.Println("Config file changed:", e.Name)
 	})
 	return mycfg
 }
 
-func getFileContents(filename string) ([]byte, error) {
-	input, err := ioutil.ReadFile(filename)
-	if err != nil {
-		logrus.Fatal(err)
-		return []byte(nil), err
-	}
-	return input, nil
+// NewConfigFromString instantiates a new configuration based on the specified string.
+func NewConfigFromString(rootLogger *logrus.Logger, input []byte) Config {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "config"})
+	return newConfigFromString(logger, input)
 }
 
-func NewConfigFromString(input []byte) Config {
-	return newConfigFromString(input)
-}
-
-func newConfigFromString(input []byte) *config {
+func newConfigFromString(logger *logrus.Entry, input []byte) *config {
 	viper.SetConfigType("toml")
 	viper.SetEnvPrefix("matterbridge")
-	viper.AddConfigPath(".")
 	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
 	viper.AutomaticEnv()
-	err := viper.ReadConfig(bytes.NewBuffer(input))
-	if err != nil {
-		logrus.Fatal(err)
+
+	if err := viper.ReadConfig(bytes.NewBuffer(input)); err != nil {
+		logger.Fatalf("Failed to parse the configuration: %#v", err)
 	}
 
 	cfg := &BridgeValues{}
-	err = viper.Unmarshal(cfg)
-	if err != nil {
-		logrus.Fatal(err)
+	if err := viper.Unmarshal(cfg); err != nil {
+		logger.Fatalf("Failed to load the configuration: %#v", err)
 	}
 	return &config{
-		v:  viper.GetViper(),
-		cv: cfg,
+		logger: logger,
+		v:      viper.GetViper(),
+		cv:     cfg,
 	}
 }
 
@@ -267,46 +265,44 @@ func (c *config) BridgeValues() *BridgeValues {
 func (c *config) GetBool(key string) (bool, bool) {
 	c.RLock()
 	defer c.RUnlock()
-	//	log.Debugf("getting bool %s = %#v", key, c.v.GetBool(key))
 	return c.v.GetBool(key), c.v.IsSet(key)
 }
 
 func (c *config) GetInt(key string) (int, bool) {
 	c.RLock()
 	defer c.RUnlock()
-	//	log.Debugf("getting int %s = %d", key, c.v.GetInt(key))
 	return c.v.GetInt(key), c.v.IsSet(key)
 }
 
 func (c *config) GetString(key string) (string, bool) {
 	c.RLock()
 	defer c.RUnlock()
-	//	log.Debugf("getting String %s = %s", key, c.v.GetString(key))
 	return c.v.GetString(key), c.v.IsSet(key)
 }
 
 func (c *config) GetStringSlice(key string) ([]string, bool) {
 	c.RLock()
 	defer c.RUnlock()
-	// log.Debugf("getting StringSlice %s = %#v", key, c.v.GetStringSlice(key))
 	return c.v.GetStringSlice(key), c.v.IsSet(key)
 }
 
 func (c *config) GetStringSlice2D(key string) ([][]string, bool) {
 	c.RLock()
 	defer c.RUnlock()
-	result := [][]string{}
-	if res, ok := c.v.Get(key).([]interface{}); ok {
-		for _, entry := range res {
-			result2 := []string{}
-			for _, entry2 := range entry.([]interface{}) {
-				result2 = append(result2, entry2.(string))
-			}
-			result = append(result, result2)
-		}
-		return result, true
+
+	res, ok := c.v.Get(key).([]interface{})
+	if !ok {
+		return nil, false
 	}
-	return result, false
+	var result [][]string
+	for _, entry := range res {
+		result2 := []string{}
+		for _, entry2 := range entry.([]interface{}) {
+			result2 = append(result2, entry2.(string))
+		}
+		result = append(result, result2)
+	}
+	return result, true
 }
 
 func GetIconURL(msg *Message, iconURL string) string {

bridge/discord/discord.go

@@ -75,6 +75,8 @@ func (b *Bdiscord) Connect() error {
 	b.c.AddHandler(b.memberUpdate)
 	b.c.AddHandler(b.messageUpdate)
 	b.c.AddHandler(b.messageDelete)
+	b.c.AddHandler(b.memberAdd)
+	b.c.AddHandler(b.memberRemove)
 	err = b.c.Open()
 	if err != nil {
 		return err

bridge/discord/handlers.go

@@ -71,6 +71,9 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 		rmsg.Username = b.getNick(m.Author)
 	} else {
 		rmsg.Username = m.Author.Username
+		if b.GetBool("UseDiscriminator") {
+			rmsg.Username += "#" + m.Author.Discriminator
+		}
 	}
 
 	// if we have embedded content add it to text
@@ -123,3 +126,45 @@ func (b *Bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUp
 		b.nickMemberMap[m.Member.Nick] = m.Member
 	}
 }
+
+func (b *Bdiscord) memberAdd(s *discordgo.Session, m *discordgo.GuildMemberAdd) {
+	if m.Member == nil {
+		b.Log.Warnf("Received member update with no member information: %#v", m)
+		return
+	}
+	username := m.Member.User.Username
+	if m.Member.Nick != "" {
+		username = m.Member.Nick
+	}
+
+	rmsg := config.Message{
+		Account:  b.Account,
+		Event:    config.EventJoinLeave,
+		Username: "system",
+		Text:     username + " joins",
+	}
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) memberRemove(s *discordgo.Session, m *discordgo.GuildMemberRemove) {
+	if m.Member == nil {
+		b.Log.Warnf("Received member update with no member information: %#v", m)
+		return
+	}
+	username := m.Member.User.Username
+	if m.Member.Nick != "" {
+		username = m.Member.Nick
+	}
+
+	rmsg := config.Message{
+		Account:  b.Account,
+		Event:    config.EventJoinLeave,
+		Username: "system",
+		Text:     username + " leaves",
+	}
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}

bridge/helper/helper.go

@@ -15,10 +15,12 @@ import (
 	"gitlab.com/golang-commonmark/markdown"
 )
 
+// DownloadFile downloads the given non-authenticated URL.
 func DownloadFile(url string) (*[]byte, error) {
 	return DownloadFileAuth(url, "")
 }
 
+// DownloadFileAuth downloads the given URL using the specified authentication token.
 func DownloadFileAuth(url string, auth string) (*[]byte, error) {
 	var buf bytes.Buffer
 	client := &http.Client{
@@ -42,8 +44,8 @@ func DownloadFileAuth(url string, auth string) (*[]byte, error) {
 }
 
 // GetSubLines splits messages in newline-delimited lines. If maxLineLength is
-// specified as non-zero GetSubLines will and also clip long lines to the
-// maximum length and insert a warning marker that the line was clipped.
+// specified as non-zero GetSubLines will also clip long lines to the maximum
+// length and insert a warning marker that the line was clipped.
 //
 // TODO: The current implementation has the inconvenient that it disregards
 // word boundaries when splitting but this is hard to solve without potentially
@@ -79,18 +81,24 @@ func GetSubLines(message string, maxLineLength int) []string {
 	return lines
 }
 
-// handle all the stuff we put into extra
+// HandleExtra manages the supplementary details stored inside a message's 'Extra' field map.
 func HandleExtra(msg *config.Message, general *config.Protocol) []config.Message {
 	extra := msg.Extra
 	rmsg := []config.Message{}
 	for _, f := range extra[config.EventFileFailureSize] {
 		fi := f.(config.FileInfo)
 		text := fmt.Sprintf("file %s too big to download (%#v > allowed size: %#v)", fi.Name, fi.Size, general.MediaDownloadSize)
-		rmsg = append(rmsg, config.Message{Text: text, Username: "<system> ", Channel: msg.Channel, Account: msg.Account})
+		rmsg = append(rmsg, config.Message{
+			Text:     text,
+			Username: "<system> ",
+			Channel:  msg.Channel,
+			Account:  msg.Account,
+		})
 	}
 	return rmsg
 }
 
+// GetAvatar constructs a URL for a given user-avatar if it is available in the cache.
 func GetAvatar(av map[string]string, userid string, general *config.Protocol) string {
 	if sha, ok := av[userid]; ok {
 		return general.MediaServerDownload + "/" + sha + "/" + userid + ".png"
@@ -98,13 +106,15 @@ func GetAvatar(av map[string]string, userid string, general *config.Protocol) st
 	return ""
 }
 
-func HandleDownloadSize(flog *logrus.Entry, msg *config.Message, name string, size int64, general *config.Protocol) error {
+// HandleDownloadSize checks a specified filename against the configured download blacklist
+// and checks a specified file-size against the configure limit.
+func HandleDownloadSize(logger *logrus.Entry, msg *config.Message, name string, size int64, general *config.Protocol) error {
 	// check blacklist here
 	for _, entry := range general.MediaDownloadBlackList {
 		if entry != "" {
 			re, err := regexp.Compile(entry)
 			if err != nil {
-				flog.Errorf("incorrect regexp %s for %s", entry, msg.Account)
+				logger.Errorf("incorrect regexp %s for %s", entry, msg.Account)
 				continue
 			}
 			if re.MatchString(name) {
@@ -112,43 +122,53 @@ func HandleDownloadSize(flog *logrus.Entry, msg *config.Message, name string, si
 			}
 		}
 	}
-	flog.Debugf("Trying to download %#v with size %#v", name, size)
+	logger.Debugf("Trying to download %#v with size %#v", name, size)
 	if int(size) > general.MediaDownloadSize {
 		msg.Event = config.EventFileFailureSize
-		msg.Extra[msg.Event] = append(msg.Extra[msg.Event], config.FileInfo{Name: name, Comment: msg.Text, Size: size})
+		msg.Extra[msg.Event] = append(msg.Extra[msg.Event], config.FileInfo{
+			Name:    name,
+			Comment: msg.Text,
+			Size:    size,
+		})
 		return fmt.Errorf("File %#v to large to download (%#v). MediaDownloadSize is %#v", name, size, general.MediaDownloadSize)
 	}
 	return nil
 }
 
-func HandleDownloadData(flog *logrus.Entry, msg *config.Message, name, comment, url string, data *[]byte, general *config.Protocol) {
+// HandleDownloadData adds the data for a remote file into a Matterbridge gateway message.
+func HandleDownloadData(logger *logrus.Entry, msg *config.Message, name, comment, url string, data *[]byte, general *config.Protocol) {
 	var avatar bool
-	flog.Debugf("Download OK %#v %#v", name, len(*data))
+	logger.Debugf("Download OK %#v %#v", name, len(*data))
 	if msg.Event == config.EventAvatarDownload {
 		avatar = true
 	}
-	msg.Extra["file"] = append(msg.Extra["file"], config.FileInfo{Name: name, Data: data, URL: url, Comment: comment, Avatar: avatar})
+	msg.Extra["file"] = append(msg.Extra["file"], config.FileInfo{
+		Name:    name,
+		Data:    data,
+		URL:     url,
+		Comment: comment,
+		Avatar:  avatar,
+	})
 }
 
+var emptyLineMatcher = regexp.MustCompile("\n+")
+
+// RemoveEmptyNewLines collapses consecutive newline characters into a single one and
+// trims any preceding or trailing newline characters as well.
 func RemoveEmptyNewLines(msg string) string {
-	lines := ""
-	for _, line := range strings.Split(msg, "\n") {
-		if line != "" {
-			lines += line + "\n"
-		}
-	}
-	lines = strings.TrimRight(lines, "\n")
-	return lines
+	return emptyLineMatcher.ReplaceAllString(strings.Trim(msg, "\n"), "\n")
 }
 
+// ClipMessage trims a message to the specified length if it exceeds it and adds a warning
+// to the message in case it does so.
 func ClipMessage(text string, length int) string {
-	// clip too long messages
+	const clippingMessage = " <clipped message>"
 	if len(text) > length {
-		text = text[:length-len(" *message clipped*")]
+		text = text[:length-len(clippingMessage)]
 		if r, size := utf8.DecodeLastRuneInString(text); r == utf8.RuneError {
 			text = text[:len(text)-size]
 		}
-		text += " *message clipped*"
+		text += clippingMessage
 	}
 	return text
 }

bridge/irc/handlers.go

@@ -81,7 +81,7 @@ func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
 		return
 	}
 	if event.Command == "QUIT" {
-		if event.Source.Name == b.Nick && strings.Contains(event.Trailing, "Ping timeout") {
+		if event.Source.Name == b.Nick && strings.Contains(event.Last(), "Ping timeout") {
 			b.Log.Infof("%s reconnecting ..", b.Account)
 			b.Remote <- config.Message{Username: "system", Text: "reconnect", Channel: channel, Account: b.Account, Event: config.EventFailure}
 			return
@@ -92,6 +92,10 @@ func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
 			return
 		}
 		b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
+		// QUIT isn't channel bound, happens for all channels on the bridge
+		if event.Command == "QUIT" {
+			channel = ""
+		}
 		msg := config.Message{Username: "system", Text: event.Source.Name + " " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
 		b.Log.Debugf("<= Message is %#v", msg)
 		b.Remote <- msg
@@ -164,7 +168,7 @@ func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
 		return
 	}
 	rmsg := config.Message{Username: event.Source.Name, Channel: strings.ToLower(event.Params[0]), Account: b.Account, UserID: event.Source.Ident + "@" + event.Source.Host}
-	b.Log.Debugf("== Receiving PRIVMSG: %s %s %#v", event.Source.Name, event.Trailing, event)
+	b.Log.Debugf("== Receiving PRIVMSG: %s %s %#v", event.Source.Name, event.Last(), event)
 
 	// set action event
 	if event.IsAction() {

bridge/irc/irc.go

@@ -295,7 +295,7 @@ func (b *Birc) storeNames(client *girc.Client, event girc.Event) {
 	channel := event.Params[2]
 	b.names[channel] = append(
 		b.names[channel],
-		strings.Split(strings.TrimSpace(event.Trailing), " ")...)
+		strings.Split(strings.TrimSpace(event.Last()), " ")...)
 }
 
 func (b *Birc) formatnicks(nicks []string) string {

bridge/matrix/matrix.go

@@ -20,11 +20,13 @@ type Bmatrix struct {
 	UserID  string
 	RoomMap map[string]string
 	sync.RWMutex
+	htmlTag *regexp.Regexp
 	*bridge.Config
 }
 
 func New(cfg *bridge.Config) bridge.Bridger {
 	b := &Bmatrix{Config: cfg}
+	b.htmlTag = regexp.MustCompile("</.*?>")
 	b.RoomMap = make(map[string]string)
 	return b
 }
@@ -113,8 +115,22 @@ func (b *Bmatrix) Send(msg config.Message) (string, error) {
 	// Edit message if we have an ID
 	// matrix has no editing support
 
+	// Use notices to send join/leave events
+	if msg.Event == config.EventJoinLeave {
+		resp, err := b.mc.SendNotice(channel, msg.Username+msg.Text)
+		if err != nil {
+			return "", err
+		}
+		return resp.EventID, err
+	}
+
+	username := html.EscapeString(msg.Username)
+	// check if we have a </tag>. if we have, we don't escape HTML. #696
+	if b.htmlTag.MatchString(msg.Username) {
+		username = msg.Username
+	}
 	// Post normal message with HTML support (eg riot.im)
-	resp, err := b.mc.SendHTML(channel, msg.Username+msg.Text, html.EscapeString(msg.Username)+helper.ParseMarkdown(msg.Text))
+	resp, err := b.mc.SendHTML(channel, msg.Username+msg.Text, username+helper.ParseMarkdown(msg.Text))
 	if err != nil {
 		return "", err
 	}
@@ -283,6 +299,12 @@ func (b *Bmatrix) handleUploadFile(msg *config.Message, channel string, fi *conf
 		if err != nil {
 			b.Log.Errorf("file comment failed: %#v", err)
 		}
+	} else {
+		// image and video uploads send no username, we have to do this ourself here #715
+		_, err := b.mc.SendText(channel, msg.Username)
+		if err != nil {
+			b.Log.Errorf("file comment failed: %#v", err)
+		}
 	}
 	b.Log.Debugf("uploading file: %s %s", fi.Name, mtype)
 	res, err := b.mc.UploadToContentRepo(content, mtype, int64(len(*fi.Data)))

bridge/rocketchat/handlers.go

@@ -0,0 +1,69 @@
+package brocketchat
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+)
+
+func (b *Brocketchat) handleRocket() {
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleRocketHook(messages)
+	} else {
+		b.Log.Debugf("Choosing login/password based receiving")
+		go b.handleRocketClient(messages)
+	}
+	for message := range messages {
+		message.Account = b.Account
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
+		b.Log.Debugf("<= Message is %#v", message)
+		b.Remote <- *message
+	}
+}
+
+func (b *Brocketchat) handleRocketHook(messages chan *config.Message) {
+	for {
+		message := b.rh.Receive()
+		b.Log.Debugf("Receiving from rockethook %#v", message)
+		// do not loop
+		if message.UserName == b.GetString("Nick") {
+			continue
+		}
+		messages <- &config.Message{
+			UserID:   message.UserID,
+			Username: message.UserName,
+			Text:     message.Text,
+			Channel:  message.ChannelName,
+		}
+	}
+}
+
+func (b *Brocketchat) handleRocketClient(messages chan *config.Message) {
+	for message := range b.messageChan {
+		b.Log.Debugf("message %#v", message)
+		m := message
+		if b.skipMessage(&m) {
+			b.Log.Debugf("Skipped message: %#v", message)
+			continue
+		}
+
+		rmsg := &config.Message{Text: message.Msg,
+			Username: message.User.UserName,
+			Channel:  b.getChannelName(message.RoomID),
+			Account:  b.Account,
+			UserID:   message.User.ID,
+			ID:       message.ID,
+		}
+		messages <- rmsg
+	}
+}
+
+func (b *Brocketchat) handleUploadFile(msg *config.Message) error {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if err := b.uploadFile(&fi, b.getChannelID(msg.Channel)); err != nil {
+			return err
+		}
+	}
+	return nil
+}

bridge/rocketchat/helpers.go

@@ -0,0 +1,198 @@
+package brocketchat
+
+import (
+	"context"
+	"io/ioutil"
+	"mime"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/hook/rockethook"
+	"github.com/42wim/matterbridge/matterhook"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/models"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/realtime"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/rest"
+	"github.com/nelsonken/gomf"
+)
+
+func (b *Brocketchat) doConnectWebhookBind() error {
+	switch {
+	case b.GetString("WebhookURL") != "":
+		b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
+		b.mh = matterhook.New(b.GetString("WebhookURL"),
+			matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+				DisableServer: true})
+		b.rh = rockethook.New(b.GetString("WebhookURL"), rockethook.Config{BindAddress: b.GetString("WebhookBindAddress")})
+	case b.GetString("Login") != "":
+		b.Log.Info("Connecting using login/password (sending)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+	default:
+		b.Log.Info("Connecting using webhookbindaddress (receiving)")
+		b.rh = rockethook.New(b.GetString("WebhookURL"), rockethook.Config{BindAddress: b.GetString("WebhookBindAddress")})
+	}
+	return nil
+}
+
+func (b *Brocketchat) doConnectWebhookURL() error {
+	b.Log.Info("Connecting using webhookurl (sending)")
+	b.mh = matterhook.New(b.GetString("WebhookURL"),
+		matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+			DisableServer: true})
+	if b.GetString("Login") != "" {
+		b.Log.Info("Connecting using login/password (receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (b *Brocketchat) apiLogin() error {
+	b.Log.Debugf("handling apiLogin()")
+	credentials := &models.UserCredentials{Email: b.GetString("login"), Password: b.GetString("password")}
+	myURL, err := url.Parse(b.GetString("server"))
+	if err != nil {
+		return err
+	}
+	client, err := realtime.NewClient(myURL, b.GetBool("debug"))
+	b.c = client
+	if err != nil {
+		return err
+	}
+	restclient := rest.NewClient(myURL, b.GetBool("debug"))
+	user, err := b.c.Login(credentials)
+	if err != nil {
+		return err
+	}
+	b.user = user
+	b.r = restclient
+	err = b.r.Login(credentials)
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	return nil
+}
+
+func (b *Brocketchat) getChannelName(id string) string {
+	b.RLock()
+	defer b.RUnlock()
+	if name, ok := b.channelMap[id]; ok {
+		return name
+	}
+	return ""
+}
+
+func (b *Brocketchat) getChannelID(name string) string {
+	b.RLock()
+	defer b.RUnlock()
+	for k, v := range b.channelMap {
+		if v == name {
+			return k
+		}
+	}
+	return ""
+}
+
+func (b *Brocketchat) skipMessage(message *models.Message) bool {
+	return message.User.ID == b.user.ID
+}
+
+func (b *Brocketchat) uploadFile(fi *config.FileInfo, channel string) error {
+	fb := gomf.New()
+	if err := fb.WriteField("description", fi.Comment); err != nil {
+		return err
+	}
+	sp := strings.Split(fi.Name, ".")
+	mtype := mime.TypeByExtension("." + sp[len(sp)-1])
+	if !strings.Contains(mtype, "image") && !strings.Contains(mtype, "video") {
+		return nil
+	}
+	if err := fb.WriteFile("file", fi.Name, mtype, *fi.Data); err != nil {
+		return err
+	}
+	req, err := fb.GetHTTPRequest(context.TODO(), b.GetString("server")+"/api/v1/rooms.upload/"+channel)
+	if err != nil {
+		return err
+	}
+	req.Header.Add("X-Auth-Token", b.user.Token)
+	req.Header.Add("X-User-Id", b.user.ID)
+	client := &http.Client{
+		Timeout: time.Second * 5,
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		b.Log.Errorf("failed: %#v", string(body))
+	}
+	return nil
+}
+
+// sendWebhook uses the configured WebhookURL to send the message
+func (b *Brocketchat) sendWebhook(msg *config.Message) error {
+	// skip events
+	if msg.Event != "" {
+		return nil
+	}
+
+	if b.GetBool("PrefixMessagesWithNick") {
+		msg.Text = msg.Username + msg.Text
+	}
+	if msg.Extra != nil {
+		// this sends a message only if we received a config.EVENT_FILE_FAILURE_SIZE
+		for _, rmsg := range helper.HandleExtra(msg, b.General) {
+			rmsg := rmsg // scopelint
+			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
+			matterMessage := matterhook.OMessage{
+				IconURL:  iconURL,
+				Channel:  rmsg.Channel,
+				UserName: rmsg.Username,
+				Text:     rmsg.Text,
+				Props:    make(map[string]interface{}),
+			}
+			if err := b.mh.Send(matterMessage); err != nil {
+				b.Log.Errorf("sendWebhook failed: %s ", err)
+			}
+		}
+
+		// webhook doesn't support file uploads, so we add the url manually
+		if len(msg.Extra["file"]) > 0 {
+			for _, f := range msg.Extra["file"] {
+				fi := f.(config.FileInfo)
+				if fi.URL != "" {
+					msg.Text += fi.URL
+				}
+			}
+		}
+	}
+	iconURL := config.GetIconURL(msg, b.GetString("iconurl"))
+	matterMessage := matterhook.OMessage{
+		IconURL:  iconURL,
+		Channel:  msg.Channel,
+		UserName: msg.Username,
+		Text:     msg.Text,
+	}
+	if msg.Avatar != "" {
+		matterMessage.IconURL = msg.Avatar
+	}
+	err := b.mh.Send(matterMessage)
+	if err != nil {
+		b.Log.Info(err)
+		return err
+	}
+	return nil
+}

bridge/rocketchat/rocketchat.go

@@ -1,21 +1,37 @@
 package brocketchat
 
 import (
+	"errors"
+	"sync"
+
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/42wim/matterbridge/hook/rockethook"
 	"github.com/42wim/matterbridge/matterhook"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/models"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/realtime"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/rest"
 )
 
 type Brocketchat struct {
 	mh *matterhook.Client
 	rh *rockethook.Client
+	c  *realtime.Client
+	r  *rest.Client
 	*bridge.Config
+	messageChan chan models.Message
+	channelMap  map[string]string
+	user        *models.User
+	sync.RWMutex
 }
 
 func New(cfg *bridge.Config) bridge.Bridger {
-	return &Brocketchat{Config: cfg}
+	b := &Brocketchat{Config: cfg}
+	b.messageChan = make(chan models.Message)
+	b.channelMap = make(map[string]string)
+	b.Log.Debugf("enabling rocketchat")
+	return b
 }
 
 func (b *Brocketchat) Command(cmd string) string {
@@ -23,70 +39,118 @@ func (b *Brocketchat) Command(cmd string) string {
 }
 
 func (b *Brocketchat) Connect() error {
-	b.Log.Info("Connecting webhooks")
-	b.mh = matterhook.New(b.GetString("WebhookURL"),
-		matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-			DisableServer: true})
-	b.rh = rockethook.New(b.GetString("WebhookURL"), rockethook.Config{BindAddress: b.GetString("WebhookBindAddress")})
-	go b.handleRocketHook()
+	if b.GetString("WebhookBindAddress") != "" {
+		if err := b.doConnectWebhookBind(); err != nil {
+			return err
+		}
+		go b.handleRocket()
+		return nil
+	}
+	switch {
+	case b.GetString("WebhookURL") != "":
+		if err := b.doConnectWebhookURL(); err != nil {
+			return err
+		}
+		go b.handleRocket()
+		return nil
+	case b.GetString("Login") != "":
+		b.Log.Info("Connecting using login/password (sending and receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+		go b.handleRocket()
+	}
+	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" &&
+		b.GetString("Login") == "" {
+		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Login/Password/Server configured")
+	}
 	return nil
 }
 
 func (b *Brocketchat) Disconnect() error {
 	return nil
-
 }
 
 func (b *Brocketchat) JoinChannel(channel config.ChannelInfo) error {
+	if b.c == nil {
+		return nil
+	}
+	id, err := b.c.GetChannelId(channel.Name)
+	if err != nil {
+		return err
+	}
+	b.Lock()
+	b.channelMap[id] = channel.Name
+	b.Unlock()
+	mychannel := &models.Channel{ID: id, Name: channel.Name}
+	if err := b.c.JoinChannel(id); err != nil {
+		return err
+	}
+	if err := b.c.SubscribeToMessageStream(mychannel, b.messageChan); err != nil {
+		return err
+	}
 	return nil
 }
 
 func (b *Brocketchat) Send(msg config.Message) (string, error) {
-	// ignore delete messages
+	channel := &models.Channel{ID: b.getChannelID(msg.Channel), Name: msg.Channel}
+
+	// Delete message
 	if msg.Event == config.EventMsgDelete {
-		return "", nil
+		if msg.ID == "" {
+			return "", nil
+		}
+		return msg.ID, b.c.DeleteMessage(&models.Message{ID: msg.ID})
 	}
-	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return "", b.sendWebhook(&msg)
+	}
+
+	// Prepend nick if configured
+	if b.GetBool("PrefixMessagesWithNick") {
+		msg.Text = msg.Username + msg.Text
+	}
+
+	// Edit message if we have an ID
+	if msg.ID != "" {
+		return msg.ID, b.c.EditMessage(&models.Message{ID: msg.ID, Msg: msg.Text, RoomID: b.getChannelID(msg.Channel)})
+	}
+
+	// Upload a file if it exists
 	if msg.Extra != nil {
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			rmsg := rmsg // scopelint
-			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
-			matterMessage := matterhook.OMessage{IconURL: iconURL, Channel: rmsg.Channel, UserName: rmsg.Username, Text: rmsg.Text}
-			b.mh.Send(matterMessage)
-		}
-		if len(msg.Extra["file"]) > 0 {
-			for _, f := range msg.Extra["file"] {
-				fi := f.(config.FileInfo)
-				if fi.URL != "" {
-					msg.Text += fi.URL
-				}
+			smsg := &models.Message{
+				RoomID: b.getChannelID(rmsg.Channel),
+				Msg:    rmsg.Username + rmsg.Text,
+				PostMessage: models.PostMessage{
+					Avatar: rmsg.Avatar,
+					Alias:  rmsg.Username,
+				},
+			}
+			if _, err := b.c.SendMessage(smsg); err != nil {
+				b.Log.Errorf("SendMessage failed: %s", err)
 			}
 		}
+		if len(msg.Extra["file"]) > 0 {
+			return "", b.handleUploadFile(&msg)
+		}
 	}
 
-	iconURL := config.GetIconURL(&msg, b.GetString("iconurl"))
-	matterMessage := matterhook.OMessage{IconURL: iconURL}
-	matterMessage.Channel = msg.Channel
-	matterMessage.UserName = msg.Username
-	matterMessage.Type = ""
-	matterMessage.Text = msg.Text
-	err := b.mh.Send(matterMessage)
-	if err != nil {
-		b.Log.Info(err)
+	smsg := &models.Message{
+		RoomID: channel.ID,
+		Msg:    msg.Text,
+		PostMessage: models.PostMessage{
+			Avatar: msg.Avatar,
+			Alias:  msg.Username,
+		},
+	}
+
+	rmsg, err := b.c.SendMessage(smsg)
+	if rmsg == nil {
 		return "", err
 	}
-	return "", nil
-}
-
-func (b *Brocketchat) handleRocketHook() {
-	for {
-		message := b.rh.Receive()
-		b.Log.Debugf("Receiving from rockethook %#v", message)
-		// do not loop
-		if message.UserName == b.GetString("Nick") {
-			continue
-		}
-		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.UserName, b.Account)
-		b.Remote <- config.Message{Text: message.Text, Username: message.UserName, Channel: message.ChannelName, Account: b.Account, UserID: message.UserID}
-	}
+	return rmsg.ID, err
 }

bridge/slack/handlers.go

@@ -192,6 +192,9 @@ func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, er
 			// This is probably a webhook we couldn't resolve.
 			return nil, fmt.Errorf("message handling resulted in an empty bot message (probably an incoming webhook we couldn't resolve): %#v", ev)
 		}
+		if ev.SubMessage != nil {
+			return nil, fmt.Errorf("message handling resulted in an empty message: %#v with submessage %#v", ev, ev.SubMessage)
+		}
 		return nil, fmt.Errorf("message handling resulted in an empty message: %#v", ev)
 	}
 	return rmsg, nil

bridge/slack/helpers.go

@@ -254,6 +254,13 @@ func (b *Bslack) populateReceivedMessage(ev *slack.MessageEvent) (*config.Messag
 		}
 	}
 
+	// For edits, only submessage has thread ts.
+	// Ensures edits to threaded messages maintain their prefix hint on the
+	// unthreaded end.
+	if ev.SubMessage != nil {
+		rmsg.ParentID = ev.SubMessage.ThreadTimestamp
+	}
+
 	if err = b.populateMessageWithUserInfo(ev, rmsg); err != nil {
 		return nil, err
 	}

bridge/slack/helpers_test.go

@@ -25,7 +25,7 @@ func TestExtractTopicOrPurpose(t *testing.T) {
 
 	logger := logrus.New()
 	logger.SetOutput(ioutil.Discard)
-	cfg := &bridge.Config{Log: logger.WithFields(nil)}
+	cfg := &bridge.Config{Bridge: &bridge.Bridge{Log: logrus.NewEntry(logger)}}
 	b := newBridge(cfg)
 	for name, tc := range testcases {
 		gotChangeType, gotOutput := b.extractTopicOrPurpose(tc.input)

bridge/slack/slack.go

@@ -121,7 +121,7 @@ func (b *Bslack) Connect() error {
 	// If we have a token we use the Slack websocket-based RTM for both sending and receiving.
 	if token := b.GetString(tokenConfig); token != "" {
 		b.Log.Info("Connecting using token")
-		b.sc = slack.New(token)
+		b.sc = slack.New(token, slack.OptionDebug(b.GetBool("Debug")))
 		b.rtm = b.sc.NewRTM()
 		go b.rtm.ManageConnection()
 		go b.handleSlack()
@@ -293,6 +293,12 @@ func (b *Bslack) sendRTM(msg config.Message) (string, error) {
 		return "", err
 	}
 
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentID == "msg-parent-not-found" {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
+	}
+
 	// Handle message deletions.
 	if handled, err = b.deleteMessage(&msg, channelInfo); handled {
 		return msg.ID, err

bridge/sshchat/sshchat.go

@@ -9,7 +9,6 @@ import (
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/shazow/ssh-chat/sshd"
-	"github.com/sirupsen/logrus"
 )
 
 type Bsshchat struct {
@@ -134,7 +133,7 @@ func (b *Bsshchat) handleSSHChat() error {
 			res := strings.Split(stripPrompt(b.r.Text()), ":")
 			if res[0] == "-> Set theme" {
 				wait = false
-				logrus.Debugf("mono found, allowing")
+				b.Log.Debugf("mono found, allowing")
 				continue
 			}
 			if !wait {

bridge/whatsapp/handlers.go

@@ -0,0 +1,104 @@
+package bwhatsapp
+
+import (
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+
+	"github.com/Rhymen/go-whatsapp"
+
+	whatsappExt "maunium.net/go/mautrix-whatsapp/whatsapp-ext"
+)
+
+/*
+Implement handling messages coming from WhatsApp
+Check:
+- https://github.com/Rhymen/go-whatsapp#add-message-handlers
+- https://github.com/Rhymen/go-whatsapp/blob/master/handler.go
+- https://github.com/tulir/mautrix-whatsapp/tree/master/whatsapp-ext for more advanced command handling
+*/
+
+// HandleError received from WhatsApp
+func (b *Bwhatsapp) HandleError(err error) {
+	b.Log.Errorf("%v", err) // TODO implement proper handling? at least respond to different error types
+}
+
+// HandleTextMessage sent from WhatsApp, relay it to the brige
+func (b *Bwhatsapp) HandleTextMessage(message whatsapp.TextMessage) {
+	if message.Info.FromMe { // || !strings.Contains(strings.ToLower(message.Text), "@echo") {
+		return
+	}
+	// whatsapp sends last messages to show context , cut them
+	if message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	messageTime := time.Unix(int64(message.Info.Timestamp), 0) // TODO check how behaves between timezones
+	groupJid := message.Info.RemoteJid
+
+	senderJid := message.Info.SenderJid
+	if len(senderJid) == 0 {
+		// TODO workaround till https://github.com/Rhymen/go-whatsapp/issues/86 resolved
+		senderJid = *message.Info.Source.Participant
+	}
+
+	// translate sender's Jid to the nicest username we can get
+	senderName := b.getSenderName(senderJid)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	extText := message.Info.Source.Message.ExtendedTextMessage
+	if extText != nil && extText.ContextInfo != nil && extText.ContextInfo.MentionedJid != nil {
+		// handle user mentions
+		for _, mentionedJid := range extText.ContextInfo.MentionedJid {
+			numberAndSuffix := strings.SplitN(mentionedJid, "@", 2)
+
+			// mentions comes as telephone numbers and we don't want to expose it to other bridges
+			// replace it with something more meaninful to others
+			mention := b.getSenderNotify(numberAndSuffix[0] + whatsappExt.NewUserSuffix)
+			if mention == "" {
+				mention = "someone"
+			}
+			message.Text = strings.Replace(message.Text, "@"+numberAndSuffix[0], "@"+mention, 1)
+		}
+	}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJid, b.Account)
+	rmsg := config.Message{
+		UserID:    senderJid,
+		Username:  senderName,
+		Text:      message.Text,
+		Timestamp: messageTime,
+		Channel:   groupJid,
+		Account:   b.Account,
+		Protocol:  b.Protocol,
+		Extra:     make(map[string][]interface{}),
+		//		ParentID: TODO, // TODO handle thread replies  // map from Info.QuotedMessageID string
+		//	Event     string    `json:"event"`
+		//	Gateway   string  // will be added during message processing
+		ID: message.Info.Id}
+
+	if avatarURL, exists := b.userAvatars[senderJid]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+//
+//func (b *Bwhatsapp) HandleImageMessage(message whatsapp.ImageMessage) {
+//	fmt.Println(message) // TODO implement
+//}
+//
+//func (b *Bwhatsapp) HandleVideoMessage(message whatsapp.VideoMessage) {
+//	fmt.Println(message) // TODO implement
+//}
+//
+//func (b *Bwhatsapp) HandleJsonMessage(message string) {
+//	fmt.Println(message) // TODO implement
+//}
+// TODO HandleRawMessage
+// TODO HandleAudioMessage

bridge/whatsapp/helpers.go

@@ -0,0 +1,84 @@
+package bwhatsapp
+
+import (
+	"encoding/gob"
+	"errors"
+	"os"
+
+	qrcodeTerminal "github.com/Baozisoftware/qrcode-terminal-go"
+	"github.com/Rhymen/go-whatsapp"
+)
+
+func qrFromTerminal(invert bool) chan string {
+	qr := make(chan string)
+	go func() {
+		terminal := qrcodeTerminal.New()
+		if invert {
+			terminal = qrcodeTerminal.New2(qrcodeTerminal.ConsoleColors.BrightWhite, qrcodeTerminal.ConsoleColors.BrightBlack, qrcodeTerminal.QRCodeRecoveryLevels.Medium)
+		}
+
+		terminal.Get(<-qr).Print()
+	}()
+
+	return qr
+}
+
+func (b *Bwhatsapp) readSession() (whatsapp.Session, error) {
+	session := whatsapp.Session{}
+	sessionFile := b.Config.GetString(sessionFile)
+
+	if sessionFile == "" {
+		return session, errors.New("if you won't set SessionFile then you will need to scan QR code on every restart")
+	}
+
+	file, err := os.Open(sessionFile)
+	if err != nil {
+		return session, err
+	}
+	defer file.Close()
+	decoder := gob.NewDecoder(file)
+	err = decoder.Decode(&session)
+	if err != nil {
+		return session, err
+	}
+	return session, nil
+}
+
+func (b *Bwhatsapp) writeSession(session whatsapp.Session) error {
+	sessionFile := b.Config.GetString(sessionFile)
+
+	if sessionFile == "" {
+		// we already sent a warning while starting the bridge, so let's be quiet here
+		return nil
+	}
+
+	file, err := os.Create(sessionFile)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	encoder := gob.NewEncoder(file)
+	err = encoder.Encode(session)
+
+	return err
+}
+
+func (b *Bwhatsapp) getSenderName(senderJid string) string {
+	if sender, exists := b.users[senderJid]; exists {
+		if sender.Name != "" {
+			return sender.Name
+		}
+		// if user is not in phone contacts
+		// it is the most obvious scenario unless you sync your phone contacts with some remote updated source
+		// users can change it in their WhatsApp settings -> profile -> click on Avatar
+		return sender.Notify
+	}
+	return ""
+}
+
+func (b *Bwhatsapp) getSenderNotify(senderJid string) string {
+	if sender, exists := b.users[senderJid]; exists {
+		return sender.Notify
+	}
+	return ""
+}

bridge/whatsapp/whatsapp.go

@@ -0,0 +1,305 @@
+package bwhatsapp
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+
+	"github.com/Rhymen/go-whatsapp"
+
+	whatsappExt "maunium.net/go/mautrix-whatsapp/whatsapp-ext"
+)
+
+const (
+	// Account config parameters
+	cfgNumber         = "Number"
+	qrOnWhiteTerminal = "QrOnWhiteTerminal"
+	sessionFile       = "SessionFile"
+)
+
+// Bwhatsapp Bridge structure keeping all the information needed for relying
+type Bwhatsapp struct {
+	*bridge.Config
+
+	// https://github.com/Rhymen/go-whatsapp/blob/c31092027237441cffba1b9cb148eadf7c83c3d2/session.go#L18-L21
+	session *whatsapp.Session
+	conn    *whatsapp.Conn
+	// https://github.com/tulir/mautrix-whatsapp/blob/master/whatsapp-ext/whatsapp.go
+	connExt   *whatsappExt.ExtendedConn
+	startedAt uint64
+
+	users       map[string]whatsapp.Contact
+	userAvatars map[string]string
+}
+
+// New Create a new WhatsApp bridge. This will be called for each [whatsapp.<server>] entry you have in the config file
+func New(cfg *bridge.Config) bridge.Bridger {
+	number := cfg.GetString(cfgNumber)
+	if number == "" {
+		cfg.Log.Fatalf("Missing configuration for WhatsApp bridge: Number")
+	}
+
+	b := &Bwhatsapp{
+		Config: cfg,
+
+		users:       make(map[string]whatsapp.Contact),
+		userAvatars: make(map[string]string),
+	}
+	return b
+}
+
+// Connect to WhatsApp. Required implementation of the Bridger interface
+// https://github.com/42wim/matterbridge/blob/2cfd880cdb0df29771bf8f31df8d990ab897889d/bridge/bridge.go#L11-L16
+func (b *Bwhatsapp) Connect() error {
+	b.RLock() // TODO do we need locking for Whatsapp?
+	defer b.RUnlock()
+
+	number := b.GetString(cfgNumber)
+	if number == "" {
+		return errors.New("WhatsApp's telephone Number need to be configured")
+	}
+
+	// https://github.com/Rhymen/go-whatsapp#creating-a-connection
+	b.Log.Debugln("Connecting to WhatsApp..")
+	conn, err := whatsapp.NewConn(20 * time.Second)
+	if err != nil {
+		return errors.New("failed to connect to WhatsApp: " + err.Error())
+	}
+
+	b.conn = conn
+	b.connExt = whatsappExt.ExtendConn(b.conn)
+	// TODO do we want to use it? b.connExt.SetClientName("Matterbridge WhatsApp bridge", "mb-wa")
+
+	b.conn.AddHandler(b)
+	b.Log.Debugln("WhatsApp connection successful")
+
+	// load existing session in order to keep it between restarts
+	if b.session == nil {
+		var session whatsapp.Session
+		session, err = b.readSession()
+
+		if err == nil {
+			b.Log.Debugln("Restoring WhatsApp session..")
+
+			// https://github.com/Rhymen/go-whatsapp#restore
+			session, err = b.conn.RestoreSession(session)
+			if err != nil {
+				// TODO return or continue to normal login?
+				// restore session connection timed out (I couldn't get over it without logging in again)
+				return errors.New("failed to restore session: " + err.Error())
+			}
+
+			b.session = &session
+			b.Log.Debugln("Session restored successfully!")
+		} else {
+			b.Log.Warn(err.Error())
+		}
+	}
+
+	// login to a new session
+	if b.session == nil {
+		err = b.Login()
+		if err != nil {
+			return err
+		}
+	}
+	b.startedAt = uint64(time.Now().Unix())
+
+	_, err = b.conn.Contacts()
+	if err != nil {
+		return fmt.Errorf("error on update of contacts: %v", err)
+	}
+
+	// map all the users
+	for id, contact := range b.conn.Store.Contacts {
+		if !isGroupJid(id) && id != "status@broadcast" {
+			// it is user
+			b.users[id] = contact
+		}
+	}
+
+	// get user avatar asynchronously
+	go func() {
+		b.Log.Debug("Getting user avatars..")
+
+		for jid := range b.users {
+			info, err := b.connExt.GetProfilePicThumb(jid)
+			if err != nil {
+				b.Log.Warnf("Could not get profile photo of %s: %v", jid, err)
+
+			} else {
+				// TODO any race conditions here?
+				b.userAvatars[jid] = info.URL
+			}
+		}
+		b.Log.Debug("Finished getting avatars..")
+	}()
+
+	return nil
+}
+
+// Login to WhatsApp creating a new session. This will require to scan a QR code on your mobile device
+func (b *Bwhatsapp) Login() error {
+	b.Log.Debugln("Logging in..")
+
+	invert := b.GetBool(qrOnWhiteTerminal) // false is the default
+	qrChan := qrFromTerminal(invert)
+
+	session, err := b.conn.Login(qrChan)
+	if err != nil {
+		b.Log.Warnln("Failed to log in:", err)
+		return err
+	}
+	b.session = &session
+
+	b.Log.Infof("Logged into session: %#v", session)
+	b.Log.Infof("Connection: %#v", b.conn)
+
+	err = b.writeSession(session)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error saving session: %v\n", err)
+	}
+
+	// TODO change connection strings to configured ones longClientName:"github.com/rhymen/go-whatsapp", shortClientName:"go-whatsapp"}" prefix=whatsapp
+	// TODO get also a nice logo
+
+	// TODO notification about unplugged and dead battery
+	// conn.Info: Wid, Pushname, Connected, Battery, Plugged
+
+	return nil
+}
+
+// Disconnect is called while reconnecting to the bridge
+// TODO 42wim Documentation would be helpful on when reconnects happen and what should be done in this function
+// Required implementation of the Bridger interface
+// https://github.com/42wim/matterbridge/blob/2cfd880cdb0df29771bf8f31df8d990ab897889d/bridge/bridge.go#L11-L16
+func (b *Bwhatsapp) Disconnect() error {
+	// We could Logout, but that would close the session completely and would require a new QR code scan
+	// https://github.com/Rhymen/go-whatsapp/blob/c31092027237441cffba1b9cb148eadf7c83c3d2/session.go#L377-L381
+	return nil
+}
+
+func isGroupJid(identifier string) bool {
+	return strings.HasSuffix(identifier, "@g.us") || strings.HasSuffix(identifier, "@temp")
+}
+
+// JoinChannel Join a WhatsApp group specified in gateway config as channel='number-id@g.us' or channel='Channel name'
+// Required implementation of the Bridger interface
+// https://github.com/42wim/matterbridge/blob/2cfd880cdb0df29771bf8f31df8d990ab897889d/bridge/bridge.go#L11-L16
+func (b *Bwhatsapp) JoinChannel(channel config.ChannelInfo) error {
+	byJid := isGroupJid(channel.Name)
+
+	// verify if we are member of the given group
+	if byJid {
+		// channel.Name specifies static group jID, not the name
+		if _, exists := b.conn.Store.Contacts[channel.Name]; !exists {
+			return fmt.Errorf("account doesn't belong to group with jid %s", channel.Name)
+		}
+	} else {
+		// channel.Name specifies group name that might change, warn about it
+		var jids []string
+		for id, contact := range b.conn.Store.Contacts {
+			if isGroupJid(id) && contact.Name == channel.Name {
+				jids = append(jids, id)
+			}
+		}
+
+		switch len(jids) {
+		case 0:
+			// didn't match any group - print out possibilites
+			// TODO sort
+			// copy b;
+			//sort.Slice(people, func(i, j int) bool {
+			//	return people[i].Age > people[j].Age
+			//})
+			for id, contact := range b.conn.Store.Contacts {
+				if isGroupJid(id) {
+					b.Log.Infof("%s %s", contact.Jid, contact.Name)
+				}
+			}
+			return fmt.Errorf("please specify group's JID from the list above instead of the name '%s'", channel.Name)
+
+		case 1:
+			return fmt.Errorf("group name might change. Please configure gateway with channel=\"%v\" instead of channel=\"%v\"", jids[0], channel.Name)
+
+		default:
+			return fmt.Errorf("there is more than one group with name '%s'. Please specify one of JIDs as channel name: %v", channel.Name, jids)
+		}
+	}
+
+	return nil
+}
+
+// Send a message from the bridge to WhatsApp
+// Required implementation of the Bridger interface
+// https://github.com/42wim/matterbridge/blob/2cfd880cdb0df29771bf8f31df8d990ab897889d/bridge/bridge.go#L11-L16
+func (b *Bwhatsapp) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Delete message
+	if msg.Event == config.EventMsgDelete {
+		if msg.ID == "" {
+			// No message ID in case action is executed on a message sent before the bridge was started
+			// and then the bridge cache doesn't have this message ID mapped
+
+			// TODO 42wim Doesn't the app get clogged with a ton of IDs after some time of running?
+			// WhatsApp allows to set any ID so in that case we could use external IDs and don't do mapping
+			// but external IDs are not set
+			return "", nil
+		}
+		// TODO delete message on WhatsApp https://github.com/Rhymen/go-whatsapp/issues/100
+		return "", nil
+	}
+
+	// Edit message
+	if msg.ID != "" {
+		b.Log.Debugf("updating message with id %s", msg.ID)
+
+		msg.Text += " (edited)"
+		// TODO handle edit as a message reply with updated text
+	}
+
+	//// TODO Handle Upload a file
+	//if msg.Extra != nil {
+	//	for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+	//		b.c.SendMessage(roomID, rmsg.Username+rmsg.Text)
+	//	}
+	//	if len(msg.Extra["file"]) > 0 {
+	//		return b.handleUploadFile(&msg, roomID)
+	//	}
+	//}
+
+	// Post text message
+	text := whatsapp.TextMessage{
+		Info: whatsapp.MessageInfo{
+			RemoteJid: msg.Channel, // which equals to group id
+		},
+		Text: msg.Username + msg.Text,
+	}
+
+	b.Log.Debugf("=> Sending %#v", msg)
+
+	// create message ID
+	// TODO follow and act if https://github.com/Rhymen/go-whatsapp/issues/101 implemented
+	bytes := make([]byte, 10)
+	if _, err := rand.Read(bytes); err != nil {
+		b.Log.Warn(err.Error())
+	}
+	text.Info.Id = strings.ToUpper(hex.EncodeToString(bytes))
+
+	err := b.conn.Send(text)
+
+	return text.Info.Id, err
+}
+
+// TODO do we want that? to allow login with QR code from a bridged channel? https://github.com/tulir/mautrix-whatsapp/blob/513eb18e2d59bada0dd515ee1abaaf38a3bfe3d5/commands.go#L76
+//func (b *Bwhatsapp) Command(cmd string) string {
+//	return ""
+//}

bridge/xmpp/xmpp.go

@@ -17,6 +17,7 @@ type Bxmpp struct {
 	xc      *xmpp.Client
 	xmppMap map[string]string
 	*bridge.Config
+	startTime time.Time
 }
 
 func New(cfg *bridge.Config) bridge.Bridger {
@@ -153,6 +154,7 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 func (b *Bxmpp) handleXMPP() error {
 	var ok bool
 	var msgid string
+	b.startTime = time.Now()
 	done := b.xmppKeepAlive()
 	defer close(done)
 	for {
@@ -164,15 +166,27 @@ func (b *Bxmpp) handleXMPP() error {
 		case xmpp.Chat:
 			if v.Type == "groupchat" {
 				b.Log.Debugf("== Receiving %#v", v)
+				event := ""
 				// skip invalid messages
 				if b.skipMessage(v) {
 					continue
 				}
+				if strings.Contains(v.Text, "has set the subject to:") {
+					event = config.EventTopicChange
+				}
 				msgid = v.ID
 				if v.ReplaceID != "" {
 					msgid = v.ReplaceID
 				}
-				rmsg := config.Message{Username: b.parseNick(v.Remote), Text: v.Text, Channel: b.parseChannel(v.Remote), Account: b.Account, UserID: v.Remote, ID: msgid}
+				rmsg := config.Message{
+					Username: b.parseNick(v.Remote),
+					Text:     v.Text,
+					Channel:  b.parseChannel(v.Remote),
+					Account:  b.Account,
+					UserID:   v.Remote,
+					ID:       msgid,
+					Event:    event,
+				}
 
 				// check if we have an action event
 				rmsg.Text, ok = b.replaceAction(rmsg.Text)
@@ -259,6 +273,11 @@ func (b *Bxmpp) skipMessage(message xmpp.Chat) bool {
 		return true
 	}
 
+	// do not show subjects on connect #732
+	if strings.Contains(message.Text, "has set the subject to:") && time.Since(b.startTime) < time.Second*5 {
+		return true
+	}
+
 	// skip delayed messages
 	t := time.Time{}
 	return message.Stamp != t

bridge/zulip/zulip.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"io/ioutil"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge"
@@ -17,10 +18,12 @@ type Bzulip struct {
 	bot     *gzb.Bot
 	streams map[int]string
 	*bridge.Config
+	channelToTopic map[string]string
+	sync.RWMutex
 }
 
 func New(cfg *bridge.Config) bridge.Bridger {
-	return &Bzulip{Config: cfg, streams: make(map[int]string)}
+	return &Bzulip{Config: cfg, streams: make(map[int]string), channelToTopic: make(map[string]string)}
 }
 
 func (b *Bzulip) Connect() error {
@@ -45,6 +48,9 @@ func (b *Bzulip) Disconnect() error {
 }
 
 func (b *Bzulip) JoinChannel(channel config.ChannelInfo) error {
+	b.Lock()
+	defer b.Unlock()
+	b.channelToTopic[channel.Name] = channel.Options.Topic
 	return nil
 }
 
@@ -100,7 +106,30 @@ func (b *Bzulip) getChannel(id int) string {
 
 func (b *Bzulip) handleQueue() error {
 	for {
-		messages, _ := b.q.GetEvents()
+		messages, err := b.q.GetEvents()
+		switch err {
+		case gzb.BackoffError:
+			time.Sleep(time.Second * 5)
+		case gzb.NoJSONError:
+			b.Log.Error("Response wasn't JSON, server down or restarting? sleeping 10 seconds")
+			time.Sleep(time.Second * 10)
+		case gzb.BadEventQueueError:
+			b.Log.Info("got a bad event queue id error, reconnecting")
+			b.bot.Queues = nil
+			b.q, err = b.bot.RegisterAll()
+			if err != nil {
+				b.Log.Errorf("reconnecting failed: %s. Sleeping 10 seconds", err)
+				time.Sleep(time.Second * 10)
+				continue
+			}
+		case gzb.HeartbeatError:
+			b.Log.Debug("heartbeat received.")
+		default:
+			b.Log.Debugf("receiving error: %#v", err)
+		}
+		if err != nil {
+			continue
+		}
 		for _, m := range messages {
 			b.Log.Debugf("== Receiving %#v", m)
 			// ignore our own messages
@@ -122,6 +151,9 @@ func (b *Bzulip) sendMessage(msg config.Message) (string, error) {
 	if b.GetString("topic") != "" {
 		topic = b.GetString("topic")
 	}
+	if res := b.getTopic(msg.Channel); res != "" {
+		topic = res
+	}
 	m := gzb.Message{
 		Stream:  msg.Channel,
 		Topic:   topic,
@@ -168,3 +200,9 @@ func (b *Bzulip) handleUploadFile(msg *config.Message) (string, error) {
 	}
 	return "", nil
 }
+
+func (b *Bzulip) getTopic(channel string) string {
+	b.RLock()
+	defer b.RUnlock()
+	return b.channelToTopic[channel]
+}

changelog.md

@@ -1,3 +1,32 @@
+# v1.14.0-rc1
+
+## New features
+* whatsapp: new protocol added. Add initial WhatsApp support (#711) Thanks to @KrzysztofMadejski
+* facebook messenger: new protocol via matterbridge api. See https://github.com/VictorNine/fbridge/ for more information.
+* general: Add scripting (tengo) support for every incoming message (#731). See `TengoModifyMessage`
+* general: Allow regexs in ignoreNicks. Closes #690 (#720)
+* general: Support rewriting messages from relaybots using ExtractNicks. Fixes #466 (#730). See `ExtractNicks` in matterbridge.toml.sample
+* general: refactor Make all loggers derive from non-default instance (#728). Thanks to @Helcaraxan
+* rocketchat: add support for the rocketchat API. Sending to rocketchat now supports uploading of files, editing and deleting of messages.
+* discord: Support join/leaves from discord. Closes #654 (#721)
+* discord: Allow sending discriminator with Discord username (#726). See `UseDiscriminator` in matterbridge.toml.sample
+* zulip: Allow zulip bridge to specify topic per channel. Closes #701 (#723). See `Topic` in matterbridge.toml.sample
+* slack: Add extra debug option (slack). See `Debug` in the slack section in matterbridge.toml.sample
+
+## Bugfix
+* zulip: Fix error handling on bad event queue id (zulip). Closes #694
+* irc: add support for (older) unrealircd versions. #708
+* irc: Support quits from irc correctly. Fixes #722 (#724)
+* matrix: Send username when uploading video/images (matrix). Fixes #715 (#717)
+* matrix: Send notices on join/parts (matrix). Fixes #712 (#716)
+* matrix: Detect html nicks in RemoteNickFormat (matrix). Fixes #696 (#719)
+* slack: Hint at thread replies when messages are unthreaded (slack) (#684)
+* xmpp: Do not send topic changes on connect (xmpp). Fixes #732 (#733)
+
+## Contributors
+This release couldn't exist without the following contributors:
+@Helcaraxan, @KrzysztofMadejski, @AJolly, @DeclanHoare
+
 # v1.13.1
 
 This release fixes go modules issues because of https://github.com/labstack/echo/issues/1272

contrib/example.tengo

@@ -0,0 +1,2 @@
+text := import("text")
+msgText=text.re_replace("matterbridge",msgText,"matterbridge (https://github.com/42wim/matterbridge)")

gateway/bench.tengo

@@ -0,0 +1,5 @@
+text := import("text")
+if text.re_match("blah",msgText) {
+    msgText="replaced by this"
+    msgUsername="fakeuser"
+}

gateway/bridgemap/bridgemap.go

@@ -13,6 +13,7 @@ import (
 	"github.com/42wim/matterbridge/bridge/sshchat"
 	"github.com/42wim/matterbridge/bridge/steam"
 	"github.com/42wim/matterbridge/bridge/telegram"
+	"github.com/42wim/matterbridge/bridge/whatsapp"
 	"github.com/42wim/matterbridge/bridge/xmpp"
 	"github.com/42wim/matterbridge/bridge/zulip"
 )
@@ -30,6 +31,7 @@ var FullMap = map[string]bridge.Factory{
 	"sshchat":      bsshchat.New,
 	"steam":        bsteam.New,
 	"telegram":     btelegram.New,
+	"whatsapp":     bwhatsapp.New,
 	"xmpp":         bxmpp.New,
 	"zulip":        bzulip.New,
 }

gateway/gateway.go

@@ -1,6 +1,7 @@
 package gateway
 
 import (
+	"io/ioutil"
 	"os"
 	"regexp"
 	"strings"
@@ -8,7 +9,8 @@ import (
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/hashicorp/golang-lru"
+	"github.com/d5/tengo/script"
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/peterhellberg/emojilib"
 	"github.com/sirupsen/logrus"
 )
@@ -24,6 +26,8 @@ type Gateway struct {
 	Message        chan config.Message
 	Name           string
 	Messages       *lru.Cache
+
+	logger *logrus.Entry
 }
 
 type BrMsgID struct {
@@ -32,25 +36,30 @@ type BrMsgID struct {
 	ChannelID string
 }
 
-var flog *logrus.Entry
+const apiProtocol = "api"
 
-const (
-	apiProtocol = "api"
-)
+// New creates a new Gateway object associated with the specified router and
+// following the given configuration.
+func New(rootLogger *logrus.Logger, cfg *config.Gateway, r *Router) *Gateway {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "gateway"})
 
-func New(cfg config.Gateway, r *Router) *Gateway {
-	flog = logrus.WithFields(logrus.Fields{"prefix": "gateway"})
-	gw := &Gateway{Channels: make(map[string]*config.ChannelInfo), Message: r.Message,
-		Router: r, Bridges: make(map[string]*bridge.Bridge), Config: r.Config}
 	cache, _ := lru.New(5000)
-	gw.Messages = cache
-	if err := gw.AddConfig(&cfg); err != nil {
-		flog.Errorf("AddConfig failed: %s", err)
+	gw := &Gateway{
+		Channels: make(map[string]*config.ChannelInfo),
+		Message:  r.Message,
+		Router:   r,
+		Bridges:  make(map[string]*bridge.Bridge),
+		Config:   r.Config,
+		Messages: cache,
+		logger:   logger,
+	}
+	if err := gw.AddConfig(cfg); err != nil {
+		logger.Errorf("Failed to add configuration to gateway: %#v", err)
 	}
 	return gw
 }
 
-// Find the canonical ID that the message is keyed under in cache
+// FindCanonicalMsgID returns the ID under which a message was stored in the cache.
 func (gw *Gateway) FindCanonicalMsgID(protocol string, mID string) string {
 	ID := protocol + " " + mID
 	if gw.Messages.Contains(ID) {
@@ -70,15 +79,18 @@ func (gw *Gateway) FindCanonicalMsgID(protocol string, mID string) string {
 	return ""
 }
 
+// AddBridge sets up a new bridge in the gateway object with the specified configuration.
 func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
 	br := gw.Router.getBridge(cfg.Account)
 	if br == nil {
 		br = bridge.New(cfg)
 		br.Config = gw.Router.Config
 		br.General = &gw.BridgeValues().General
-		// set logging
-		br.Log = logrus.WithFields(logrus.Fields{"prefix": "bridge"})
-		brconfig := &bridge.Config{Remote: gw.Message, Log: logrus.WithFields(logrus.Fields{"prefix": br.Protocol}), Bridge: br}
+		br.Log = gw.logger.WithFields(logrus.Fields{"prefix": br.Protocol})
+		brconfig := &bridge.Config{
+			Remote: gw.Message,
+			Bridge: br,
+		}
 		// add the actual bridger for this protocol to this bridge using the bridgeMap
 		br.Bridger = gw.Router.BridgeMap[br.Protocol](brconfig)
 	}
@@ -87,11 +99,12 @@ func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
 	return nil
 }
 
+// AddConfig associates a new configuration with the gateway object.
 func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
 	gw.Name = cfg.Name
 	gw.MyConfig = cfg
 	if err := gw.mapChannels(); err != nil {
-		flog.Errorf("mapChannels() failed: %s", err)
+		gw.logger.Errorf("mapChannels() failed: %s", err)
 	}
 	for _, br := range append(gw.MyConfig.In, append(gw.MyConfig.InOut, gw.MyConfig.Out...)...) {
 		br := br //scopelint
@@ -113,20 +126,20 @@ func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
 
 func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
 	if err := br.Disconnect(); err != nil {
-		flog.Errorf("Disconnect() %s failed: %s", br.Account, err)
+		gw.logger.Errorf("Disconnect() %s failed: %s", br.Account, err)
 	}
 	time.Sleep(time.Second * 5)
 RECONNECT:
-	flog.Infof("Reconnecting %s", br.Account)
+	gw.logger.Infof("Reconnecting %s", br.Account)
 	err := br.Connect()
 	if err != nil {
-		flog.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
+		gw.logger.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
 		time.Sleep(time.Second * 60)
 		goto RECONNECT
 	}
 	br.Joined = make(map[string]bool)
 	if err := br.JoinChannels(); err != nil {
-		flog.Errorf("JoinChannels() %s failed: %s", br.Account, err)
+		gw.logger.Errorf("JoinChannels() %s failed: %s", br.Account, err)
 	}
 }
 
@@ -140,13 +153,19 @@ func (gw *Gateway) mapChannelConfig(cfg []config.Bridge, direction string) {
 			br.Channel = strings.ToLower(br.Channel)
 		}
 		if strings.HasPrefix(br.Account, "mattermost.") && strings.HasPrefix(br.Channel, "#") {
-			flog.Errorf("Mattermost channels do not start with a #: remove the # in %s", br.Channel)
+			gw.logger.Errorf("Mattermost channels do not start with a #: remove the # in %s", br.Channel)
 			os.Exit(1)
 		}
 		ID := br.Channel + br.Account
 		if _, ok := gw.Channels[ID]; !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: direction, ID: ID, Options: br.Options, Account: br.Account,
-				SameChannel: make(map[string]bool)}
+			channel := &config.ChannelInfo{
+				Name:        br.Channel,
+				Direction:   direction,
+				ID:          ID,
+				Options:     br.Options,
+				Account:     br.Account,
+				SameChannel: make(map[string]bool),
+			}
 			channel.SameChannel[gw.Name] = br.SameChannel
 			gw.Channels[channel.ID] = channel
 		} else {
@@ -174,10 +193,38 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 		return channels
 	}
 
+	// discord join/leave is for the whole bridge, isn't a per channel join/leave
+	if msg.Event == config.EventJoinLeave && getProtocol(msg) == "discord" && msg.Channel == "" {
+		for _, channel := range gw.Channels {
+			if channel.Account == dest.Account && strings.Contains(channel.Direction, "out") &&
+				gw.validGatewayDest(msg) {
+				channels = append(channels, *channel)
+			}
+		}
+		return channels
+	}
+
+	// irc quit is for the whole bridge, isn't a per channel quit.
+	// channel is empty when we quit
+	if msg.Event == config.EventJoinLeave && getProtocol(msg) == "irc" && msg.Channel == "" {
+		// if we only have one channel on this irc bridge it's got to be the sending one.
+		// don't send it back
+		if dest.Account == msg.Account && len(dest.Channels) == 1 && dest.Protocol == "irc" {
+			return channels
+		}
+		for _, channel := range gw.Channels {
+			if channel.Account == dest.Account && strings.Contains(channel.Direction, "out") &&
+				gw.validGatewayDest(msg) {
+				channels = append(channels, *channel)
+			}
+		}
+		return channels
+	}
+
 	// if source channel is in only, do nothing
 	for _, channel := range gw.Channels {
 		// lookup the channel from the message
-		if channel.ID == getChannelID(*msg) {
+		if channel.ID == getChannelID(msg) {
 			// we only have destinations if the original message is from an "in" (sending) channel
 			if !strings.Contains(channel.Direction, "in") {
 				return channels
@@ -186,11 +233,11 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 		}
 	}
 	for _, channel := range gw.Channels {
-		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
+		if _, ok := gw.Channels[getChannelID(msg)]; !ok {
 			continue
 		}
 
-		// do samechannelgateway flogic
+		// do samechannelgateway logic
 		if channel.SameChannel[msg.Gateway] {
 			if msg.Channel == channel.Name && msg.Account != dest.Account {
 				channels = append(channels, *channel)
@@ -204,7 +251,7 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 	return channels
 }
 
-func (gw *Gateway) getDestMsgID(msgID string, dest *bridge.Bridge, channel config.ChannelInfo) string {
+func (gw *Gateway) getDestMsgID(msgID string, dest *bridge.Bridge, channel *config.ChannelInfo) string {
 	if res, ok := gw.Messages.Get(msgID); ok {
 		IDs := res.([]*BrMsgID)
 		for _, id := range IDs {
@@ -233,42 +280,10 @@ func (gw *Gateway) ignoreTextEmpty(msg *config.Message) bool {
 			len(msg.Extra[config.EventFileFailureSize]) > 0) {
 		return false
 	}
-	flog.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
+	gw.logger.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
 	return true
 }
 
-// ignoreTexts returns true if msg.Text matches any of the input regexes.
-func (gw *Gateway) ignoreTexts(msg *config.Message, input []string) bool {
-	for _, entry := range input {
-		if entry == "" {
-			continue
-		}
-		// TODO do not compile regexps everytime
-		re, err := regexp.Compile(entry)
-		if err != nil {
-			flog.Errorf("incorrect regexp %s for %s", entry, msg.Account)
-			continue
-		}
-		if re.MatchString(msg.Text) {
-			flog.Debugf("matching %s. ignoring %s from %s", entry, msg.Text, msg.Account)
-			return true
-		}
-	}
-	return false
-}
-
-// ignoreNicks returns true if msg.Username matches any of the input regexes.
-func (gw *Gateway) ignoreNicks(msg *config.Message, input []string) bool {
-	// is the username in IgnoreNicks field
-	for _, entry := range input {
-		if msg.Username == entry {
-			flog.Debugf("ignoring %s from %s", msg.Username, msg.Account)
-			return true
-		}
-	}
-	return false
-}
-
 func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
 	// if we don't have the bridge, ignore it
 	if _, ok := gw.Bridges[msg.Account]; !ok {
@@ -277,14 +292,14 @@ func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
 
 	igNicks := strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreNicks"))
 	igMessages := strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreMessages"))
-	if gw.ignoreTextEmpty(msg) || gw.ignoreNicks(msg, igNicks) || gw.ignoreTexts(msg, igMessages) {
+	if gw.ignoreTextEmpty(msg) || gw.ignoreText(msg.Username, igNicks) || gw.ignoreText(msg.Text, igMessages) {
 		return true
 	}
 
 	return false
 }
 
-func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) string {
+func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) string {
 	br := gw.Bridges[msg.Account]
 	msg.Protocol = br.Protocol
 	if dest.GetBool("StripNick") {
@@ -300,7 +315,7 @@ func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) strin
 		// TODO move compile to bridge init somewhere
 		re, err := regexp.Compile(search)
 		if err != nil {
-			flog.Errorf("regexp in %s failed: %s", msg.Account, err)
+			gw.logger.Errorf("regexp in %s failed: %s", msg.Account, err)
 			break
 		}
 		msg.Username = re.ReplaceAllString(msg.Username, replace)
@@ -328,7 +343,7 @@ func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) strin
 	return nick
 }
 
-func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string {
+func (gw *Gateway) modifyAvatar(msg *config.Message, dest *bridge.Bridge) string {
 	iconurl := dest.GetString("IconURL")
 	iconurl = strings.Replace(iconurl, "{NICK}", msg.Username, -1)
 	if msg.Avatar == "" {
@@ -338,6 +353,10 @@ func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string
 }
 
 func (gw *Gateway) modifyMessage(msg *config.Message) {
+	if err := modifyMessageTengo(gw.BridgeValues().General.TengoModifyMessage, msg); err != nil {
+		gw.logger.Errorf("TengoModifyMessage failed: %s", err)
+	}
+
 	// replace :emoji: to unicode
 	msg.Text = emojilib.Replace(msg.Text)
 
@@ -349,55 +368,68 @@ func (gw *Gateway) modifyMessage(msg *config.Message) {
 		// TODO move compile to bridge init somewhere
 		re, err := regexp.Compile(search)
 		if err != nil {
-			flog.Errorf("regexp in %s failed: %s", msg.Account, err)
+			gw.logger.Errorf("regexp in %s failed: %s", msg.Account, err)
 			break
 		}
 		msg.Text = re.ReplaceAllString(msg.Text, replace)
 	}
 
+	gw.handleExtractNicks(msg)
+
 	// messages from api have Gateway specified, don't overwrite
 	if msg.Protocol != apiProtocol {
 		msg.Gateway = gw.Name
 	}
 }
 
-// SendMessage sends a message (with specified parentID) to the channel on the selected destination bridge.
-// returns a message id and error.
-func (gw *Gateway) SendMessage(origmsg config.Message, dest *bridge.Bridge, channel config.ChannelInfo, canonicalParentMsgID string) (string, error) {
-	msg := origmsg
+// SendMessage sends a message (with specified parentID) to the channel on the selected
+// destination bridge and returns a message ID or an error.
+func (gw *Gateway) SendMessage(
+	rmsg *config.Message,
+	dest *bridge.Bridge,
+	channel *config.ChannelInfo,
+	canonicalParentMsgID string,
+) (string, error) {
+	msg := *rmsg
 	// Only send the avatar download event to ourselves.
 	if msg.Event == config.EventAvatarDownload {
-		if channel.ID != getChannelID(origmsg) {
+		if channel.ID != getChannelID(rmsg) {
 			return "", nil
 		}
 	} else {
 		// do not send to ourself for any other event
-		if channel.ID == getChannelID(origmsg) {
+		if channel.ID == getChannelID(rmsg) {
 			return "", nil
 		}
 	}
 
 	// Too noisy to log like other events
 	if msg.Event != config.EventUserTyping {
-		flog.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, origmsg.Channel, dest.Account, channel.Name)
+		gw.logger.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, rmsg.Channel, dest.Account, channel.Name)
 	}
 
 	msg.Channel = channel.Name
-	msg.Avatar = gw.modifyAvatar(origmsg, dest)
-	msg.Username = gw.modifyUsername(origmsg, dest)
+	msg.Avatar = gw.modifyAvatar(rmsg, dest)
+	msg.Username = gw.modifyUsername(rmsg, dest)
 
-	msg.ID = gw.getDestMsgID(origmsg.Protocol+" "+origmsg.ID, dest, channel)
+	msg.ID = gw.getDestMsgID(rmsg.Protocol+" "+rmsg.ID, dest, channel)
 
 	// for api we need originchannel as channel
 	if dest.Protocol == apiProtocol {
-		msg.Channel = origmsg.Channel
+		msg.Channel = rmsg.Channel
 	}
 
-	msg.ParentID = gw.getDestMsgID(origmsg.Protocol+" "+canonicalParentMsgID, dest, channel)
+	msg.ParentID = gw.getDestMsgID(rmsg.Protocol+" "+canonicalParentMsgID, dest, channel)
 	if msg.ParentID == "" {
 		msg.ParentID = canonicalParentMsgID
 	}
 
+	// if the parentID is still empty and we have a parentID set in the original message
+	// this means that we didn't find it in the cache so set it "msg-parent-not-found"
+	if msg.ParentID == "" && rmsg.ParentID != "" {
+		msg.ParentID = "msg-parent-not-found"
+	}
+
 	// if we are using mattermost plugin account, send messages to MattermostPlugin channel
 	// that can be picked up by the mattermost matterbridge plugin
 	if dest.Account == "mattermost.plugin" {
@@ -411,7 +443,7 @@ func (gw *Gateway) SendMessage(origmsg config.Message, dest *bridge.Bridge, chan
 
 	// append the message ID (mID) from this bridge (dest) to our brMsgIDs slice
 	if mID != "" {
-		flog.Debugf("mID %s: %s", dest.Account, mID)
+		gw.logger.Debugf("mID %s: %s", dest.Account, mID)
 		return mID, nil
 		//brMsgIDs = append(brMsgIDs, &BrMsgID{dest, dest.Protocol + " " + mID, channel.ID})
 	}
@@ -422,10 +454,60 @@ func (gw *Gateway) validGatewayDest(msg *config.Message) bool {
 	return msg.Gateway == gw.Name
 }
 
-func getChannelID(msg config.Message) string {
+func getChannelID(msg *config.Message) string {
 	return msg.Channel + msg.Account
 }
 
 func isAPI(account string) bool {
 	return strings.HasPrefix(account, "api.")
 }
+
+// ignoreText returns true if text matches any of the input regexes.
+func (gw *Gateway) ignoreText(text string, input []string) bool {
+	for _, entry := range input {
+		if entry == "" {
+			continue
+		}
+		// TODO do not compile regexps everytime
+		re, err := regexp.Compile(entry)
+		if err != nil {
+			gw.logger.Errorf("incorrect regexp %s", entry)
+			continue
+		}
+		if re.MatchString(text) {
+			gw.logger.Debugf("matching %s. ignoring %s", entry, text)
+			return true
+		}
+	}
+	return false
+}
+
+func getProtocol(msg *config.Message) string {
+	p := strings.Split(msg.Account, ".")
+	return p[0]
+}
+
+func modifyMessageTengo(filename string, msg *config.Message) error {
+	if filename == "" {
+		return nil
+	}
+	res, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	s := script.New(res)
+	_ = s.Add("msgText", msg.Text)
+	_ = s.Add("msgUsername", msg.Username)
+	_ = s.Add("msgAccount", msg.Account)
+	_ = s.Add("msgChannel", msg.Channel)
+	c, err := s.Compile()
+	if err != nil {
+		return err
+	}
+	if err := c.Run(); err != nil {
+		return err
+	}
+	msg.Text = c.Get("msgText").String()
+	msg.Username = c.Get("msgUsername").String()
+	return nil
+}

gateway/gateway_test.go

@@ -2,12 +2,15 @@ package gateway
 
 import (
 	"fmt"
+	"io/ioutil"
 	"strconv"
 	"testing"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/gateway/bridgemap"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
 )
 
 var testconfig = []byte(`
@@ -159,8 +162,10 @@ const (
 )
 
 func maketestRouter(input []byte) *Router {
-	cfg := config.NewConfigFromString(input)
-	r, err := NewRouter(cfg, bridgemap.FullMap)
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	cfg := config.NewConfigFromString(logger, input)
+	r, err := NewRouter(logger, cfg, bridgemap.FullMap)
 	if err != nil {
 		fmt.Println(err)
 	}
@@ -387,7 +392,23 @@ func TestGetDestChannelAdvanced(t *testing.T) {
 	assert.Equal(t, map[string]int{"bridge3": 4, "bridge": 9, "announcements": 3, "bridge2": 4}, hits)
 }
 
-func TestIgnoreTextEmpty(t *testing.T) {
+type ignoreTestSuite struct {
+	suite.Suite
+
+	gw *Gateway
+}
+
+func TestIgnoreSuite(t *testing.T) {
+	s := &ignoreTestSuite{}
+	suite.Run(t, s)
+}
+
+func (s *ignoreTestSuite) SetupSuite() {
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	s.gw = &Gateway{logger: logrus.NewEntry(logger)}
+}
+func (s *ignoreTestSuite) TestIgnoreTextEmpty() {
 	extraFile := make(map[string][]interface{})
 	extraAttach := make(map[string][]interface{})
 	extraFailure := make(map[string][]interface{})
@@ -424,78 +445,85 @@ func TestIgnoreTextEmpty(t *testing.T) {
 			output: true,
 		},
 	}
-	gw := &Gateway{}
 	for testname, testcase := range msgTests {
-		output := gw.ignoreTextEmpty(testcase.input)
-		assert.Equalf(t, testcase.output, output, "case '%s' failed", testname)
+		output := s.gw.ignoreTextEmpty(testcase.input)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
 	}
 
 }
 
-func TestIgnoreTexts(t *testing.T) {
+func (s *ignoreTestSuite) TestIgnoreTexts() {
 	msgTests := map[string]struct {
-		input  *config.Message
+		input  string
 		re     []string
 		output bool
 	}{
 		"no regex": {
-			input:  &config.Message{Text: "a text message"},
+			input:  "a text message",
 			re:     []string{},
 			output: false,
 		},
 		"simple regex": {
-			input:  &config.Message{Text: "a text message"},
+			input:  "a text message",
 			re:     []string{"text"},
 			output: true,
 		},
 		"multiple regex fail": {
-			input:  &config.Message{Text: "a text message"},
+			input:  "a text message",
 			re:     []string{"abc", "123$"},
 			output: false,
 		},
 		"multiple regex pass": {
-			input:  &config.Message{Text: "a text message"},
+			input:  "a text message",
 			re:     []string{"lala", "sage$"},
 			output: true,
 		},
 	}
-	gw := &Gateway{}
 	for testname, testcase := range msgTests {
-		output := gw.ignoreTexts(testcase.input, testcase.re)
-		assert.Equalf(t, testcase.output, output, "case '%s' failed", testname)
+		output := s.gw.ignoreText(testcase.input, testcase.re)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
 	}
 }
 
-func TestIgnoreNicks(t *testing.T) {
+func (s *ignoreTestSuite) TestIgnoreNicks() {
 	msgTests := map[string]struct {
-		input  *config.Message
+		input  string
 		re     []string
 		output bool
 	}{
 		"no entry": {
-			input:  &config.Message{Username: "user", Text: "a text message"},
+			input:  "user",
 			re:     []string{},
 			output: false,
 		},
 		"one entry": {
-			input:  &config.Message{Username: "user", Text: "a text message"},
+			input:  "user",
 			re:     []string{"user"},
 			output: true,
 		},
 		"multiple entries": {
-			input:  &config.Message{Username: "user", Text: "a text message"},
+			input:  "user",
 			re:     []string{"abc", "user"},
 			output: true,
 		},
 		"multiple entries fail": {
-			input:  &config.Message{Username: "user", Text: "a text message"},
+			input:  "user",
 			re:     []string{"abc", "def"},
 			output: false,
 		},
 	}
-	gw := &Gateway{}
 	for testname, testcase := range msgTests {
-		output := gw.ignoreNicks(testcase.input, testcase.re)
-		assert.Equalf(t, testcase.output, output, "case '%s' failed", testname)
+		output := s.gw.ignoreText(testcase.input, testcase.re)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
+	}
+}
+
+func BenchmarkTengo(b *testing.B) {
+	msg := &config.Message{Username: "user", Text: "blah testing", Account: "protocol.account", Channel: "mychannel"}
+	for n := 0; n < b.N; n++ {
+		err := modifyMessageTengo("bench.tengo", msg)
+		if err != nil {
+			return
+		}
 	}
 }

gateway/handlers.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge"
@@ -39,7 +40,7 @@ func (r *Router) handleEventGetChannelMembers(msg *config.Message) {
 		for _, br := range gw.Bridges {
 			if msg.Account == br.Account {
 				cMembers := msg.Extra[config.EventGetChannelMembers][0].(config.ChannelMembers)
-				flog.Debugf("Syncing channelmembers from %s", msg.Account)
+				r.logger.Debugf("Syncing channelmembers from %s", msg.Account)
 				br.SetChannelMembers(&cMembers)
 				return
 			}
@@ -57,7 +58,7 @@ func (r *Router) handleEventRejoinChannels(msg *config.Message) {
 			if msg.Account == br.Account {
 				br.Joined = make(map[string]bool)
 				if err := br.JoinChannels(); err != nil {
-					flog.Errorf("channel join failed for %s: %s", msg.Account, err)
+					r.logger.Errorf("channel join failed for %s: %s", msg.Account, err)
 				}
 			}
 		}
@@ -93,13 +94,13 @@ func (gw *Gateway) handleFiles(msg *config.Message) {
 		if gw.BridgeValues().General.MediaServerUpload != "" {
 			// Use MediaServerUpload. Upload using a PUT HTTP request and basicauth.
 			if err := gw.handleFilesUpload(&fi); err != nil {
-				flog.Error(err)
+				gw.logger.Error(err)
 				continue
 			}
 		} else {
 			// Use MediaServerPath. Place the file on the current filesystem.
 			if err := gw.handleFilesLocal(&fi); err != nil {
-				flog.Error(err)
+				gw.logger.Error(err)
 				continue
 			}
 		}
@@ -107,7 +108,7 @@ func (gw *Gateway) handleFiles(msg *config.Message) {
 		// Download URL.
 		durl := gw.BridgeValues().General.MediaServerDownload + "/" + sha1sum + "/" + fi.Name
 
-		flog.Debugf("mediaserver download URL = %s", durl)
+		gw.logger.Debugf("mediaserver download URL = %s", durl)
 
 		// We uploaded/placed the file successfully. Add the SHA and URL.
 		extra := msg.Extra["file"][i].(config.FileInfo)
@@ -132,7 +133,7 @@ func (gw *Gateway) handleFilesUpload(fi *config.FileInfo) error {
 		return fmt.Errorf("mediaserver upload failed, could not create request: %#v", err)
 	}
 
-	flog.Debugf("mediaserver upload url: %s", url)
+	gw.logger.Debugf("mediaserver upload url: %s", url)
 
 	req.Header.Set("Content-Type", "binary/octet-stream")
 	_, err = client.Do(req)
@@ -153,7 +154,7 @@ func (gw *Gateway) handleFilesLocal(fi *config.FileInfo) error {
 	}
 
 	path := dir + "/" + fi.Name
-	flog.Debugf("mediaserver path placing file: %s", path)
+	gw.logger.Debugf("mediaserver path placing file: %s", path)
 
 	err = ioutil.WriteFile(path, *fi.Data, os.ModePerm)
 	if err != nil {
@@ -186,36 +187,36 @@ func (gw *Gateway) ignoreEvent(event string, dest *bridge.Bridge) bool {
 
 // handleMessage makes sure the message get sent to the correct bridge/channels.
 // Returns an array of msg ID's
-func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) []*BrMsgID {
+func (gw *Gateway) handleMessage(rmsg *config.Message, dest *bridge.Bridge) []*BrMsgID {
 	var brMsgIDs []*BrMsgID
 
 	// if we have an attached file, or other info
-	if msg.Extra != nil && len(msg.Extra[config.EventFileFailureSize]) != 0 && msg.Text == "" {
+	if rmsg.Extra != nil && len(rmsg.Extra[config.EventFileFailureSize]) != 0 && rmsg.Text == "" {
 		return brMsgIDs
 	}
 
-	if gw.ignoreEvent(msg.Event, dest) {
+	if gw.ignoreEvent(rmsg.Event, dest) {
 		return brMsgIDs
 	}
 
 	// broadcast to every out channel (irc QUIT)
-	if msg.Channel == "" && msg.Event != config.EventJoinLeave {
-		flog.Debug("empty channel")
+	if rmsg.Channel == "" && rmsg.Event != config.EventJoinLeave {
+		gw.logger.Debug("empty channel")
 		return brMsgIDs
 	}
 
 	// Get the ID of the parent message in thread
 	var canonicalParentMsgID string
-	if msg.ParentID != "" && dest.GetBool("PreserveThreading") {
-		canonicalParentMsgID = gw.FindCanonicalMsgID(msg.Protocol, msg.ParentID)
+	if rmsg.ParentID != "" && dest.GetBool("PreserveThreading") {
+		canonicalParentMsgID = gw.FindCanonicalMsgID(rmsg.Protocol, rmsg.ParentID)
 	}
 
-	origmsg := msg
-	channels := gw.getDestChannel(&msg, *dest)
-	for _, channel := range channels {
-		msgID, err := gw.SendMessage(origmsg, dest, channel, canonicalParentMsgID)
+	channels := gw.getDestChannel(rmsg, *dest)
+	for idx := range channels {
+		channel := &channels[idx]
+		msgID, err := gw.SendMessage(rmsg, dest, channel, canonicalParentMsgID)
 		if err != nil {
-			flog.Errorf("SendMessage failed: %s", err)
+			gw.logger.Errorf("SendMessage failed: %s", err)
 			continue
 		}
 		if msgID == "" {
@@ -225,3 +226,41 @@ func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) []*BrM
 	}
 	return brMsgIDs
 }
+
+func (gw *Gateway) handleExtractNicks(msg *config.Message) {
+	var err error
+	br := gw.Bridges[msg.Account]
+	for _, outer := range br.GetStringSlice2D("ExtractNicks") {
+		search := outer[0]
+		replace := outer[1]
+		msg.Username, msg.Text, err = extractNick(search, replace, msg.Username, msg.Text)
+		if err != nil {
+			gw.logger.Errorf("regexp in %s failed: %s", msg.Account, err)
+			break
+		}
+	}
+}
+
+// extractNick searches for a username (based on "search" a regular expression).
+// if this matches it extracts a nick (based on "extract" another regular expression) from text
+// and replaces username with this result.
+// returns error if the regexp doesn't compile.
+func extractNick(search, extract, username, text string) (string, string, error) {
+	re, err := regexp.Compile(search)
+	if err != nil {
+		return username, text, err
+	}
+	if re.MatchString(username) {
+		re, err = regexp.Compile(extract)
+		if err != nil {
+			return username, text, err
+		}
+		res := re.FindAllStringSubmatch(text, 1)
+		// only replace if we have exactly 1 match
+		if len(res) > 0 && len(res[0]) == 2 {
+			username = res[0][1]
+			text = strings.Replace(text, res[0][0], "", 1)
+		}
+	}
+	return username, text, nil
+}

gateway/handlers_test.go

@@ -0,0 +1,75 @@
+package gateway
+
+import (
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+func TestIgnoreEvent(t *testing.T) {
+	eventTests := map[string]struct {
+		input  string
+		dest   *bridge.Bridge
+		output bool
+	}{
+		"avatar mattermost": {
+			input:  config.EventAvatarDownload,
+			dest:   &bridge.Bridge{Protocol: "mattermost"},
+			output: false,
+		},
+		"avatar slack": {
+			input:  config.EventAvatarDownload,
+			dest:   &bridge.Bridge{Protocol: "slack"},
+			output: true,
+		},
+		"avatar telegram": {
+			input:  config.EventAvatarDownload,
+			dest:   &bridge.Bridge{Protocol: "telegram"},
+			output: false,
+		},
+	}
+	gw := &Gateway{}
+	for testname, testcase := range eventTests {
+		output := gw.ignoreEvent(testcase.input, testcase.dest)
+		assert.Equalf(t, testcase.output, output, "case '%s' failed", testname)
+	}
+
+}
+
+func TestExtractNick(t *testing.T) {
+	eventTests := map[string]struct {
+		search         string
+		extract        string
+		username       string
+		text           string
+		resultUsername string
+		resultText     string
+	}{
+		"test1": {
+			search:         "fromgitter",
+			extract:        "<(.*?)>\\s+",
+			username:       "fromgitter",
+			text:           "<userx> blahblah",
+			resultUsername: "userx",
+			resultText:     "blahblah",
+		},
+		"test2": {
+			search: "<.*?bot>",
+			//extract:        `\((.*?)\)\s+`,
+			extract:        "\\((.*?)\\)\\s+",
+			username:       "<matterbot>",
+			text:           "(userx) blahblah (abc) test",
+			resultUsername: "userx",
+			resultText:     "blahblah (abc) test",
+		},
+	}
+	//	gw := &Gateway{}
+	for testname, testcase := range eventTests {
+		resultUsername, resultText, _ := extractNick(testcase.search, testcase.extract, testcase.username, testcase.text)
+		assert.Equalf(t, testcase.resultUsername, resultUsername, "case '%s' failed", testname)
+		assert.Equalf(t, testcase.resultText, resultText, "case '%s' failed", testname)
+	}
+
+}

gateway/router.go

@@ -7,31 +7,40 @@ import (
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	samechannelgateway "github.com/42wim/matterbridge/gateway/samechannel"
+	"github.com/42wim/matterbridge/gateway/samechannel"
+	"github.com/sirupsen/logrus"
 )
 
 type Router struct {
 	config.Config
+	sync.RWMutex
 
 	BridgeMap        map[string]bridge.Factory
 	Gateways         map[string]*Gateway
 	Message          chan config.Message
 	MattermostPlugin chan config.Message
-	sync.RWMutex
+
+	logger *logrus.Entry
 }
 
-func NewRouter(cfg config.Config, bridgeMap map[string]bridge.Factory) (*Router, error) {
+// NewRouter initializes a new Matterbridge router for the specified configuration and
+// sets up all required gateways.
+func NewRouter(rootLogger *logrus.Logger, cfg config.Config, bridgeMap map[string]bridge.Factory) (*Router, error) {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "router"})
+
 	r := &Router{
 		Config:           cfg,
 		BridgeMap:        bridgeMap,
 		Message:          make(chan config.Message),
 		MattermostPlugin: make(chan config.Message),
 		Gateways:         make(map[string]*Gateway),
+		logger:           logger,
 	}
-	sgw := samechannelgateway.New(cfg)
-	gwconfigs := sgw.GetConfig()
+	sgw := samechannel.New(cfg)
+	gwconfigs := append(sgw.GetConfig(), cfg.BridgeValues().Gateway...)
 
-	for _, entry := range append(gwconfigs, cfg.BridgeValues().Gateway...) {
+	for idx := range gwconfigs {
+		entry := &gwconfigs[idx]
 		if !entry.Enable {
 			continue
 		}
@@ -41,21 +50,23 @@ func NewRouter(cfg config.Config, bridgeMap map[string]bridge.Factory) (*Router,
 		if _, ok := r.Gateways[entry.Name]; ok {
 			return nil, fmt.Errorf("Gateway with name %s already exists", entry.Name)
 		}
-		r.Gateways[entry.Name] = New(entry, r)
+		r.Gateways[entry.Name] = New(rootLogger, entry, r)
 	}
 	return r, nil
 }
 
+// Start will connect all gateways belonging to this router and subsequently route messages
+// between them.
 func (r *Router) Start() error {
 	m := make(map[string]*bridge.Bridge)
 	for _, gw := range r.Gateways {
-		flog.Infof("Parsing gateway %s", gw.Name)
+		r.logger.Infof("Parsing gateway %s", gw.Name)
 		for _, br := range gw.Bridges {
 			m[br.Account] = br
 		}
 	}
 	for _, br := range m {
-		flog.Infof("Starting bridge: %s ", br.Account)
+		r.logger.Infof("Starting bridge: %s ", br.Account)
 		err := br.Connect()
 		if err != nil {
 			e := fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
@@ -77,13 +88,13 @@ func (r *Router) Start() error {
 	for _, gw := range r.Gateways {
 		for i, br := range gw.Bridges {
 			if br.Bridger == nil {
-				flog.Errorf("removing failed bridge %s", i)
+				r.logger.Errorf("removing failed bridge %s", i)
 				delete(gw.Bridges, i)
 			}
 		}
 	}
 	go r.handleReceive()
-	go r.updateChannelMembers()
+	//go r.updateChannelMembers()
 	return nil
 }
 
@@ -91,7 +102,7 @@ func (r *Router) Start() error {
 // otherwise returns false
 func (r *Router) disableBridge(br *bridge.Bridge, err error) bool {
 	if r.BridgeValues().General.IgnoreFailureOnStart {
-		flog.Error(err)
+		r.logger.Error(err)
 		// setting this bridge empty
 		*br = bridge.Bridge{}
 		return true
@@ -124,7 +135,7 @@ func (r *Router) handleReceive() {
 			gw.modifyMessage(&msg)
 			gw.handleFiles(&msg)
 			for _, br := range gw.Bridges {
-				msgIDs = append(msgIDs, gw.handleMessage(msg, br)...)
+				msgIDs = append(msgIDs, gw.handleMessage(&msg, br)...)
 			}
 			// only add the message ID if it doesn't already exists
 			if _, ok := gw.Messages.Get(msg.Protocol + " " + msg.ID); !ok && msg.ID != "" {
@@ -146,9 +157,9 @@ func (r *Router) updateChannelMembers() {
 				if br.Protocol != "slack" {
 					continue
 				}
-				flog.Debugf("sending %s to %s", config.EventGetChannelMembers, br.Account)
+				r.logger.Debugf("sending %s to %s", config.EventGetChannelMembers, br.Account)
 				if _, err := br.Send(config.Message{Event: config.EventGetChannelMembers}); err != nil {
-					flog.Errorf("updateChannelMembers: %s", err)
+					r.logger.Errorf("updateChannelMembers: %s", err)
 				}
 			}
 		}

gateway/samechannel/samechannel.go

@@ -1,4 +1,4 @@
-package samechannelgateway
+package samechannel
 
 import (
 	"github.com/42wim/matterbridge/bridge/config"

gateway/samechannel/samechannel_test.go

@@ -1,9 +1,11 @@
-package samechannelgateway
+package samechannel
 
 import (
+	"io/ioutil"
 	"testing"
 
 	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -66,7 +68,9 @@ var (
 )
 
 func TestGetConfig(t *testing.T) {
-	cfg := config.NewConfigFromString([]byte(testConfig))
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	cfg := config.NewConfigFromString(logger, []byte(testConfig))
 	sgw := New(cfg)
 	configs := sgw.GetConfig()
 	assert.Equal(t, []config.Gateway{expectedConfig}, configs)

go.mod

@@ -2,14 +2,18 @@ module github.com/42wim/matterbridge
 
 require (
 	github.com/42wim/go-gitter v0.0.0-20170828205020-017310c2d557
+	github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f
 	github.com/BurntSushi/toml v0.0.0-20170318202913-d94612f9fc14 // indirect
+	github.com/Jeffail/gabs v1.1.1 // indirect
 	github.com/Philipp15b/go-steam v1.0.1-0.20180818081528-681bd9573329
+	github.com/Rhymen/go-whatsapp v0.0.0-20190208184307-c9a81e957884
 	github.com/bwmarrin/discordgo v0.19.0
+	github.com/d5/tengo v1.9.2
 	github.com/dfordsoft/golib v0.0.0-20180902042739-76ee6ab99bec
 	github.com/fsnotify/fsnotify v1.4.7
 	github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible
-	github.com/golang/protobuf v0.0.0-20170613224224-e325f446bebc // indirect
 	github.com/google/gops v0.3.5
+	github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4 // indirect
 	github.com/gopherjs/gopherjs v0.0.0-20180628210949-0892b62f0d9f // indirect
 	github.com/gorilla/schema v1.0.2
 	github.com/gorilla/websocket v1.4.0
@@ -20,17 +24,19 @@ require (
 	github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/labstack/echo/v4 v4.0.0
-	github.com/lrstanley/girc v0.0.0-20190102153329-c1e59a02f488
+	github.com/lrstanley/girc v0.0.0-20190210212025-51b8e096d398
 	github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 // indirect
 	github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6 // indirect
+	github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20190210153444-cc9d05784d5d
 	github.com/matterbridge/go-xmpp v0.0.0-20180529212104-cd19799fba91
 	github.com/matterbridge/gomatrix v0.0.0-20190102230110-6f9631ca6dea
-	github.com/matterbridge/gozulipbot v0.0.0-20180507190239-b6bb12d33544
+	github.com/matterbridge/gozulipbot v0.0.0-20190212232658-7aa251978a18
 	github.com/matterbridge/logrus-prefixed-formatter v0.0.0-20180806162718-01618749af61
 	github.com/mattermost/mattermost-server v5.5.0+incompatible
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
 	github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474 // indirect
 	github.com/mrexodia/wray v0.0.0-20160318003008-78a2c1f284ff // indirect
+	github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9
 	github.com/nicksnyder/go-i18n v1.4.0 // indirect
 	github.com/nlopes/slack v0.5.0
 	github.com/onsi/ginkgo v1.6.0 // indirect
@@ -43,7 +49,6 @@ require (
 	github.com/russross/blackfriday v2.0.0+incompatible
 	github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca
 	github.com/shazow/ssh-chat v0.0.0-20190125184227-81d7e1686296
-	github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 // indirect
 	github.com/sirupsen/logrus v1.3.0
 	github.com/smartystreets/assertions v0.0.0-20180803164922-886ec427f6b9 // indirect
 	github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a // indirect
@@ -61,10 +66,8 @@ require (
 	go.uber.org/atomic v1.3.2 // indirect
 	go.uber.org/multierr v1.1.0 // indirect
 	go.uber.org/zap v1.9.1 // indirect
-	golang.org/x/net v0.0.0-20180108090419-434ec0c7fe37 // indirect
-	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/fsnotify.v1 v1.4.7 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
+	maunium.net/go/mautrix-whatsapp v0.0.0-20190127121751-281b3e8f77f3
 )

go.sum

@@ -1,9 +1,17 @@
 github.com/42wim/go-gitter v0.0.0-20170828205020-017310c2d557 h1:IZtuWGfzQnKnCSu+vl8WGLhpVQ5Uvy3rlSwqXSg+sQg=
 github.com/42wim/go-gitter v0.0.0-20170828205020-017310c2d557/go.mod h1:jL0YSXMs/txjtGJ4PWrmETOk6KUHMDPMshgQZlTeB3Y=
+github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f h1:2dk3eOnYllh+wUOuDhOoC2vUVoJF/5z478ryJ+wzEII=
+github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f/go.mod h1:4a58ifQTEe2uwwsaqbh3i2un5/CBPg+At/qHpt18Tmk=
 github.com/BurntSushi/toml v0.0.0-20170318202913-d94612f9fc14 h1:v/zr4ns/4sSahF9KBm4Uc933bLsEEv7LuT63CJ019yo=
 github.com/BurntSushi/toml v0.0.0-20170318202913-d94612f9fc14/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/Jeffail/gabs v1.1.1 h1:V0uzR08Hj22EX8+8QMhyI9sX2hwRu+/RJhJUmnwda/E=
+github.com/Jeffail/gabs v1.1.1/go.mod h1:6xMvQMK4k33lb7GUUpaAPh6nKMmemQeg5d4gn7/bOXc=
 github.com/Philipp15b/go-steam v1.0.1-0.20180818081528-681bd9573329 h1:xZBoq249G9MSt+XuY7sVQzcfONJ6IQuwpCK+KAaOpnY=
 github.com/Philipp15b/go-steam v1.0.1-0.20180818081528-681bd9573329/go.mod h1:HuVM+sZFzumUdKPWiz+IlCMb4RdsKdT3T+nQBKL+sYg=
+github.com/Rhymen/go-whatsapp v0.0.0-20181218094654-2ca6af00572c h1:ldRXgMEfKmzBomrZusl3edG9AGEeztA7jovLEQy62us=
+github.com/Rhymen/go-whatsapp v0.0.0-20181218094654-2ca6af00572c/go.mod h1:MSDmePOOkbFFbVW2WRRppBcbA+aabwpXRgyIIG7jDFQ=
+github.com/Rhymen/go-whatsapp v0.0.0-20190208184307-c9a81e957884 h1:2AxfzkQi2L4QGBvUCZoWD6hQuUJa5MG54wiYyNqJlf4=
+github.com/Rhymen/go-whatsapp v0.0.0-20190208184307-c9a81e957884/go.mod h1:rdQr95g2C1xcOfM7QGOhza58HeI3I+tZ/bbluv7VazA=
 github.com/alexcesaro/log v0.0.0-20150915221235-61e686294e58 h1:MkpmYfld/S8kXqTYI68DfL8/hHXjHogL120Dy00TIxc=
 github.com/alexcesaro/log v0.0.0-20150915221235-61e686294e58/go.mod h1:YNfsMyWSs+h+PaYkxGeMVmVCX75Zj/pqdjbu12ciCYE=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
@@ -12,6 +20,8 @@ github.com/bwmarrin/discordgo v0.19.0/go.mod h1:O9S4p+ofTFwB02em7jkpkV8M3R0/PUVO
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/d5/tengo v1.9.2 h1:UE/X8PYl7bLS4Ww2zGeh91nq5PTnkhe8ncgNeA5PK7k=
+github.com/d5/tengo v1.9.2/go.mod h1:gsbjo7lBXzBIWBd6NQp1lRKqqiDDANqBOyhW8rTlFsY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -19,16 +29,20 @@ github.com/dfordsoft/golib v0.0.0-20180902042739-76ee6ab99bec h1:JEUiu7P9smN7zgX
 github.com/dfordsoft/golib v0.0.0-20180902042739-76ee6ab99bec/go.mod h1:UGa5M2Sz/Uh13AMse4+RELKCDw7kqgqlTjeGae+7vUY=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible h1:i64CCJcSqkRIkm5OSdZQjZq84/gJsk2zNwHWIRYWlKE=
 github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM=
-github.com/golang/protobuf v0.0.0-20170613224224-e325f446bebc h1:wdhDSKrkYy24mcfzuA3oYm58h0QkyXjwERCkzJDP5kA=
-github.com/golang/protobuf v0.0.0-20170613224224-e325f446bebc/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/gops v0.3.5 h1:SIWvPLiYvy5vMwjxB3rVFTE4QBhUFj2KKWr3Xm7CKhw=
 github.com/google/gops v0.3.5/go.mod h1:pMQgrscwEK/aUSW1IFSaBPbJX82FPHWaSoJw1axQfD0=
+github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4 h1:4EZlYQIiyecYJlUbVkFXCXHz1QPhVXcHnQKAzBTPfQo=
+github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4/go.mod h1:lEO7XoHJ/xNRBCxrn4h/CEB67h0kW1B0t4ooP2yrjUA=
 github.com/gopherjs/gopherjs v0.0.0-20180628210949-0892b62f0d9f h1:FDM3EtwZLyhW48YRiyqjivNlNZjAObv4xt4NnJaU+NQ=
 github.com/gopherjs/gopherjs v0.0.0-20180628210949-0892b62f0d9f/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/schema v1.0.2 h1:sAgNfOcNYvdDSrzGHVy9nzCQahG+qmsg+nE8dK85QRA=
 github.com/gorilla/schema v1.0.2/go.mod h1:kgLaKoK1FELgZqMAVxx/5cbj0kT+57qxUrAlIO2eleU=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
@@ -58,20 +72,22 @@ github.com/labstack/echo/v4 v4.0.0 h1:q1GH+caIXPP7H2StPIdzy/ez9CO0EepqYeUg6vi9SW
 github.com/labstack/echo/v4 v4.0.0/go.mod h1:tZv7nai5buKSg5h/8E6zz4LsD/Dqh9/91Mvs7Z5Zyno=
 github.com/labstack/gommon v0.2.8 h1:JvRqmeZcfrHC5u6uVleB4NxxNbzx6gpbJiQknDbKQu0=
 github.com/labstack/gommon v0.2.8/go.mod h1:/tj9csK2iPSBvn+3NLM9e52usepMtrd5ilFYA+wQNJ4=
-github.com/lrstanley/girc v0.0.0-20190102153329-c1e59a02f488 h1:dDEQN5oaa0WOzEiPDSbOugW/e2I/SWY98HYRdcwmGfY=
-github.com/lrstanley/girc v0.0.0-20190102153329-c1e59a02f488/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk=
+github.com/lrstanley/girc v0.0.0-20190210212025-51b8e096d398 h1:a40kRmhA1p2XFJ6gqXfCExSyuDDCp/U9LA8ZY27u2Lk=
+github.com/lrstanley/girc v0.0.0-20190210212025-51b8e096d398/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk=
 github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 h1:AsEBgzv3DhuYHI/GiQh2HxvTP71HCCE9E/tzGUzGdtU=
 github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5/go.mod h1:c2mYKRyMb1BPkO5St0c/ps62L4S0W2NAkaTXj9qEI+0=
 github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6 h1:iOAVXzZyXtW408TMYejlUPo6BIn92HmOacWtIfNyYns=
 github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6/go.mod h1:sFlOUpQL1YcjhFVXhg1CG8ZASEs/Mf1oVb6H75JL/zg=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20190210153444-cc9d05784d5d h1:F+Sr+C0ojSlYQ37BLylQtSFmyQULe3jbAygcyXQ9mVs=
+github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20190210153444-cc9d05784d5d/go.mod h1:c6MxwqHD+0HvtAJjsHMIdPCiAwGiQwPRPTp69ACMg8A=
 github.com/matterbridge/go-xmpp v0.0.0-20180529212104-cd19799fba91 h1:KzDEcy8eDbTx881giW8a6llsAck3e2bJvMyKvh1IK+k=
 github.com/matterbridge/go-xmpp v0.0.0-20180529212104-cd19799fba91/go.mod h1:ECDRehsR9TYTKCAsRS8/wLeOk6UUqDydw47ln7wG41Q=
 github.com/matterbridge/gomatrix v0.0.0-20190102230110-6f9631ca6dea h1:kaADGqpK4gGO2BpzEyJrBxq2Jc57Rsar4i2EUxcACUc=
 github.com/matterbridge/gomatrix v0.0.0-20190102230110-6f9631ca6dea/go.mod h1:+jWeaaUtXQbBRdKYWfjW6JDDYiI2XXE+3NnTjW5kg8g=
-github.com/matterbridge/gozulipbot v0.0.0-20180507190239-b6bb12d33544 h1:A8lLG3DAu75B5jITHs9z4JBmU6oCq1WiUNnDAmqKCZc=
-github.com/matterbridge/gozulipbot v0.0.0-20180507190239-b6bb12d33544/go.mod h1:yAjnZ34DuDyPHMPHHjOsTk/FefW4JJjoMMCGt/8uuQA=
+github.com/matterbridge/gozulipbot v0.0.0-20190212232658-7aa251978a18 h1:fLhwXtWGtfTgZVxHG1lcKjv+re7dRwyyuYFNu69xdho=
+github.com/matterbridge/gozulipbot v0.0.0-20190212232658-7aa251978a18/go.mod h1:yAjnZ34DuDyPHMPHHjOsTk/FefW4JJjoMMCGt/8uuQA=
 github.com/matterbridge/logrus-prefixed-formatter v0.0.0-20180806162718-01618749af61 h1:R/MgM/eUyRBQx2FiH6JVmXck8PaAuKfe2M1tWIzW7nE=
 github.com/matterbridge/logrus-prefixed-formatter v0.0.0-20180806162718-01618749af61/go.mod h1:iXGEotOvwI1R1SjLxRc+BF5rUORTMtE0iMZBT2lxqAU=
 github.com/mattermost/mattermost-server v5.5.0+incompatible h1:0wcLGgYtd+YImtLDPf2AOfpBHxbU4suATx+6XKw1XbU=
@@ -80,6 +96,7 @@ github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRU
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
@@ -88,6 +105,8 @@ github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474 h1:oKIteT
 github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474/go.mod h1:OQA4XLvDbMgS8P0CevmM4m9Q3Jq4phKUzcocxuGJ5m8=
 github.com/mrexodia/wray v0.0.0-20160318003008-78a2c1f284ff h1:HLGD5/9UxxfEuO9DtP8gnTmNtMxbPyhYltfxsITel8g=
 github.com/mrexodia/wray v0.0.0-20160318003008-78a2c1f284ff/go.mod h1:B8jLfIIPn2sKyWr0D7cL2v7tnrDD5z291s2Zypdu89E=
+github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9 h1:mp6tU1r0xLostUGLkTspf/9/AiHuVD7ptyXhySkDEsE=
+github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9/go.mod h1:A5SRAcpTemjGgIuBq6Kic2yHcoeUFWUinOAlMP/i9xo=
 github.com/nicksnyder/go-i18n v1.4.0 h1:AgLl+Yq7kg5OYlzCgu9cKTZOyI4tD/NgukKqLqC8E+I=
 github.com/nicksnyder/go-i18n v1.4.0/go.mod h1:HrK7VCrbOvQoUAQ7Vpy7i87N7JZZZ7R2xBGjv0j365Q=
 github.com/nlopes/slack v0.5.0 h1:NbIae8Kd0NpqaEI3iUrsuS0KbcEDhzhc939jLW5fNm0=
@@ -112,16 +131,20 @@ github.com/rs/xid v1.2.1 h1:mhH9Nq+C1fY2l1XIpgxIiUOfNpRBYH1kKcr+qfKgjRc=
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/russross/blackfriday v2.0.0+incompatible h1:cBXrhZNUf9C+La9/YpS+UHpUT8YD6Td9ZMSU9APFcsk=
 github.com/russross/blackfriday v2.0.0+incompatible/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca h1:NugYot0LIVPxTvN8n+Kvkn6TrbMyxQiuvKdEwFdR9vI=
 github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca/go.mod h1:uugorj2VCxiV1x+LzaIdVa9b4S4qGAcH6cbhh4qVxOU=
 github.com/shazow/rateio v0.0.0-20150116013248-e8e00881e5c1 h1:Lx3BlDGFElJt4u/zKc9A3BuGYbQAGlEFyPuUA3jeMD0=
 github.com/shazow/rateio v0.0.0-20150116013248-e8e00881e5c1/go.mod h1:vt2jWY/3Qw1bIzle5thrJWucsLuuX9iUNnp20CqCciI=
 github.com/shazow/ssh-chat v0.0.0-20190125184227-81d7e1686296 h1:8RLq547MSVc6vhOuCl4Ca0TsAQknj6NX6ZLSZ3+xmio=
 github.com/shazow/ssh-chat v0.0.0-20190125184227-81d7e1686296/go.mod h1:1GLXsL4esywkpNId3v4QWuMf3THtWGitWvtQ/L3aSA4=
-github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 h1:/vdW8Cb7EXrkqWGufVMES1OH2sU9gKVb2n9/1y5NMBY=
-github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.3.0 h1:hI/7Q+DtNZ2kINb6qt/lS+IyXnHQe9e90POfeewL/ME=
 github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/skip2/go-qrcode v0.0.0-20171229120447-cf5f9fa2f0d8/go.mod h1:PLPIyL7ikehBD1OAjmKKiOEhbvWyHGaNDjquXMcYABo=
+github.com/skip2/go-qrcode v0.0.0-20190110000554-dc11ecdae0a9 h1:lpEzuenPuO1XNTeikEmvqYFcU37GVLl8SRNblzyvGBE=
+github.com/skip2/go-qrcode v0.0.0-20190110000554-dc11ecdae0a9/go.mod h1:PLPIyL7ikehBD1OAjmKKiOEhbvWyHGaNDjquXMcYABo=
 github.com/smartystreets/assertions v0.0.0-20180803164922-886ec427f6b9 h1:lXQ+j+KwZcbwrbgU0Rp4Eglg3EJLHbuZU3BbOqAGBmg=
 github.com/smartystreets/assertions v0.0.0-20180803164922-886ec427f6b9/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a h1:JSvGDIbmil4Ui/dDdFBExb7/cmkNjyX5F97oglmvCDo=
@@ -177,14 +200,20 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16 h1:y6ce7gCWtnH+m3dCjzQ1PCuwl28DDIc3VNnvY29DlIA=
 golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190103213133-ff983b9c42bc/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664 h1:YbZJ76lQ1BqNhVe7dKTSB67wDrc2VPRR75IyGyyPDX8=
 golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20180108090419-434ec0c7fe37 h1:BkNcmLtAVeWe9h5k0jt24CQgaG5vb4x/doFbAiEC/Ho=
-golang.org/x/net v0.0.0-20180108090419-434ec0c7fe37/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613 h1:MQ/ZZiDsUapFFiMS+vzwXkCTeEKaum+Do5rINYJDmxc=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20190110200230-915654e7eabc h1:Yx9JGxI1SBhVLFjpAkWMaO1TF+xyqtHLjZpvQboJGiM=
+golang.org/x/net v0.0.0-20190110200230-915654e7eabc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181212120007-b05ddf57801d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190109145017-48ac38b7c8cb/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc h1:WiYx1rIFmx8c0mXAFtv5D/mHyKe1+jmuP7PViuwqwuQ=
 golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
@@ -200,3 +229,9 @@ gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkep
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+maunium.net/go/mauflag v1.0.0/go.mod h1:nLivPOpTpHnpzEh8jEdSL9UqO9+/KBJFmNRlwKfkPeA=
+maunium.net/go/maulogger/v2 v2.0.0/go.mod h1:Hbbkq3NV6jvJodByZu1mgEF3fpT7Kz9z0MjEZ3/BusI=
+maunium.net/go/mautrix v0.1.0-alpha.3/go.mod h1:GTVu6WDHR+98DKOrYetWsXorvUeKQV3jsSWO6ScbuFI=
+maunium.net/go/mautrix-appservice v0.1.0-alpha.3/go.mod h1:wOnWOIuprYad7ly12rHIo3JLCPh4jwvx1prVrAB9RhM=
+maunium.net/go/mautrix-whatsapp v0.0.0-20190127121751-281b3e8f77f3 h1:A18t5Lp7I3aK0V7B7zdpb0hb/PBlu0X/Ai2AyU/XEk4=
+maunium.net/go/mautrix-whatsapp v0.0.0-20190127121751-281b3e8f77f3/go.mod h1:r5E3J4urDEsjfui9OYZYMLBfCliaAqcCwM2xeczta6k=

matterbridge.go

@@ -15,48 +15,71 @@ import (
 )
 
 var (
-	version = "1.13.1"
+	version = "1.14.0-rc1"
 	githash string
+
+	flagConfig  = flag.String("conf", "matterbridge.toml", "config file")
+	flagDebug   = flag.Bool("debug", false, "enable debug")
+	flagVersion = flag.Bool("version", false, "show version")
+	flagGops    = flag.Bool("gops", false, "enable gops agent")
 )
 
 func main() {
-	logrus.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: true})
-	flog := logrus.WithFields(logrus.Fields{"prefix": "main"})
-	flagConfig := flag.String("conf", "matterbridge.toml", "config file")
-	flagDebug := flag.Bool("debug", false, "enable debug")
-	flagVersion := flag.Bool("version", false, "show version")
-	flagGops := flag.Bool("gops", false, "enable gops agent")
 	flag.Parse()
-	if *flagGops {
-		if err := agent.Listen(agent.Options{}); err != nil {
-			flog.Errorf("failed to start gops agent: %#v", err)
-		} else {
-			defer agent.Close()
-		}
-	}
 	if *flagVersion {
 		fmt.Printf("version: %s %s\n", version, githash)
 		return
 	}
-	if *flagDebug || os.Getenv("DEBUG") == "1" {
-		logrus.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false, ForceFormatting: true})
-		flog.Info("Enabling debug")
-		logrus.SetLevel(logrus.DebugLevel)
+
+	rootLogger := setupLogger()
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "main"})
+
+	if *flagGops {
+		if err := agent.Listen(agent.Options{}); err != nil {
+			logger.Errorf("Failed to start gops agent: %#v", err)
+		} else {
+			defer agent.Close()
+		}
 	}
-	flog.Printf("Running version %s %s", version, githash)
+
+	logger.Printf("Running version %s %s", version, githash)
 	if strings.Contains(version, "-dev") {
-		flog.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
+		logger.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
 	}
-	cfg := config.NewConfig(*flagConfig)
+
+	cfg := config.NewConfig(rootLogger, *flagConfig)
 	cfg.BridgeValues().General.Debug = *flagDebug
-	r, err := gateway.NewRouter(cfg, bridgemap.FullMap)
+
+	r, err := gateway.NewRouter(rootLogger, cfg, bridgemap.FullMap)
 	if err != nil {
-		flog.Fatalf("Starting gateway failed: %s", err)
+		logger.Fatalf("Starting gateway failed: %s", err)
 	}
-	err = r.Start()
-	if err != nil {
-		flog.Fatalf("Starting gateway failed: %s", err)
+	if err = r.Start(); err != nil {
+		logger.Fatalf("Starting gateway failed: %s", err)
 	}
-	flog.Printf("Gateway(s) started succesfully. Now relaying messages")
+	logger.Printf("Gateway(s) started succesfully. Now relaying messages")
 	select {}
 }
+
+func setupLogger() *logrus.Logger {
+	logger := &logrus.Logger{
+		Out: os.Stdout,
+		Formatter: &prefixed.TextFormatter{
+			PrefixPadding: 13,
+			DisableColors: true,
+			FullTimestamp: true,
+		},
+		Level: logrus.InfoLevel,
+	}
+	if *flagDebug || os.Getenv("DEBUG") == "1" {
+		logger.Formatter = &prefixed.TextFormatter{
+			PrefixPadding:   13,
+			DisableColors:   true,
+			FullTimestamp:   false,
+			ForceFormatting: true,
+		}
+		logger.Level = logrus.DebugLevel
+		logger.WithFields(logrus.Fields{"prefix": "main"}).Info("Enabling debug logging.")
+	}
+	return logger
+}

matterbridge.toml.sample

@@ -102,6 +102,7 @@ ColorNicks=false
 RunCommands=["PRIVMSG user hello","PRIVMSG chanserv something"]
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -129,6 +130,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -139,7 +151,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -196,6 +208,7 @@ SkipTLSVerify=true
 ## Settings below can be reloaded by editing the file
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -223,6 +236,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #OPTIONAL (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -232,7 +256,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -276,6 +300,7 @@ Nick="yourlogin"
 ## Settings below can be reloaded by editing the file
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="spammer1 spammer2"
@@ -303,6 +328,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -312,7 +348,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -416,6 +452,7 @@ EditDisable=false
 EditSuffix=" (edited)"
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -443,6 +480,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -452,7 +500,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -491,6 +539,7 @@ Token="Yourtokenhere"
 ## Settings below can be reloaded by editing the file
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -518,6 +567,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -527,7 +587,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -557,6 +617,10 @@ ShowTopicChange=false
 #REQUIRED (when not using webhooks)
 Token="yourslacktoken"
 
+#Extra slack specific debug info, warning this generates a lot of output.
+#OPTIONAL (default false)
+Debug="false"
+
 #### Settings for webhook matterbridge.
 #NOT RECOMMENDED TO USE INCOMING/OUTGOING WEBHOOK. USE SLACK API
 #AND DEDICATED BOT USER WHEN POSSIBLE!
@@ -609,6 +673,7 @@ EditSuffix=" (edited)"
 PrefixMessagesWithNick=false
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -636,6 +701,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -645,7 +721,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -704,10 +780,14 @@ Server="yourservername"
 #OPTIONAL (default false)
 ShowEmbeds=false
 
-#Shows the username (minus the discriminator) instead of the server nickname
+#Shows the username instead of the server nickname
 #OPTIONAL (default false)
 UseUserName=false
 
+#Show #xxxx discriminator with UseUserName
+#OPTIONAL (default false)
+UseDiscriminator=false
+
 #Specify WebhookURL. If given, will relay messages using the Webhook, which gives a better look to messages.
 #This only works if you have one discord channel, if you have multiple discord channels you'll have to specify it in the gateway config
 #OPTIONAL (default empty)
@@ -722,6 +802,7 @@ EditDisable=false
 EditSuffix=" (edited)"
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -749,6 +830,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -758,7 +850,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -830,6 +922,7 @@ EditDisable=false
 EditSuffix=" (edited)"
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="spammer1 spammer2"
@@ -857,6 +950,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -870,7 +974,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -893,6 +997,21 @@ ShowTopicChange=false
 #REQUIRED
 
 [rocketchat.rockme]
+#The rocketchat hostname. (prefix it with http or https)
+#REQUIRED (when not using webhooks)
+Server="https://yourrocketchatserver.domain.com:443"
+
+#login/pass of your bot. 
+#Use a dedicated user for this and not your own! 
+#REQUIRED (when not using webhooks)
+Login="yourlogin"
+Password="yourpass"
+
+#### Settings for webhook matterbridge.
+#USE DEDICATED BOT USER WHEN POSSIBLE! This allows you to use advanced features like message editing/deleting and uploads
+#You don't need to configure this, if you have configured the settings 
+#above.
+
 #Url is your incoming webhook url as specified in rocketchat
 #Read #https://rocket.chat/docs/administrator-guides/integrations/#how-to-create-a-new-incoming-webhook
 #See administration - integrations - new integration - incoming webhook
@@ -917,6 +1036,8 @@ NoTLS=false
 #OPTIONAL (default false)
 SkipTLSVerify=true
 
+#### End settings for webhook matterbridge.
+
 ## RELOADABLE SETTINGS
 ## Settings below can be reloaded by editing the file
 
@@ -928,6 +1049,7 @@ SkipTLSVerify=true
 PrefixMessagesWithNick=false
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="ircspammer1 ircspammer2"
@@ -955,6 +1077,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -964,7 +1097,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -1014,6 +1147,7 @@ NoHomeServerSuffix=false
 PrefixMessagesWithNick=false
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="spammer1 spammer2"
@@ -1041,6 +1175,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -1050,7 +1195,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -1094,6 +1239,7 @@ Authcode="ABCE12"
 PrefixMessagesWithNick=false
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="spammer1 spammer2"
@@ -1121,6 +1267,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -1130,7 +1287,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -1144,10 +1301,45 @@ StripNick=false
 #OPTIONAL (default false)
 ShowTopicChange=false
 
+
+
 ###################################################################
-#zulip section
+#
+# WhatsApp
+#
 ###################################################################
+
+[whatsapp.bridge]
+
+# Number you will use as a relay bot. Tip: Get some disposable sim card, don't rely on your own number.
+Number="+48111222333"
+
+# First time that you login you will need to scan QR code, then credentials willl be saved in a session file
+# If you won't set SessionFile then you will need to scan QR code on every restart
+# optional (by default the session is stored only in memory, till restarting matterbridge)
+SessionFile="session-48111222333.gob"
+
+# If your terminal is white we need to invert QR code in order for it to be scanned properly
+# optional (default false)
+QrOnWhiteTerminal=true
+
+# Messages will be seen by other WhatsApp contacts as coming from the bridge. Original nick will be part of the message.
+RemoteNickFormat="@{NICK}: "
+
+# extra label that can be used in the RemoteNickFormat
+# optional (default empty)
+Label="Organization"
+
+
+
+###################################################################
+#
+# zulip
+#
+###################################################################
+
 [zulip]
+
 #You can configure multiple servers "[zulip.name]" or "[zulip.name2]"
 #In this example we use [zulip.streamchat]
 #REQUIRED
@@ -1168,12 +1360,15 @@ Server="https://yourserver.zulipchat.com"
 
 #Topic of the messages matterbridge will use
 #OPTIONAL (default "matterbridge")
+#You can specify a specific topic for each channel using [gateway.inout.options]
+#See more information below at the gateway configuration
 Topic="matterbridge"
 
 ## RELOADABLE SETTINGS
 ## Settings below can be reloaded by editing the file
 
 #Nicks you want to ignore. 
+#Regular expressions supported
 #Messages from those users will not be sent to other bridges.
 #OPTIONAL
 IgnoreNicks="spammer1 spammer2"
@@ -1201,6 +1396,17 @@ ReplaceMessages=[ ["cat","dog"] ]
 #optional (default empty)
 ReplaceNicks=[ ["user--","user"] ]
 
+#Extractnicks is used to for example rewrite messages from other relaybots
+#See https://github.com/42wim/matterbridge/issues/713 and https://github.com/42wim/matterbridge/issues/466
+#some examples:
+#this replaces a message like "Relaybot: <relayeduser> something interesting" to "relayeduser: something interesting"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ] ]
+#you can use multiple entries for multiplebots
+#this also replaces a message like "otherbot: (relayeduser) something else" to "relayeduser: something else"
+#ExtractNicks=[ [ "Relaybot", "<(.*?)>\\s+" ],[ "otherbot","\\((.*?)\\)\\s+" ]
+#OPTIONAL (default empty)
+ExtractNicks=[ ["otherbot","<(.*?)>\\s+" ] ]
+
 #extra label that can be used in the RemoteNickFormat
 #optional (default empty)
 Label=""
@@ -1210,7 +1416,7 @@ Label=""
 RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 #Enable to show users joins/parts from other bridges 
-#Currently works for messages from the following bridges: irc, mattermost, slack
+#Currently works for messages from the following bridges: irc, mattermost, slack, discord
 #OPTIONAL (default false)
 ShowJoinPart=false
 
@@ -1321,6 +1527,29 @@ MediaDownloadBlacklist=[".html$",".htm$"]
 #OPTIONAL (default false)
 IgnoreFailureOnStart=false
 
+
+#TengoModifyMessage allows you to specify the location of a tengo (https://github.com/d5/tengo/) script.
+#This script will receive every incoming message and can be used to modify the Username and the Text of that message.
+#The script will have the following global variables:
+#to modify: msgUsername and msgText
+#to read: msgChannel and msgAccount
+#
+#The script is reloaded on every message, so you can modify the script on the fly.
+#
+#Example script can be found in https://github.com/42wim/matterbridge/tree/master/gateway/bench.tengo
+#and https://github.com/42wim/matterbridge/tree/master/contrib/example.tengo
+#
+#The example below will check if the text contains blah and if so, it'll replace the text and the username of that message.
+#text := import("text")
+#if text.re_match("blah",msgText) {
+#    msgText="replaced by this"
+#    msgUsername="fakeuser"
+#}
+#More information about tengo on: https://github.com/d5/tengo/blob/master/docs/tutorial.md and
+#https://github.com/d5/tengo/blob/master/docs/stdlib.md
+#OPTIONAL (default empty)
+TengoModifyMessage="example.tengo"
+
 ###################################################################
 #Gateway configuration
 ###################################################################
@@ -1342,36 +1571,41 @@ name="gateway1"
 ##OPTIONAL (default false)
 enable=true
 
-    #[[gateway.in]] specifies the account and channels we will receive messages from.
-    #The following example bridges between mattermost and irc
+    # [[gateway.in]] specifies the account and channels we will receive messages from.
+    # The following example bridges between mattermost and irc
     [[gateway.in]]
 
-    #account specified above
-    #REQUIRED
+    # account specified above
+    # REQUIRED
     account="irc.freenode"
-    #channel to connect on that account
-    #How to specify them for the different bridges:
+
+    # channel to connect on that account
+    # How to specify them for the different bridges:
     #
-    #irc        - #channel (# is required) (this needs to be lowercase!)
-    #mattermost - channel (the channel name as seen in the URL, not the displayname)
-    #gitter     - username/room 
-    #xmpp       - channel
-    #slack      - channel (without the #)
-    #           - ID:C123456 (where C123456 is the channel ID) does not work with webhook
-    #discord    - channel (without the #)
-    #           - ID:123456789 (where 123456789 is the channel ID) 
+    # irc        - #channel (# is required) (this needs to be lowercase!)
+    # mattermost - channel (the channel name as seen in the URL, not the displayname)
+    # gitter     - username/room
+    # xmpp       - channel
+    # slack      - channel (without the #)
+    #            - ID:C123456 (where C123456 is the channel ID) does not work with webhook
+    # discord    - channel (without the #)
+    #            - ID:123456789 (where 123456789 is the channel ID)
     #               (https://github.com/42wim/matterbridge/issues/57)
-    #telegram   - chatid (a large negative number, eg -123456789)
+    # telegram   - chatid (a large negative number, eg -123456789)
     #             see (https://www.linkedin.com/pulse/telegram-bots-beginners-marco-frau)
-    #hipchat    - id_channel (see https://www.hipchat.com/account/xmpp for the correct channel)
-    #rocketchat - #channel (# is required (also needed for private channels!)
-    #matrix     - #channel:server (eg #yourchannel:matrix.org) 
-    #           - encrypted rooms are not supported in matrix
-    #steam      - chatid (a large number). 
+    # hipchat    - id_channel (see https://www.hipchat.com/account/xmpp for the correct channel)
+    # rocketchat - #channel (# is required (also needed for private channels!)
+    # matrix     - #channel:server (eg #yourchannel:matrix.org)
+    #            - encrypted rooms are not supported in matrix
+    # steam      - chatid (a large number).
     #             The number in the URL when you click "enter chat room" in the browser
-    #zulip      - stream (without the #)
+    # whatsapp   - 48111222333-123455678999@g.us A unique group JID;
+    #              if you specify an empty string bridge will list all the possibilities
+    #            - "Group Name" if you specify a group name the bridge will hint its JID to specify
+    #              as group names might change in time and contain weird emoticons
+    # zulip      - stream (without the #)
     #                  
-    #REQUIRED
+    # REQUIRED
     channel="#testing"
 
         #OPTIONAL - only used for IRC and XMPP protocols at the moment
@@ -1409,6 +1643,13 @@ enable=true
         [gateway.inout.options]
         webhookurl="https://discordapp.com/api/webhooks/123456789123456789/C9WPqExYWONPDZabcdef-def1434FGFjstasJX9pYht73y"
 
+    [[gateway.inout]]
+    account="zulip.streamchat"
+    channel="general"
+        #OPTIONAL - topic only works for zulip
+        [gateway.inout.options]
+        topic="topic1"
+
     #API example
     #[[gateway.inout]]
     #account="api.local"

matterclient/channels.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	"github.com/mattermost/mattermost-server/model"
-	"github.com/sirupsen/logrus"
 )
 
 // GetChannels returns all channels we're members off
@@ -155,11 +154,11 @@ func (m *MMClient) JoinChannel(channelId string) error { //nolint:golint
 	defer m.RUnlock()
 	for _, c := range m.Team.Channels {
 		if c.Id == channelId {
-			m.log.Debug("Not joining ", channelId, " already joined.")
+			m.logger.Debug("Not joining ", channelId, " already joined.")
 			return nil
 		}
 	}
-	m.log.Debug("Joining ", channelId)
+	m.logger.Debug("Joining ", channelId)
 	_, resp := m.Client.AddChannelMember(channelId, m.User.Id)
 	if resp.Error != nil {
 		return resp.Error
@@ -189,19 +188,19 @@ func (m *MMClient) UpdateChannels() error {
 
 func (m *MMClient) UpdateChannelHeader(channelId string, header string) { //nolint:golint
 	channel := &model.Channel{Id: channelId, Header: header}
-	m.log.Debugf("updating channelheader %#v, %#v", channelId, header)
+	m.logger.Debugf("updating channelheader %#v, %#v", channelId, header)
 	_, resp := m.Client.UpdateChannel(channel)
 	if resp.Error != nil {
-		logrus.Error(resp.Error)
+		m.logger.Error(resp.Error)
 	}
 }
 
 func (m *MMClient) UpdateLastViewed(channelId string) error { //nolint:golint
-	m.log.Debugf("posting lastview %#v", channelId)
+	m.logger.Debugf("posting lastview %#v", channelId)
 	view := &model.ChannelView{ChannelId: channelId}
 	_, resp := m.Client.ViewChannel(m.User.Id, view)
 	if resp.Error != nil {
-		m.log.Errorf("ChannelView update for %s failed: %s", channelId, resp.Error)
+		m.logger.Errorf("ChannelView update for %s failed: %s", channelId, resp.Error)
 		return resp.Error
 	}
 	return nil

matterclient/helpers.go

@@ -22,7 +22,7 @@ func (m *MMClient) doLogin(firstConnection bool, b *backoff.Backoff) error {
 	var logmsg = "trying login"
 	var err error
 	for {
-		m.log.Debugf("%s %s %s %s", logmsg, m.Credentials.Team, m.Credentials.Login, m.Credentials.Server)
+		m.logger.Debugf("%s %s %s %s", logmsg, m.Credentials.Team, m.Credentials.Login, m.Credentials.Server)
 		if m.Credentials.Token != "" {
 			resp, err = m.doLoginToken()
 			if err != nil {
@@ -34,14 +34,14 @@ func (m *MMClient) doLogin(firstConnection bool, b *backoff.Backoff) error {
 		appErr = resp.Error
 		if appErr != nil {
 			d := b.Duration()
-			m.log.Debug(appErr.DetailedError)
+			m.logger.Debug(appErr.DetailedError)
 			if firstConnection {
 				if appErr.Message == "" {
 					return errors.New(appErr.DetailedError)
 				}
 				return errors.New(appErr.Message)
 			}
-			m.log.Debugf("LOGIN: %s, reconnecting in %s", appErr, d)
+			m.logger.Debugf("LOGIN: %s, reconnecting in %s", appErr, d)
 			time.Sleep(d)
 			logmsg = "retrying login"
 			continue
@@ -59,17 +59,17 @@ func (m *MMClient) doLoginToken() (*model.Response, error) {
 	m.Client.AuthType = model.HEADER_BEARER
 	m.Client.AuthToken = m.Credentials.Token
 	if m.Credentials.CookieToken {
-		m.log.Debugf(logmsg + " with cookie (MMAUTH) token")
+		m.logger.Debugf(logmsg + " with cookie (MMAUTH) token")
 		m.Client.HttpClient.Jar = m.createCookieJar(m.Credentials.Token)
 	} else {
-		m.log.Debugf(logmsg + " with personal token")
+		m.logger.Debugf(logmsg + " with personal token")
 	}
 	m.User, resp = m.Client.GetMe("")
 	if resp.Error != nil {
 		return resp, resp.Error
 	}
 	if m.User == nil {
-		m.log.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
+		m.logger.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
 		return resp, errors.New("invalid token")
 	}
 	return resp, nil
@@ -126,7 +126,7 @@ func (m *MMClient) initUser() error {
 	defer m.Unlock()
 	// we only load all team data on initial login.
 	// all other updates are for channels from our (primary) team only.
-	//m.log.Debug("initUser(): loading all team data")
+	//m.logger.Debug("initUser(): loading all team data")
 	teams, resp := m.Client.GetTeamsForUser(m.User.Id, "")
 	if resp.Error != nil {
 		return resp.Error
@@ -156,7 +156,7 @@ func (m *MMClient) initUser() error {
 		m.OtherTeams = append(m.OtherTeams, t)
 		if team.Name == m.Credentials.Team {
 			m.Team = t
-			m.log.Debugf("initUser(): found our team %s (id: %s)", team.Name, team.Id)
+			m.logger.Debugf("initUser(): found our team %s (id: %s)", team.Name, team.Id)
 		}
 		// add all users
 		for k, v := range t.Users {
@@ -180,10 +180,10 @@ func (m *MMClient) serverAlive(firstConnection bool, b *backoff.Backoff) error {
 		}
 		m.ServerVersion = resp.ServerVersion
 		if m.ServerVersion == "" {
-			m.log.Debugf("Server not up yet, reconnecting in %s", d)
+			m.logger.Debugf("Server not up yet, reconnecting in %s", d)
 			time.Sleep(d)
 		} else {
-			m.log.Infof("Found version %s", m.ServerVersion)
+			m.logger.Infof("Found version %s", m.ServerVersion)
 			return nil
 		}
 	}
@@ -207,7 +207,7 @@ func (m *MMClient) wsConnect() {
 	header := http.Header{}
 	header.Set(model.HEADER_AUTH, "BEARER "+m.Client.AuthToken)
 
-	m.log.Debugf("WsClient: making connection: %s", wsurl)
+	m.logger.Debugf("WsClient: making connection: %s", wsurl)
 	for {
 		wsDialer := &websocket.Dialer{
 			TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}, //nolint:gosec
@@ -217,14 +217,14 @@ func (m *MMClient) wsConnect() {
 		m.WsClient, _, err = wsDialer.Dial(wsurl, header)
 		if err != nil {
 			d := b.Duration()
-			m.log.Debugf("WSS: %s, reconnecting in %s", err, d)
+			m.logger.Debugf("WSS: %s, reconnecting in %s", err, d)
 			time.Sleep(d)
 			continue
 		}
 		break
 	}
 
-	m.log.Debug("WsClient: connected")
+	m.logger.Debug("WsClient: connected")
 	m.WsSequence = 1
 	m.WsPingChan = make(chan *model.WebSocketResponse)
 	// only start to parse WS messages when login is completely done
@@ -252,7 +252,7 @@ func (m *MMClient) checkAlive() error {
 	if resp.Error != nil {
 		return resp.Error
 	}
-	m.log.Debug("WS PING")
+	m.logger.Debug("WS PING")
 	return m.sendWSRequest("ping", nil)
 }
 
@@ -262,7 +262,7 @@ func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) err
 	req.Action = action
 	req.Data = data
 	m.WsSequence++
-	m.log.Debugf("sendWsRequest %#v", req)
+	m.logger.Debugf("sendWsRequest %#v", req)
 	return m.WsClient.WriteJSON(req)
 }
 

matterclient/matterclient.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
-	"github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/jpillora/backoff"
 	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
 	"github.com/mattermost/mattermost-server/model"
@@ -49,13 +49,13 @@ type Team struct {
 type MMClient struct {
 	sync.RWMutex
 	*Credentials
+
 	Team          *Team
 	OtherTeams    []*Team
 	Client        *model.Client4
 	User          *model.User
 	Users         map[string]*model.User
 	MessageChan   chan *Message
-	log           *logrus.Entry
 	WsClient      *websocket.Conn
 	WsQuit        bool
 	WsAway        bool
@@ -64,31 +64,61 @@ type MMClient struct {
 	WsPingChan    chan *model.WebSocketResponse
 	ServerVersion string
 	OnWsConnect   func()
-	lruCache      *lru.Cache
+
+	logger     *logrus.Entry
+	rootLogger *logrus.Logger
+	lruCache   *lru.Cache
 }
 
-func New(login, pass, team, server string) *MMClient {
-	cred := &Credentials{Login: login, Pass: pass, Team: team, Server: server}
-	mmclient := &MMClient{Credentials: cred, MessageChan: make(chan *Message, 100), Users: make(map[string]*model.User)}
-	logrus.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true})
-	mmclient.log = logrus.WithFields(logrus.Fields{"prefix": "matterclient"})
-	mmclient.lruCache, _ = lru.New(500)
-	return mmclient
+// New will instantiate a new Matterclient with the specified login details without connecting.
+func New(login string, pass string, team string, server string) *MMClient {
+	rootLogger := logrus.New()
+	rootLogger.SetFormatter(&prefixed.TextFormatter{
+		PrefixPadding: 13,
+		DisableColors: true,
+	})
+
+	cred := &Credentials{
+		Login:  login,
+		Pass:   pass,
+		Team:   team,
+		Server: server,
+	}
+
+	cache, _ := lru.New(500)
+	return &MMClient{
+		Credentials: cred,
+		MessageChan: make(chan *Message, 100),
+		Users:       make(map[string]*model.User),
+		rootLogger:  rootLogger,
+		lruCache:    cache,
+		logger:      rootLogger.WithFields(logrus.Fields{"prefix": "matterclient"}),
+	}
 }
 
+// SetDebugLog activates debugging logging on all Matterclient log output.
 func (m *MMClient) SetDebugLog() {
-	logrus.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false, ForceFormatting: true})
+	m.rootLogger.SetFormatter(&prefixed.TextFormatter{
+		PrefixPadding:   13,
+		DisableColors:   true,
+		FullTimestamp:   false,
+		ForceFormatting: true,
+	})
 }
 
+// SetLogLevel tries to parse the specified level and if successful sets
+// the log level accordingly. Accepted levels are: 'debug', 'info', 'warn',
+// 'error', 'fatal' and 'panic'.
 func (m *MMClient) SetLogLevel(level string) {
 	l, err := logrus.ParseLevel(level)
 	if err != nil {
-		logrus.SetLevel(logrus.InfoLevel)
-		return
+		m.logger.Warnf("Failed to parse specified log-level '%s': %#v", level, err)
+	} else {
+		m.rootLogger.SetLevel(l)
 	}
-	logrus.SetLevel(l)
 }
 
+// Login tries to connect the client with the loging details with which it was initialized.
 func (m *MMClient) Login() error {
 	// check if this is a first connect or a reconnection
 	firstConnection := true
@@ -131,13 +161,14 @@ func (m *MMClient) Login() error {
 	return nil
 }
 
+// Logout disconnects the client from the chat server.
 func (m *MMClient) Logout() error {
-	m.log.Debugf("logout as %s (team: %s) on %s", m.Credentials.Login, m.Credentials.Team, m.Credentials.Server)
+	m.logger.Debugf("logout as %s (team: %s) on %s", m.Credentials.Login, m.Credentials.Team, m.Credentials.Server)
 	m.WsQuit = true
 	m.WsClient.Close()
 	m.WsClient.UnderlyingConn().Close()
 	if strings.Contains(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN) {
-		m.log.Debug("Not invalidating session in logout, credential is a token")
+		m.logger.Debug("Not invalidating session in logout, credential is a token")
 		return nil
 	}
 	_, resp := m.Client.Logout()
@@ -147,13 +178,16 @@ func (m *MMClient) Logout() error {
 	return nil
 }
 
+// WsReceiver implements the core loop that manages the connection to the chat server. In
+// case of a disconnect it will try to reconnect. A call to this method is blocking until
+// the 'WsQuite' field of the MMClient object is set to 'true'.
 func (m *MMClient) WsReceiver() {
 	for {
 		var rawMsg json.RawMessage
 		var err error
 
 		if m.WsQuit {
-			m.log.Debug("exiting WsReceiver")
+			m.logger.Debug("exiting WsReceiver")
 			return
 		}
 
@@ -163,14 +197,14 @@ func (m *MMClient) WsReceiver() {
 		}
 
 		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
-			m.log.Error("error:", err)
+			m.logger.Error("error:", err)
 			// reconnect
 			m.wsConnect()
 		}
 
 		var event model.WebSocketEvent
 		if err := json.Unmarshal(rawMsg, &event); err == nil && event.IsValid() {
-			m.log.Debugf("WsReceiver event: %#v", event)
+			m.logger.Debugf("WsReceiver event: %#v", event)
 			msg := &Message{Raw: &event, Team: m.Credentials.Team}
 			m.parseMessage(msg)
 			// check if we didn't empty the message
@@ -189,40 +223,42 @@ func (m *MMClient) WsReceiver() {
 
 		var response model.WebSocketResponse
 		if err := json.Unmarshal(rawMsg, &response); err == nil && response.IsValid() {
-			m.log.Debugf("WsReceiver response: %#v", response)
+			m.logger.Debugf("WsReceiver response: %#v", response)
 			m.parseResponse(response)
-			continue
 		}
 	}
 }
 
+// StatusLoop implements a ping-cycle that ensures that the connection to the chat servers
+// remains alive. In case of a disconnect it will try to reconnect. A call to this method
+// is blocking until the 'WsQuite' field of the MMClient object is set to 'true'.
 func (m *MMClient) StatusLoop() {
 	retries := 0
 	backoff := time.Second * 60
 	if m.OnWsConnect != nil {
 		m.OnWsConnect()
 	}
-	m.log.Debug("StatusLoop:", m.OnWsConnect != nil)
+	m.logger.Debug("StatusLoop:", m.OnWsConnect != nil)
 	for {
 		if m.WsQuit {
 			return
 		}
 		if m.WsConnected {
 			if err := m.checkAlive(); err != nil {
-				logrus.Errorf("Connection is not alive: %#v", err)
+				m.logger.Errorf("Connection is not alive: %#v", err)
 			}
 			select {
 			case <-m.WsPingChan:
-				m.log.Debug("WS PONG received")
+				m.logger.Debug("WS PONG received")
 				backoff = time.Second * 60
 			case <-time.After(time.Second * 5):
 				if retries > 3 {
-					m.log.Debug("StatusLoop() timeout")
+					m.logger.Debug("StatusLoop() timeout")
 					m.Logout()
 					m.WsQuit = false
 					err := m.Login()
 					if err != nil {
-						logrus.Errorf("Login failed: %#v", err)
+						m.logger.Errorf("Login failed: %#v", err)
 						break
 					}
 					if m.OnWsConnect != nil {

matterclient/messages.go

@@ -10,14 +10,14 @@ func (m *MMClient) parseActionPost(rmsg *Message) {
 	// add post to cache, if it already exists don't relay this again.
 	// this should fix reposts
 	if ok, _ := m.lruCache.ContainsOrAdd(digestString(rmsg.Raw.Data["post"].(string)), true); ok {
-		m.log.Debugf("message %#v in cache, not processing again", rmsg.Raw.Data["post"].(string))
+		m.logger.Debugf("message %#v in cache, not processing again", rmsg.Raw.Data["post"].(string))
 		rmsg.Text = ""
 		return
 	}
 	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Data["post"].(string)))
 	// we don't have the user, refresh the userlist
 	if m.GetUser(data.UserId) == nil {
-		m.log.Infof("User '%v' is not known, ignoring message '%#v'",
+		m.logger.Infof("User '%v' is not known, ignoring message '%#v'",
 			data.UserId, data)
 		return
 	}
@@ -54,7 +54,7 @@ func (m *MMClient) parseMessage(rmsg *Message) {
 		}
 	case "group_added":
 		if err := m.UpdateChannels(); err != nil {
-			m.log.Errorf("failed to update channels: %#v", err)
+			m.logger.Errorf("failed to update channels: %#v", err)
 		}
 		/*
 			case model.ACTION_USER_REMOVED:
@@ -178,18 +178,18 @@ func (m *MMClient) SendDirectMessage(toUserId string, msg string, rootId string)
 }
 
 func (m *MMClient) SendDirectMessageProps(toUserId string, msg string, rootId string, props map[string]interface{}) { //nolint:golint
-	m.log.Debugf("SendDirectMessage to %s, msg %s", toUserId, msg)
+	m.logger.Debugf("SendDirectMessage to %s, msg %s", toUserId, msg)
 	// create DM channel (only happens on first message)
 	_, resp := m.Client.CreateDirectChannel(m.User.Id, toUserId)
 	if resp.Error != nil {
-		m.log.Debugf("SendDirectMessage to %#v failed: %s", toUserId, resp.Error)
+		m.logger.Debugf("SendDirectMessage to %#v failed: %s", toUserId, resp.Error)
 		return
 	}
 	channelName := model.GetDMNameFromIds(toUserId, m.User.Id)
 
 	// update our channels
 	if err := m.UpdateChannels(); err != nil {
-		m.log.Errorf("failed to update channels: %#v", err)
+		m.logger.Errorf("failed to update channels: %#v", err)
 	}
 
 	// build & send the message

matterclient/users.go

@@ -124,7 +124,7 @@ func (m *MMClient) UpdateUserNick(nick string) error {
 func (m *MMClient) UsernamesInChannel(channelId string) []string { //nolint:golint
 	res, resp := m.Client.GetChannelMembers(channelId, 0, 50000, "")
 	if resp.Error != nil {
-		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, resp.Error)
+		m.logger.Errorf("UsernamesInChannel(%s) failed: %s", channelId, resp.Error)
 		return []string{}
 	}
 	allusers := m.GetUsers()

vendor/github.com/Baozisoftware/qrcode-terminal-go/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

vendor/github.com/Baozisoftware/qrcode-terminal-go/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2017, Baozisoftware
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/Baozisoftware/qrcode-terminal-go/README.md

@@ -0,0 +1,39 @@
+
+# qrcode-terminal-go
+QRCode terminal for golang.
+
+# Example
+```go
+package main
+
+import "github.com/Baozisoftware/qrcode-terminal-go"
+
+func main() {
+	Test1()
+	Test2()
+}
+
+func Test1(){
+	content := "Hello, 世界"
+	obj := qrcodeTerminal.New()
+	obj.Get(content).Print()
+}
+
+func Test2(){
+	content := "https://github.com/Baozisoftware/qrcode-terminal-go"
+	obj := qrcodeTerminal.New2(qrcodeTerminal.ConsoleColors.BrightBlue,qrcodeTerminal.ConsoleColors.BrightGreen,qrcodeTerminal.QRCodeRecoveryLevels.Low)
+	obj.Get([]byte(content)).Print()
+}
+```
+
+## Screenshots
+### Windows XP
+![winxp](https://github.com/Baozisoftware/qrcode-terminal-go/blob/master/screenshots/winxp.png)
+### Windows 7
+![win7](https://github.com/Baozisoftware/qrcode-terminal-go/blob/master/screenshots/win7.png)
+### Windows 10
+![win10](https://github.com/Baozisoftware/qrcode-terminal-go/blob/master/screenshots/win10.png)
+### Ubuntu
+![ubuntu](https://github.com/Baozisoftware/qrcode-terminal-go/blob/master/screenshots/ubuntu.png)
+### macOS
+![macos](https://github.com/Baozisoftware/qrcode-terminal-go/blob/master/screenshots/macos.png)

vendor/github.com/Baozisoftware/qrcode-terminal-go/qrcodeTerminal.go

@@ -0,0 +1,155 @@
+package qrcodeTerminal
+
+import (
+	"fmt"
+
+	"github.com/skip2/go-qrcode"
+	"github.com/mattn/go-colorable"
+	"image/png"
+	nbytes "bytes"
+)
+
+type consoleColor string
+type consoleColors struct {
+	NormalBlack   consoleColor
+	NormalRed     consoleColor
+	NormalGreen   consoleColor
+	NormalYellow  consoleColor
+	NormalBlue    consoleColor
+	NormalMagenta consoleColor
+	NormalCyan    consoleColor
+	NormalWhite   consoleColor
+	BrightBlack   consoleColor
+	BrightRed     consoleColor
+	BrightGreen   consoleColor
+	BrightYellow  consoleColor
+	BrightBlue    consoleColor
+	BrightMagenta consoleColor
+	BrightCyan    consoleColor
+	BrightWhite   consoleColor
+}
+type qrcodeRecoveryLevel qrcode.RecoveryLevel
+type qrcodeRecoveryLevels struct {
+	Low     qrcodeRecoveryLevel
+	Medium  qrcodeRecoveryLevel
+	High    qrcodeRecoveryLevel
+	Highest qrcodeRecoveryLevel
+}
+
+var (
+	ConsoleColors consoleColors = consoleColors{
+		NormalBlack:   "\033[38;5;0m  \033[0m",
+		NormalRed:     "\033[38;5;1m  \033[0m",
+		NormalGreen:   "\033[38;5;2m  \033[0m",
+		NormalYellow:  "\033[38;5;3m  \033[0m",
+		NormalBlue:    "\033[38;5;4m  \033[0m",
+		NormalMagenta: "\033[38;5;5m  \033[0m",
+		NormalCyan:    "\033[38;5;6m  \033[0m",
+		NormalWhite:   "\033[38;5;7m  \033[0m",
+		BrightBlack:   "\033[48;5;0m  \033[0m",
+		BrightRed:     "\033[48;5;1m  \033[0m",
+		BrightGreen:   "\033[48;5;2m  \033[0m",
+		BrightYellow:  "\033[48;5;3m  \033[0m",
+		BrightBlue:    "\033[48;5;4m  \033[0m",
+		BrightMagenta: "\033[48;5;5m  \033[0m",
+		BrightCyan:    "\033[48;5;6m  \033[0m",
+		BrightWhite:   "\033[48;5;7m  \033[0m"}
+	QRCodeRecoveryLevels = qrcodeRecoveryLevels{
+		Low:     qrcodeRecoveryLevel(qrcode.Low),
+		Medium:  qrcodeRecoveryLevel(qrcode.Medium),
+		High:    qrcodeRecoveryLevel(qrcode.High),
+		Highest: qrcodeRecoveryLevel(qrcode.Highest)}
+)
+
+type QRCodeString string
+
+func (v *QRCodeString) Print() {
+	fmt.Fprint(outer, *v)
+}
+
+type qrcodeTerminal struct {
+	front consoleColor
+	back  consoleColor
+	level qrcodeRecoveryLevel
+}
+
+func (v *qrcodeTerminal) Get(content interface{}) (result *QRCodeString) {
+	var qr *qrcode.QRCode
+	var err error
+	if t, ok := content.(string); ok {
+		qr, err = qrcode.New(t, qrcode.RecoveryLevel(v.level))
+	} else if t, ok := content.([]byte); ok {
+		qr, err = qrcode.New(string(t), qrcode.RecoveryLevel(v.level))
+	}
+	if qr != nil && err == nil {
+		data := qr.Bitmap()
+		result = v.getQRCodeString(data)
+	}
+	return
+}
+
+func (v *qrcodeTerminal) Get2(bytes []byte) (result *QRCodeString) {
+	data, err := parseQR(bytes)
+	if err == nil {
+		result = v.getQRCodeString(data)
+	}
+	return
+}
+
+func New2(front, back consoleColor, level qrcodeRecoveryLevel) *qrcodeTerminal {
+	obj := qrcodeTerminal{front: front, back: back, level: level}
+	return &obj
+}
+
+func New() *qrcodeTerminal {
+	front, back, level := ConsoleColors.BrightBlack, ConsoleColors.BrightWhite, QRCodeRecoveryLevels.Medium
+	return New2(front, back, level)
+}
+
+func (v *qrcodeTerminal) getQRCodeString(data [][]bool) (result *QRCodeString) {
+	str := ""
+	for ir, row := range data {
+		lr := len(row)
+		if ir == 0 || ir == 1 || ir == 2 ||
+			ir == lr-1 || ir == lr-2 || ir == lr-3 {
+			continue
+		}
+		for ic, col := range row {
+			lc := len(data)
+			if ic == 0 || ic == 1 || ic == 2 ||
+				ic == lc-1 || ic == lc-2 || ic == lc-3 {
+				continue
+			}
+			if col {
+				str += fmt.Sprint(v.front)
+			} else {
+				str += fmt.Sprint(v.back)
+			}
+		}
+		str += fmt.Sprintln()
+	}
+	obj := QRCodeString(str)
+	result = &obj
+	return
+}
+
+func parseQR(bytes []byte) (data [][]bool, err error) {
+	r := nbytes.NewReader(bytes)
+	img, err := png.Decode(r)
+	if err == nil {
+		rect := img.Bounds()
+		mx, my := rect.Max.X, rect.Max.Y
+		data = make([][]bool, mx)
+		for x := 0; x < mx; x++ {
+			data[x] = make([]bool, my)
+			for y := 0; y < my; y++ {
+				c := img.At(x, y)
+				r, _, _, _ := c.RGBA()
+				data[x][y] = r == 0
+			}
+		}
+	}
+	return
+}
+
+var outer = colorable.NewColorableStdout()

vendor/github.com/Jeffail/gabs/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Ashley Jeffs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/Jeffail/gabs/README.md

@@ -0,0 +1,315 @@
+![Gabs](gabs_logo.png "Gabs")
+
+Gabs is a small utility for dealing with dynamic or unknown JSON structures in
+golang. It's pretty much just a helpful wrapper around the golang
+`json.Marshal/json.Unmarshal` behaviour and `map[string]interface{}` objects.
+It does nothing spectacular except for being fabulous.
+
+https://godoc.org/github.com/Jeffail/gabs
+
+## How to install:
+
+``` bash
+go get github.com/Jeffail/gabs
+```
+
+## How to use
+
+### Parsing and searching JSON
+
+``` go
+...
+
+import "github.com/Jeffail/gabs"
+
+jsonParsed, err := gabs.ParseJSON([]byte(`{
+	"outter":{
+		"inner":{
+			"value1":10,
+			"value2":22
+		},
+		"alsoInner":{
+			"value1":20
+		}
+	}
+}`))
+
+var value float64
+var ok bool
+
+value, ok = jsonParsed.Path("outter.inner.value1").Data().(float64)
+// value == 10.0, ok == true
+
+value, ok = jsonParsed.Search("outter", "inner", "value1").Data().(float64)
+// value == 10.0, ok == true
+
+value, ok = jsonParsed.Path("does.not.exist").Data().(float64)
+// value == 0.0, ok == false
+
+exists := jsonParsed.Exists("outter", "inner", "value1")
+// exists == true
+
+exists := jsonParsed.Exists("does", "not", "exist")
+// exists == false
+
+exists := jsonParsed.ExistsP("does.not.exist")
+// exists == false
+
+...
+```
+
+### Iterating objects
+
+``` go
+...
+
+jsonParsed, _ := gabs.ParseJSON([]byte(`{"object":{ "first": 1, "second": 2, "third": 3 }}`))
+
+// S is shorthand for Search
+children, _ := jsonParsed.S("object").ChildrenMap()
+for key, child := range children {
+	fmt.Printf("key: %v, value: %v\n", key, child.Data().(string))
+}
+
+...
+```
+
+### Iterating arrays
+
+``` go
+...
+
+jsonParsed, _ := gabs.ParseJSON([]byte(`{"array":[ "first", "second", "third" ]}`))
+
+// S is shorthand for Search
+children, _ := jsonParsed.S("array").Children()
+for _, child := range children {
+	fmt.Println(child.Data().(string))
+}
+
+...
+```
+
+Will print:
+
+```
+first
+second
+third
+```
+
+Children() will return all children of an array in order. This also works on
+objects, however, the children will be returned in a random order.
+
+### Searching through arrays
+
+If your JSON structure contains arrays you can still search the fields of the
+objects within the array, this returns a JSON array containing the results for
+each element.
+
+``` go
+...
+
+jsonParsed, _ := gabs.ParseJSON([]byte(`{"array":[ {"value":1}, {"value":2}, {"value":3} ]}`))
+fmt.Println(jsonParsed.Path("array.value").String())
+
+...
+```
+
+Will print:
+
+```
+[1,2,3]
+```
+
+### Generating JSON
+
+``` go
+...
+
+jsonObj := gabs.New()
+// or gabs.Consume(jsonObject) to work on an existing map[string]interface{}
+
+jsonObj.Set(10, "outter", "inner", "value")
+jsonObj.SetP(20, "outter.inner.value2")
+jsonObj.Set(30, "outter", "inner2", "value3")
+
+fmt.Println(jsonObj.String())
+
+...
+```
+
+Will print:
+
+```
+{"outter":{"inner":{"value":10,"value2":20},"inner2":{"value3":30}}}
+```
+
+To pretty-print:
+
+``` go
+...
+
+fmt.Println(jsonObj.StringIndent("", "  "))
+
+...
+```
+
+Will print:
+
+```
+{
+  "outter": {
+    "inner": {
+      "value": 10,
+      "value2": 20
+    },
+    "inner2": {
+      "value3": 30
+    }
+  }
+}
+```
+
+### Generating Arrays
+
+``` go
+...
+
+jsonObj := gabs.New()
+
+jsonObj.Array("foo", "array")
+// Or .ArrayP("foo.array")
+
+jsonObj.ArrayAppend(10, "foo", "array")
+jsonObj.ArrayAppend(20, "foo", "array")
+jsonObj.ArrayAppend(30, "foo", "array")
+
+fmt.Println(jsonObj.String())
+
+...
+```
+
+Will print:
+
+```
+{"foo":{"array":[10,20,30]}}
+```
+
+Working with arrays by index:
+
+``` go
+...
+
+jsonObj := gabs.New()
+
+// Create an array with the length of 3
+jsonObj.ArrayOfSize(3, "foo")
+
+jsonObj.S("foo").SetIndex("test1", 0)
+jsonObj.S("foo").SetIndex("test2", 1)
+
+// Create an embedded array with the length of 3
+jsonObj.S("foo").ArrayOfSizeI(3, 2)
+
+jsonObj.S("foo").Index(2).SetIndex(1, 0)
+jsonObj.S("foo").Index(2).SetIndex(2, 1)
+jsonObj.S("foo").Index(2).SetIndex(3, 2)
+
+fmt.Println(jsonObj.String())
+
+...
+```
+
+Will print:
+
+```
+{"foo":["test1","test2",[1,2,3]]}
+```
+
+### Converting back to JSON
+
+This is the easiest part:
+
+``` go
+...
+
+jsonParsedObj, _ := gabs.ParseJSON([]byte(`{
+	"outter":{
+		"values":{
+			"first":10,
+			"second":11
+		}
+	},
+	"outter2":"hello world"
+}`))
+
+jsonOutput := jsonParsedObj.String()
+// Becomes `{"outter":{"values":{"first":10,"second":11}},"outter2":"hello world"}`
+
+...
+```
+
+And to serialize a specific segment is as simple as:
+
+``` go
+...
+
+jsonParsedObj := gabs.ParseJSON([]byte(`{
+	"outter":{
+		"values":{
+			"first":10,
+			"second":11
+		}
+	},
+	"outter2":"hello world"
+}`))
+
+jsonOutput := jsonParsedObj.Search("outter").String()
+// Becomes `{"values":{"first":10,"second":11}}`
+
+...
+```
+
+### Merge two containers
+
+You can merge a JSON structure into an existing one, where collisions will be
+converted into a JSON array.
+
+``` go
+jsonParsed1, _ := ParseJSON([]byte(`{"outter": {"value1": "one"}}`))
+jsonParsed2, _ := ParseJSON([]byte(`{"outter": {"inner": {"value3": "three"}}, "outter2": {"value2": "two"}}`))
+
+jsonParsed1.Merge(jsonParsed2)
+// Becomes `{"outter":{"inner":{"value3":"three"},"value1":"one"},"outter2":{"value2":"two"}}`
+```
+
+Arrays are merged:
+
+``` go
+jsonParsed1, _ := ParseJSON([]byte(`{"array": ["one"]}`))
+jsonParsed2, _ := ParseJSON([]byte(`{"array": ["two"]}`))
+
+jsonParsed1.Merge(jsonParsed2)
+// Becomes `{"array":["one", "two"]}`
+```
+
+### Parsing Numbers
+
+Gabs uses the `json` package under the bonnet, which by default will parse all
+number values into `float64`. If you need to parse `Int` values then you should
+use a `json.Decoder` (https://golang.org/pkg/encoding/json/#Decoder):
+
+``` go
+sample := []byte(`{"test":{"int":10, "float":6.66}}`)
+dec := json.NewDecoder(bytes.NewReader(sample))
+dec.UseNumber()
+
+val, err := gabs.ParseJSONDecoder(dec)
+if err != nil {
+    t.Errorf("Failed to parse: %v", err)
+    return
+}
+
+intValue, err := val.Path("test.int").Data().(json.Number).Int64()
+```

vendor/github.com/Jeffail/gabs/gabs.go

@@ -0,0 +1,581 @@
+/*
+Copyright (c) 2014 Ashley Jeffs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+// Package gabs implements a simplified wrapper around creating and parsing JSON.
+package gabs
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"io/ioutil"
+	"strings"
+)
+
+//--------------------------------------------------------------------------------------------------
+
+var (
+	// ErrOutOfBounds - Index out of bounds.
+	ErrOutOfBounds = errors.New("out of bounds")
+
+	// ErrNotObjOrArray - The target is not an object or array type.
+	ErrNotObjOrArray = errors.New("not an object or array")
+
+	// ErrNotObj - The target is not an object type.
+	ErrNotObj = errors.New("not an object")
+
+	// ErrNotArray - The target is not an array type.
+	ErrNotArray = errors.New("not an array")
+
+	// ErrPathCollision - Creating a path failed because an element collided with an existing value.
+	ErrPathCollision = errors.New("encountered value collision whilst building path")
+
+	// ErrInvalidInputObj - The input value was not a map[string]interface{}.
+	ErrInvalidInputObj = errors.New("invalid input object")
+
+	// ErrInvalidInputText - The input data could not be parsed.
+	ErrInvalidInputText = errors.New("input text could not be parsed")
+
+	// ErrInvalidPath - The filepath was not valid.
+	ErrInvalidPath = errors.New("invalid file path")
+
+	// ErrInvalidBuffer - The input buffer contained an invalid JSON string
+	ErrInvalidBuffer = errors.New("input buffer contained invalid JSON")
+)
+
+//--------------------------------------------------------------------------------------------------
+
+// Container - an internal structure that holds a reference to the core interface map of the parsed
+// json. Use this container to move context.
+type Container struct {
+	object interface{}
+}
+
+// Data - Return the contained data as an interface{}.
+func (g *Container) Data() interface{} {
+	if g == nil {
+		return nil
+	}
+	return g.object
+}
+
+//--------------------------------------------------------------------------------------------------
+
+// Path - Search for a value using dot notation.
+func (g *Container) Path(path string) *Container {
+	return g.Search(strings.Split(path, ".")...)
+}
+
+// Search - Attempt to find and return an object within the JSON structure by specifying the
+// hierarchy of field names to locate the target. If the search encounters an array and has not
+// reached the end target then it will iterate each object of the array for the target and return
+// all of the results in a JSON array.
+func (g *Container) Search(hierarchy ...string) *Container {
+	var object interface{}
+
+	object = g.Data()
+	for target := 0; target < len(hierarchy); target++ {
+		if mmap, ok := object.(map[string]interface{}); ok {
+			object, ok = mmap[hierarchy[target]]
+			if !ok {
+				return nil
+			}
+		} else if marray, ok := object.([]interface{}); ok {
+			tmpArray := []interface{}{}
+			for _, val := range marray {
+				tmpGabs := &Container{val}
+				res := tmpGabs.Search(hierarchy[target:]...)
+				if res != nil {
+					tmpArray = append(tmpArray, res.Data())
+				}
+			}
+			if len(tmpArray) == 0 {
+				return nil
+			}
+			return &Container{tmpArray}
+		} else {
+			return nil
+		}
+	}
+	return &Container{object}
+}
+
+// S - Shorthand method, does the same thing as Search.
+func (g *Container) S(hierarchy ...string) *Container {
+	return g.Search(hierarchy...)
+}
+
+// Exists - Checks whether a path exists.
+func (g *Container) Exists(hierarchy ...string) bool {
+	return g.Search(hierarchy...) != nil
+}
+
+// ExistsP - Checks whether a dot notation path exists.
+func (g *Container) ExistsP(path string) bool {
+	return g.Exists(strings.Split(path, ".")...)
+}
+
+// Index - Attempt to find and return an object within a JSON array by index.
+func (g *Container) Index(index int) *Container {
+	if array, ok := g.Data().([]interface{}); ok {
+		if index >= len(array) {
+			return &Container{nil}
+		}
+		return &Container{array[index]}
+	}
+	return &Container{nil}
+}
+
+// Children - Return a slice of all the children of the array. This also works for objects, however,
+// the children returned for an object will NOT be in order and you lose the names of the returned
+// objects this way.
+func (g *Container) Children() ([]*Container, error) {
+	if array, ok := g.Data().([]interface{}); ok {
+		children := make([]*Container, len(array))
+		for i := 0; i < len(array); i++ {
+			children[i] = &Container{array[i]}
+		}
+		return children, nil
+	}
+	if mmap, ok := g.Data().(map[string]interface{}); ok {
+		children := []*Container{}
+		for _, obj := range mmap {
+			children = append(children, &Container{obj})
+		}
+		return children, nil
+	}
+	return nil, ErrNotObjOrArray
+}
+
+// ChildrenMap - Return a map of all the children of an object.
+func (g *Container) ChildrenMap() (map[string]*Container, error) {
+	if mmap, ok := g.Data().(map[string]interface{}); ok {
+		children := map[string]*Container{}
+		for name, obj := range mmap {
+			children[name] = &Container{obj}
+		}
+		return children, nil
+	}
+	return nil, ErrNotObj
+}
+
+//--------------------------------------------------------------------------------------------------
+
+// Set - Set the value of a field at a JSON path, any parts of the path that do not exist will be
+// constructed, and if a collision occurs with a non object type whilst iterating the path an error
+// is returned.
+func (g *Container) Set(value interface{}, path ...string) (*Container, error) {
+	if len(path) == 0 {
+		g.object = value
+		return g, nil
+	}
+	var object interface{}
+	if g.object == nil {
+		g.object = map[string]interface{}{}
+	}
+	object = g.object
+	for target := 0; target < len(path); target++ {
+		if mmap, ok := object.(map[string]interface{}); ok {
+			if target == len(path)-1 {
+				mmap[path[target]] = value
+			} else if mmap[path[target]] == nil {
+				mmap[path[target]] = map[string]interface{}{}
+			}
+			object = mmap[path[target]]
+		} else {
+			return &Container{nil}, ErrPathCollision
+		}
+	}
+	return &Container{object}, nil
+}
+
+// SetP - Does the same as Set, but using a dot notation JSON path.
+func (g *Container) SetP(value interface{}, path string) (*Container, error) {
+	return g.Set(value, strings.Split(path, ".")...)
+}
+
+// SetIndex - Set a value of an array element based on the index.
+func (g *Container) SetIndex(value interface{}, index int) (*Container, error) {
+	if array, ok := g.Data().([]interface{}); ok {
+		if index >= len(array) {
+			return &Container{nil}, ErrOutOfBounds
+		}
+		array[index] = value
+		return &Container{array[index]}, nil
+	}
+	return &Container{nil}, ErrNotArray
+}
+
+// Object - Create a new JSON object at a path. Returns an error if the path contains a collision
+// with a non object type.
+func (g *Container) Object(path ...string) (*Container, error) {
+	return g.Set(map[string]interface{}{}, path...)
+}
+
+// ObjectP - Does the same as Object, but using a dot notation JSON path.
+func (g *Container) ObjectP(path string) (*Container, error) {
+	return g.Object(strings.Split(path, ".")...)
+}
+
+// ObjectI - Create a new JSON object at an array index. Returns an error if the object is not an
+// array or the index is out of bounds.
+func (g *Container) ObjectI(index int) (*Container, error) {
+	return g.SetIndex(map[string]interface{}{}, index)
+}
+
+// Array - Create a new JSON array at a path. Returns an error if the path contains a collision with
+// a non object type.
+func (g *Container) Array(path ...string) (*Container, error) {
+	return g.Set([]interface{}{}, path...)
+}
+
+// ArrayP - Does the same as Array, but using a dot notation JSON path.
+func (g *Container) ArrayP(path string) (*Container, error) {
+	return g.Array(strings.Split(path, ".")...)
+}
+
+// ArrayI - Create a new JSON array at an array index. Returns an error if the object is not an
+// array or the index is out of bounds.
+func (g *Container) ArrayI(index int) (*Container, error) {
+	return g.SetIndex([]interface{}{}, index)
+}
+
+// ArrayOfSize - Create a new JSON array of a particular size at a path. Returns an error if the
+// path contains a collision with a non object type.
+func (g *Container) ArrayOfSize(size int, path ...string) (*Container, error) {
+	a := make([]interface{}, size)
+	return g.Set(a, path...)
+}
+
+// ArrayOfSizeP - Does the same as ArrayOfSize, but using a dot notation JSON path.
+func (g *Container) ArrayOfSizeP(size int, path string) (*Container, error) {
+	return g.ArrayOfSize(size, strings.Split(path, ".")...)
+}
+
+// ArrayOfSizeI - Create a new JSON array of a particular size at an array index. Returns an error
+// if the object is not an array or the index is out of bounds.
+func (g *Container) ArrayOfSizeI(size, index int) (*Container, error) {
+	a := make([]interface{}, size)
+	return g.SetIndex(a, index)
+}
+
+// Delete - Delete an element at a JSON path, an error is returned if the element does not exist.
+func (g *Container) Delete(path ...string) error {
+	var object interface{}
+
+	if g.object == nil {
+		return ErrNotObj
+	}
+	object = g.object
+	for target := 0; target < len(path); target++ {
+		if mmap, ok := object.(map[string]interface{}); ok {
+			if target == len(path)-1 {
+				if _, ok := mmap[path[target]]; ok {
+					delete(mmap, path[target])
+				} else {
+					return ErrNotObj
+				}
+			}
+			object = mmap[path[target]]
+		} else {
+			return ErrNotObj
+		}
+	}
+	return nil
+}
+
+// DeleteP - Does the same as Delete, but using a dot notation JSON path.
+func (g *Container) DeleteP(path string) error {
+	return g.Delete(strings.Split(path, ".")...)
+}
+
+// Merge - Merges two gabs-containers
+func (g *Container) Merge(toMerge *Container) error {
+	var recursiveFnc func(map[string]interface{}, []string) error
+	recursiveFnc = func(mmap map[string]interface{}, path []string) error {
+		for key, value := range mmap {
+			newPath := append(path, key)
+			if g.Exists(newPath...) {
+				target := g.Search(newPath...)
+				switch t := value.(type) {
+				case map[string]interface{}:
+					switch targetV := target.Data().(type) {
+					case map[string]interface{}:
+						if err := recursiveFnc(t, newPath); err != nil {
+							return err
+						}
+					case []interface{}:
+						g.Set(append(targetV, t), newPath...)
+					default:
+						newSlice := append([]interface{}{}, targetV)
+						g.Set(append(newSlice, t), newPath...)
+					}
+				case []interface{}:
+					for _, valueOfSlice := range t {
+						if err := g.ArrayAppend(valueOfSlice, newPath...); err != nil {
+							return err
+						}
+					}
+				default:
+					switch targetV := target.Data().(type) {
+					case []interface{}:
+						g.Set(append(targetV, t), newPath...)
+					default:
+						newSlice := append([]interface{}{}, targetV)
+						g.Set(append(newSlice, t), newPath...)
+					}
+				}
+			} else {
+				// path doesn't exist. So set the value
+				if _, err := g.Set(value, newPath...); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	if mmap, ok := toMerge.Data().(map[string]interface{}); ok {
+		return recursiveFnc(mmap, []string{})
+	}
+	return nil
+}
+
+//--------------------------------------------------------------------------------------------------
+
+/*
+Array modification/search - Keeping these options simple right now, no need for anything more
+complicated since you can just cast to []interface{}, modify and then reassign with Set.
+*/
+
+// ArrayAppend - Append a value onto a JSON array. If the target is not a JSON array then it will be
+// converted into one, with its contents as the first element of the array.
+func (g *Container) ArrayAppend(value interface{}, path ...string) error {
+	if array, ok := g.Search(path...).Data().([]interface{}); ok {
+		array = append(array, value)
+		_, err := g.Set(array, path...)
+		return err
+	}
+
+	newArray := []interface{}{}
+	if d := g.Search(path...).Data(); d != nil {
+		newArray = append(newArray, d)
+	}
+	newArray = append(newArray, value)
+
+	_, err := g.Set(newArray, path...)
+	return err
+}
+
+// ArrayAppendP - Append a value onto a JSON array using a dot notation JSON path.
+func (g *Container) ArrayAppendP(value interface{}, path string) error {
+	return g.ArrayAppend(value, strings.Split(path, ".")...)
+}
+
+// ArrayRemove - Remove an element from a JSON array.
+func (g *Container) ArrayRemove(index int, path ...string) error {
+	if index < 0 {
+		return ErrOutOfBounds
+	}
+	array, ok := g.Search(path...).Data().([]interface{})
+	if !ok {
+		return ErrNotArray
+	}
+	if index < len(array) {
+		array = append(array[:index], array[index+1:]...)
+	} else {
+		return ErrOutOfBounds
+	}
+	_, err := g.Set(array, path...)
+	return err
+}
+
+// ArrayRemoveP - Remove an element from a JSON array using a dot notation JSON path.
+func (g *Container) ArrayRemoveP(index int, path string) error {
+	return g.ArrayRemove(index, strings.Split(path, ".")...)
+}
+
+// ArrayElement - Access an element from a JSON array.
+func (g *Container) ArrayElement(index int, path ...string) (*Container, error) {
+	if index < 0 {
+		return &Container{nil}, ErrOutOfBounds
+	}
+	array, ok := g.Search(path...).Data().([]interface{})
+	if !ok {
+		return &Container{nil}, ErrNotArray
+	}
+	if index < len(array) {
+		return &Container{array[index]}, nil
+	}
+	return &Container{nil}, ErrOutOfBounds
+}
+
+// ArrayElementP - Access an element from a JSON array using a dot notation JSON path.
+func (g *Container) ArrayElementP(index int, path string) (*Container, error) {
+	return g.ArrayElement(index, strings.Split(path, ".")...)
+}
+
+// ArrayCount - Count the number of elements in a JSON array.
+func (g *Container) ArrayCount(path ...string) (int, error) {
+	if array, ok := g.Search(path...).Data().([]interface{}); ok {
+		return len(array), nil
+	}
+	return 0, ErrNotArray
+}
+
+// ArrayCountP - Count the number of elements in a JSON array using a dot notation JSON path.
+func (g *Container) ArrayCountP(path string) (int, error) {
+	return g.ArrayCount(strings.Split(path, ".")...)
+}
+
+//--------------------------------------------------------------------------------------------------
+
+// Bytes - Converts the contained object back to a JSON []byte blob.
+func (g *Container) Bytes() []byte {
+	if g.Data() != nil {
+		if bytes, err := json.Marshal(g.object); err == nil {
+			return bytes
+		}
+	}
+	return []byte("{}")
+}
+
+// BytesIndent - Converts the contained object to a JSON []byte blob formatted with prefix, indent.
+func (g *Container) BytesIndent(prefix string, indent string) []byte {
+	if g.object != nil {
+		if bytes, err := json.MarshalIndent(g.object, prefix, indent); err == nil {
+			return bytes
+		}
+	}
+	return []byte("{}")
+}
+
+// String - Converts the contained object to a JSON formatted string.
+func (g *Container) String() string {
+	return string(g.Bytes())
+}
+
+// StringIndent - Converts the contained object back to a JSON formatted string with prefix, indent.
+func (g *Container) StringIndent(prefix string, indent string) string {
+	return string(g.BytesIndent(prefix, indent))
+}
+
+// EncodeOpt is a functional option for the EncodeJSON method.
+type EncodeOpt func(e *json.Encoder)
+
+// EncodeOptHTMLEscape sets the encoder to escape the JSON for html.
+func EncodeOptHTMLEscape(doEscape bool) EncodeOpt {
+	return func(e *json.Encoder) {
+		e.SetEscapeHTML(doEscape)
+	}
+}
+
+// EncodeOptIndent sets the encoder to indent the JSON output.
+func EncodeOptIndent(prefix string, indent string) EncodeOpt {
+	return func(e *json.Encoder) {
+		e.SetIndent(prefix, indent)
+	}
+}
+
+// EncodeJSON - Encodes the contained object back to a JSON formatted []byte
+// using a variant list of modifier functions for the encoder being used.
+// Functions for modifying the output are prefixed with EncodeOpt, e.g.
+// EncodeOptHTMLEscape.
+func (g *Container) EncodeJSON(encodeOpts ...EncodeOpt) []byte {
+	var b bytes.Buffer
+	encoder := json.NewEncoder(&b)
+	encoder.SetEscapeHTML(false) // Do not escape by default.
+	for _, opt := range encodeOpts {
+		opt(encoder)
+	}
+	if err := encoder.Encode(g.object); err != nil {
+		return []byte("{}")
+	}
+	result := b.Bytes()
+	if len(result) > 0 {
+		result = result[:len(result)-1]
+	}
+	return result
+}
+
+// New - Create a new gabs JSON object.
+func New() *Container {
+	return &Container{map[string]interface{}{}}
+}
+
+// Consume - Gobble up an already converted JSON object, or a fresh map[string]interface{} object.
+func Consume(root interface{}) (*Container, error) {
+	return &Container{root}, nil
+}
+
+// ParseJSON - Convert a string into a representation of the parsed JSON.
+func ParseJSON(sample []byte) (*Container, error) {
+	var gabs Container
+
+	if err := json.Unmarshal(sample, &gabs.object); err != nil {
+		return nil, err
+	}
+
+	return &gabs, nil
+}
+
+// ParseJSONDecoder - Convert a json.Decoder into a representation of the parsed JSON.
+func ParseJSONDecoder(decoder *json.Decoder) (*Container, error) {
+	var gabs Container
+
+	if err := decoder.Decode(&gabs.object); err != nil {
+		return nil, err
+	}
+
+	return &gabs, nil
+}
+
+// ParseJSONFile - Read a file and convert into a representation of the parsed JSON.
+func ParseJSONFile(path string) (*Container, error) {
+	if len(path) > 0 {
+		cBytes, err := ioutil.ReadFile(path)
+		if err != nil {
+			return nil, err
+		}
+
+		container, err := ParseJSON(cBytes)
+		if err != nil {
+			return nil, err
+		}
+
+		return container, nil
+	}
+	return nil, ErrInvalidPath
+}
+
+// ParseJSONBuffer - Read the contents of a buffer into a representation of the parsed JSON.
+func ParseJSONBuffer(buffer io.Reader) (*Container, error) {
+	var gabs Container
+	jsonDecoder := json.NewDecoder(buffer)
+	if err := jsonDecoder.Decode(&gabs.object); err != nil {
+		return nil, err
+	}
+
+	return &gabs, nil
+}
+
+//--------------------------------------------------------------------------------------------------

vendor/github.com/Rhymen/go-whatsapp/.gitignore

@@ -0,0 +1,2 @@
+.idea/
+docs/

vendor/github.com/Rhymen/go-whatsapp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/Rhymen/go-whatsapp/README.md

@@ -0,0 +1,104 @@
+# go-whatsapp
+Package rhymen/go-whatsapp implements the WhatsApp Web API to provide a clean interface for developers. Big thanks to all contributors of the [sigalor/whatsapp-web-reveng](https://github.com/sigalor/whatsapp-web-reveng) project. The official WhatsApp Business API was released in August 2018. You can check it out [here](https://www.whatsapp.com/business/api).
+
+## Installation
+```sh
+go get github.com/rhymen/go-whatsapp
+```
+
+## Usage
+### Creating a connection
+```go
+import (
+    whatsapp "github.com/Rhymen/go-whatsapp"
+)
+
+wac, err := whatsapp.NewConn(20 * time.Second)
+```
+The duration passed to the NewConn function is used to timeout login requests. If you have a bad internet connection use a higher timeout value. This function only creates a websocket connection, it does not handle authentication.
+
+### Login
+```go
+qrChan := make(chan string)
+go func() {
+    fmt.Printf("qr code: %v\n", <-qrChan)
+    //show qr code or save it somewhere to scan
+}
+sess, err := wac.Login(qrChan)
+```
+The authentication process requires you to scan the qr code, that is send through the channel, with the device you are using whatsapp on. The session struct that is returned can be saved and used to restore the login without scanning the qr code again. The qr code has a ttl of 20 seconds and the login function throws a timeout err if the time has passed or any other request fails.
+
+### Restore
+```go
+newSess, err := wac.RestoreSession(sess)
+```
+The restore function needs a valid session and returns the new session that was created.
+
+### Add message handlers
+```go
+type myHandler struct{}
+
+func (myHandler) HandleError(err error) {
+	fmt.Fprintf(os.Stderr, "%v", err)
+}
+
+func (myHandler) HandleTextMessage(message whatsapp.TextMessage) {
+	fmt.Println(message)
+}
+
+func (myHandler) HandleImageMessage(message whatsapp.ImageMessage) {
+	fmt.Println(message)
+}
+
+func (myHandler) HandleVideoMessage(message whatsapp.VideoMessage) {
+	fmt.Println(message)
+}
+
+func (myHandler) HandleJsonMessage(message string) {
+	fmt.Println(message)
+}
+
+wac.AddHandler(myHandler{})
+```
+The message handlers are all optional, you don't need to implement anything but the error handler to implement the interface. The ImageMessage and VideoMessage provide a Download function to get the media data.
+
+### Sending text messages
+```go
+text := whatsapp.TextMessage{
+    Info: whatsapp.MessageInfo{
+        RemoteJid: "0123456789@s.whatsapp.net",
+    },
+    Text: "Hello Whatsapp",
+}
+
+err := wac.Send(text)
+```
+The message will be send over the websocket. The attributes seen above are the required ones. All other relevant attributes (id, timestamp, fromMe, status) are set if they are missing in the struct. For the time being we only support text messages, but other types are planned for the near future.
+
+## Legal
+This code is in no way affiliated with, authorized, maintained, sponsored or endorsed by WhatsApp or any of its
+affiliates or subsidiaries. This is an independent and unofficial software. Use at your own risk.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/Rhymen/go-whatsapp/binary/decoder.go

@@ -0,0 +1,388 @@
+package binary
+
+import (
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/binary/token"
+	"io"
+	"strconv"
+)
+
+type binaryDecoder struct {
+	data  []byte
+	index int
+}
+
+func NewDecoder(data []byte) *binaryDecoder {
+	return &binaryDecoder{data, 0}
+}
+
+func (r *binaryDecoder) checkEOS(length int) error {
+	if r.index+length > len(r.data) {
+		return io.EOF
+	}
+
+	return nil
+}
+
+func (r *binaryDecoder) readByte() (byte, error) {
+	if err := r.checkEOS(1); err != nil {
+		return 0, err
+	}
+
+	b := r.data[r.index]
+	r.index++
+
+	return b, nil
+}
+
+func (r *binaryDecoder) readIntN(n int, littleEndian bool) (int, error) {
+	if err := r.checkEOS(n); err != nil {
+		return 0, err
+	}
+
+	var ret int
+
+	for i := 0; i < n; i++ {
+		var curShift int
+		if littleEndian {
+			curShift = i
+		} else {
+			curShift = n - i - 1
+		}
+		ret |= int(r.data[r.index+i]) << uint(curShift*8)
+	}
+
+	r.index += n
+	return ret, nil
+}
+
+func (r *binaryDecoder) readInt8(littleEndian bool) (int, error) {
+	return r.readIntN(1, littleEndian)
+}
+
+func (r *binaryDecoder) readInt16(littleEndian bool) (int, error) {
+	return r.readIntN(2, littleEndian)
+}
+
+func (r *binaryDecoder) readInt20() (int, error) {
+	if err := r.checkEOS(3); err != nil {
+		return 0, err
+	}
+
+	ret := ((int(r.data[r.index]) & 15) << 16) + (int(r.data[r.index+1]) << 8) + int(r.data[r.index+2])
+	r.index += 3
+	return ret, nil
+}
+
+func (r *binaryDecoder) readInt32(littleEndian bool) (int, error) {
+	return r.readIntN(4, littleEndian)
+}
+
+func (r *binaryDecoder) readInt64(littleEndian bool) (int, error) {
+	return r.readIntN(8, littleEndian)
+}
+
+func (r *binaryDecoder) readPacked8(tag int) (string, error) {
+	startByte, err := r.readByte()
+	if err != nil {
+		return "", err
+	}
+
+	ret := ""
+
+	for i := 0; i < int(startByte&127); i++ {
+		currByte, err := r.readByte()
+		if err != nil {
+			return "", err
+		}
+
+		lower, err := unpackByte(tag, currByte&0xF0>>4)
+		if err != nil {
+			return "", err
+		}
+
+		upper, err := unpackByte(tag, currByte&0x0F)
+		if err != nil {
+			return "", err
+		}
+
+		ret += lower + upper
+	}
+
+	if startByte>>7 != 0 {
+		ret = ret[:len(ret)-1]
+	}
+	return ret, nil
+}
+
+func unpackByte(tag int, value byte) (string, error) {
+	switch tag {
+	case token.NIBBLE_8:
+		return unpackNibble(value)
+	case token.HEX_8:
+		return unpackHex(value)
+	default:
+		return "", fmt.Errorf("unpackByte with unknown tag %d", tag)
+	}
+}
+
+func unpackNibble(value byte) (string, error) {
+	switch {
+	case value < 0 || value > 15:
+		return "", fmt.Errorf("unpackNibble with value %d", value)
+	case value == 10:
+		return "-", nil
+	case value == 11:
+		return ".", nil
+	case value == 15:
+		return "\x00", nil
+	default:
+		return strconv.Itoa(int(value)), nil
+	}
+}
+
+func unpackHex(value byte) (string, error) {
+	switch {
+	case value < 0 || value > 15:
+		return "", fmt.Errorf("unpackHex with value %d", value)
+	case value < 10:
+		return strconv.Itoa(int(value)), nil
+	default:
+		return string('A' + value - 10), nil
+	}
+}
+
+func (r *binaryDecoder) readListSize(tag int) (int, error) {
+	switch tag {
+	case token.LIST_EMPTY:
+		return 0, nil
+	case token.LIST_8:
+		return r.readInt8(false)
+	case token.LIST_16:
+		return r.readInt16(false)
+	default:
+		return 0, fmt.Errorf("readListSize with unknown tag %d at position %d", tag, r.index)
+	}
+}
+
+func (r *binaryDecoder) readString(tag int) (string, error) {
+	switch {
+	case tag >= 3 && tag <= len(token.SingleByteTokens):
+		tok, err := token.GetSingleToken(tag)
+		if err != nil {
+			return "", err
+		}
+
+		if tok == "s.whatsapp.net" {
+			tok = "c.us"
+		}
+
+		return tok, nil
+	case tag == token.DICTIONARY_0 || tag == token.DICTIONARY_1 || tag == token.DICTIONARY_2 || tag == token.DICTIONARY_3:
+		i, err := r.readInt8(false)
+		if err != nil {
+			return "", err
+		}
+
+		return token.GetDoubleToken(tag-token.DICTIONARY_0, i)
+	case tag == token.LIST_EMPTY:
+		return "", nil
+	case tag == token.BINARY_8:
+		length, err := r.readInt8(false)
+		if err != nil {
+			return "", err
+		}
+
+		return r.readStringFromChars(length)
+	case tag == token.BINARY_20:
+		length, err := r.readInt20()
+		if err != nil {
+			return "", err
+		}
+
+		return r.readStringFromChars(length)
+	case tag == token.BINARY_32:
+		length, err := r.readInt32(false)
+		if err != nil {
+			return "", err
+		}
+
+		return r.readStringFromChars(length)
+	case tag == token.JID_PAIR:
+		b, err := r.readByte()
+		if err != nil {
+			return "", err
+		}
+		i, err := r.readString(int(b))
+		if err != nil {
+			return "", err
+		}
+
+		b, err = r.readByte()
+		if err != nil {
+			return "", err
+		}
+		j, err := r.readString(int(b))
+		if err != nil {
+			return "", err
+		}
+
+		if i == "" || j == "" {
+			return "", fmt.Errorf("invalid jid pair: %s - %s", i, j)
+		}
+
+		return i + "@" + j, nil
+	case tag == token.NIBBLE_8 || tag == token.HEX_8:
+		return r.readPacked8(tag)
+	default:
+		return "", fmt.Errorf("invalid string with tag %d", tag)
+	}
+}
+
+func (r *binaryDecoder) readStringFromChars(length int) (string, error) {
+	if err := r.checkEOS(length); err != nil {
+		return "", err
+	}
+
+	ret := r.data[r.index : r.index+length]
+	r.index += length
+
+	return string(ret), nil
+}
+
+func (r *binaryDecoder) readAttributes(n int) (map[string]string, error) {
+	if n == 0 {
+		return nil, nil
+	}
+
+	ret := make(map[string]string)
+	for i := 0; i < n; i++ {
+		idx, err := r.readInt8(false)
+		if err != nil {
+			return nil, err
+		}
+
+		index, err := r.readString(idx)
+		if err != nil {
+			return nil, err
+		}
+
+		idx, err = r.readInt8(false)
+		if err != nil {
+			return nil, err
+		}
+
+		ret[index], err = r.readString(idx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return ret, nil
+}
+
+func (r *binaryDecoder) readList(tag int) ([]Node, error) {
+	size, err := r.readListSize(tag)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]Node, size)
+	for i := 0; i < size; i++ {
+		n, err := r.ReadNode()
+
+		if err != nil {
+			return nil, err
+		}
+
+		ret[i] = *n
+	}
+
+	return ret, nil
+}
+
+func (r *binaryDecoder) ReadNode() (*Node, error) {
+	ret := &Node{}
+
+	size, err := r.readInt8(false)
+	if err != nil {
+		return nil, err
+	}
+	listSize, err := r.readListSize(size)
+	if err != nil {
+		return nil, err
+	}
+
+	descrTag, err := r.readInt8(false)
+	if descrTag == token.STREAM_END {
+		return nil, fmt.Errorf("unexpected stream end")
+	}
+	ret.Description, err = r.readString(descrTag)
+	if err != nil {
+		return nil, err
+	}
+	if listSize == 0 || ret.Description == "" {
+		return nil, fmt.Errorf("invalid Node")
+	}
+
+	ret.Attributes, err = r.readAttributes((listSize - 1) >> 1)
+	if err != nil {
+		return nil, err
+	}
+
+	if listSize%2 == 1 {
+		return ret, nil
+	}
+
+	tag, err := r.readInt8(false)
+	if err != nil {
+		return nil, err
+	}
+
+	switch tag {
+	case token.LIST_EMPTY, token.LIST_8, token.LIST_16:
+		ret.Content, err = r.readList(tag)
+	case token.BINARY_8:
+		size, err = r.readInt8(false)
+		if err != nil {
+			return nil, err
+		}
+
+		ret.Content, err = r.readBytes(size)
+	case token.BINARY_20:
+		size, err = r.readInt20()
+		if err != nil {
+			return nil, err
+		}
+
+		ret.Content, err = r.readBytes(size)
+	case token.BINARY_32:
+		size, err = r.readInt32(false)
+		if err != nil {
+			return nil, err
+		}
+
+		ret.Content, err = r.readBytes(size)
+	default:
+		ret.Content, err = r.readString(tag)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func (r *binaryDecoder) readBytes(n int) ([]byte, error) {
+	ret := make([]byte, n)
+	var err error
+
+	for i := range ret {
+		ret[i], err = r.readByte()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return ret, nil
+}

vendor/github.com/Rhymen/go-whatsapp/binary/encoder.go

@@ -0,0 +1,351 @@
+package binary
+
+import (
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/binary/token"
+	"math"
+	"strconv"
+	"strings"
+)
+
+type binaryEncoder struct {
+	data []byte
+}
+
+func NewEncoder() *binaryEncoder {
+	return &binaryEncoder{make([]byte, 0)}
+}
+
+func (w *binaryEncoder) GetData() []byte {
+	return w.data
+}
+
+func (w *binaryEncoder) pushByte(b byte) {
+	w.data = append(w.data, b)
+}
+
+func (w *binaryEncoder) pushBytes(bytes []byte) {
+	w.data = append(w.data, bytes...)
+}
+
+func (w *binaryEncoder) pushIntN(value, n int, littleEndian bool) {
+	for i := 0; i < n; i++ {
+		var curShift int
+		if littleEndian {
+			curShift = i
+		} else {
+			curShift = n - i - 1
+		}
+		w.pushByte(byte((value >> uint(curShift*8)) & 0xFF))
+	}
+}
+
+func (w *binaryEncoder) pushInt20(value int) {
+	w.pushBytes([]byte{byte((value >> 16) & 0x0F), byte((value >> 8) & 0xFF), byte(value & 0xFF)})
+}
+
+func (w *binaryEncoder) pushInt8(value int) {
+	w.pushIntN(value, 1, false)
+}
+
+func (w *binaryEncoder) pushInt16(value int) {
+	w.pushIntN(value, 2, false)
+}
+
+func (w *binaryEncoder) pushInt32(value int) {
+	w.pushIntN(value, 4, false)
+}
+
+func (w *binaryEncoder) pushInt64(value int) {
+	w.pushIntN(value, 8, false)
+}
+
+func (w *binaryEncoder) pushString(value string) {
+	w.pushBytes([]byte(value))
+}
+
+func (w *binaryEncoder) writeByteLength(length int) error {
+	if length > math.MaxInt32 {
+		return fmt.Errorf("length is too large: %d", length)
+	} else if length >= (1 << 20) {
+		w.pushByte(token.BINARY_32)
+		w.pushInt32(length)
+	} else if length >= 256 {
+		w.pushByte(token.BINARY_20)
+		w.pushInt20(length)
+	} else {
+		w.pushByte(token.BINARY_8)
+		w.pushInt8(length)
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) WriteNode(n Node) error {
+	numAttributes := 0
+	if n.Attributes != nil {
+		numAttributes = len(n.Attributes)
+	}
+
+	hasContent := 0
+	if n.Content != nil {
+		hasContent = 1
+	}
+
+	w.writeListStart(2*numAttributes + 1 + hasContent)
+	if err := w.writeString(n.Description, false); err != nil {
+		return err
+	}
+
+	if err := w.writeAttributes(n.Attributes); err != nil {
+		return err
+	}
+
+	if err := w.writeChildren(n.Content); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeString(tok string, i bool) error {
+	if !i && tok == "c.us" {
+		if err := w.writeToken(token.IndexOfSingleToken("s.whatsapp.net")); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	tokenIndex := token.IndexOfSingleToken(tok)
+	if tokenIndex == -1 {
+		jidSepIndex := strings.Index(tok, "@")
+		if jidSepIndex < 1 {
+			w.writeStringRaw(tok)
+		} else {
+			w.writeJid(tok[:jidSepIndex], tok[jidSepIndex+1:])
+		}
+	} else {
+		if tokenIndex < token.SINGLE_BYTE_MAX {
+			if err := w.writeToken(tokenIndex); err != nil {
+				return err
+			}
+		} else {
+			singleByteOverflow := tokenIndex - token.SINGLE_BYTE_MAX
+			dictionaryIndex := singleByteOverflow >> 8
+			if dictionaryIndex < 0 || dictionaryIndex > 3 {
+				return fmt.Errorf("double byte dictionary token out of range: %v", tok)
+			}
+			if err := w.writeToken(token.DICTIONARY_0 + dictionaryIndex); err != nil {
+				return err
+			}
+			if err := w.writeToken(singleByteOverflow % 256); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeStringRaw(value string) error {
+	if err := w.writeByteLength(len(value)); err != nil {
+		return err
+	}
+
+	w.pushString(value)
+
+	return nil
+}
+
+func (w *binaryEncoder) writeJid(jidLeft, jidRight string) error {
+	w.pushByte(token.JID_PAIR)
+
+	if jidLeft != "" {
+		if err := w.writePackedBytes(jidLeft); err != nil {
+			return err
+		}
+	} else {
+		if err := w.writeToken(token.LIST_EMPTY); err != nil {
+			return err
+		}
+	}
+
+	if err := w.writeString(jidRight, false); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeToken(tok int) error {
+	if tok < len(token.SingleByteTokens) {
+		w.pushByte(byte(tok))
+	} else if tok <= 500 {
+		return fmt.Errorf("invalid token: %d", tok)
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeAttributes(attributes map[string]string) error {
+	if attributes == nil {
+		return nil
+	}
+
+	for key, val := range attributes {
+		if val == "" {
+			continue
+		}
+
+		if err := w.writeString(key, false); err != nil {
+			return err
+		}
+
+		if err := w.writeString(val, false); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeChildren(children interface{}) error {
+	if children == nil {
+		return nil
+	}
+
+	switch childs := children.(type) {
+	case string:
+		if err := w.writeString(childs, true); err != nil {
+			return err
+		}
+	case []byte:
+		if err := w.writeByteLength(len(childs)); err != nil {
+			return err
+		}
+
+		w.pushBytes(childs)
+	case []Node:
+		w.writeListStart(len(childs))
+		for _, n := range childs {
+			if err := w.WriteNode(n); err != nil {
+				return err
+			}
+		}
+	default:
+		return fmt.Errorf("cannot write child of type: %T", children)
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writeListStart(listSize int) {
+	if listSize == 0 {
+		w.pushByte(byte(token.LIST_EMPTY))
+	} else if listSize < 256 {
+		w.pushByte(byte(token.LIST_8))
+		w.pushInt8(listSize)
+	} else {
+		w.pushByte(byte(token.LIST_16))
+		w.pushInt16(listSize)
+	}
+}
+
+func (w *binaryEncoder) writePackedBytes(value string) error {
+	if err := w.writePackedBytesImpl(value, token.NIBBLE_8); err != nil {
+		if err := w.writePackedBytesImpl(value, token.HEX_8); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) writePackedBytesImpl(value string, dataType int) error {
+	numBytes := len(value)
+	if numBytes > token.PACKED_MAX {
+		return fmt.Errorf("too many bytes to pack: %d", numBytes)
+	}
+
+	w.pushByte(byte(dataType))
+
+	x := 0
+	if numBytes%2 != 0 {
+		x = 128
+	}
+	w.pushByte(byte(x | int(math.Ceil(float64(numBytes)/2.0))))
+	for i, l := 0, numBytes/2; i < l; i++ {
+		b, err := w.packBytePair(dataType, value[2*i:2*i+1], value[2*i+1:2*i+2])
+		if err != nil {
+			return err
+		}
+
+		w.pushByte(byte(b))
+	}
+
+	if (numBytes % 2) != 0 {
+		b, err := w.packBytePair(dataType, value[numBytes-1:], "\x00")
+		if err != nil {
+			return err
+		}
+
+		w.pushByte(byte(b))
+	}
+
+	return nil
+}
+
+func (w *binaryEncoder) packBytePair(packType int, part1, part2 string) (int, error) {
+	if packType == token.NIBBLE_8 {
+		n1, err := packNibble(part1)
+		if err != nil {
+			return 0, err
+		}
+
+		n2, err := packNibble(part2)
+		if err != nil {
+			return 0, err
+		}
+
+		return (n1 << 4) | n2, nil
+	} else if packType == token.HEX_8 {
+		n1, err := packHex(part1)
+		if err != nil {
+			return 0, err
+		}
+
+		n2, err := packHex(part2)
+		if err != nil {
+			return 0, err
+		}
+
+		return (n1 << 4) | n2, nil
+	} else {
+		return 0, fmt.Errorf("invalid pack type (%d) for byte pair: %s / %s", packType, part1, part2)
+	}
+}
+
+func packNibble(value string) (int, error) {
+	if value >= "0" && value <= "9" {
+		return strconv.Atoi(value)
+	} else if value == "-" {
+		return 10, nil
+	} else if value == "." {
+		return 11, nil
+	} else if value == "\x00" {
+		return 15, nil
+	}
+
+	return 0, fmt.Errorf("invalid string to pack as nibble: %v", value)
+}
+
+func packHex(value string) (int, error) {
+	if (value >= "0" && value <= "9") || (value >= "A" && value <= "F") || (value >= "a" && value <= "f") {
+		d, err := strconv.ParseInt(value, 16, 0)
+		return int(d), err
+	} else if value == "\x00" {
+		return 15, nil
+	}
+
+	return 0, fmt.Errorf("invalid string to pack as hex: %v", value)
+}

vendor/github.com/Rhymen/go-whatsapp/binary/node.go

@@ -0,0 +1,103 @@
+package binary
+
+import (
+	"fmt"
+	pb "github.com/Rhymen/go-whatsapp/binary/proto"
+	"github.com/golang/protobuf/proto"
+)
+
+type Node struct {
+	Description string
+	Attributes  map[string]string
+	Content     interface{}
+}
+
+func Marshal(n Node) ([]byte, error) {
+	if n.Attributes != nil && n.Content != nil {
+		a, err := marshalMessageArray(n.Content.([]interface{}))
+		if err != nil {
+			return nil, err
+		}
+		n.Content = a
+	}
+
+	w := NewEncoder()
+	if err := w.WriteNode(n); err != nil {
+		return nil, err
+	}
+
+	return w.GetData(), nil
+}
+
+func marshalMessageArray(messages []interface{}) ([]Node, error) {
+	ret := make([]Node, len(messages))
+
+	for i, m := range messages {
+		if wmi, ok := m.(*pb.WebMessageInfo); ok {
+			b, err := marshalWebMessageInfo(wmi)
+			if err != nil {
+				return nil, nil
+			}
+			ret[i] = Node{"message", nil, b}
+		} else {
+			ret[i], ok = m.(Node)
+			if !ok {
+				return nil, fmt.Errorf("invalid Node")
+			}
+		}
+	}
+
+	return ret, nil
+}
+
+func marshalWebMessageInfo(p *pb.WebMessageInfo) ([]byte, error) {
+	b, err := proto.Marshal(p)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+func Unmarshal(data []byte) (*Node, error) {
+	r := NewDecoder(data)
+	n, err := r.ReadNode()
+	if err != nil {
+		return nil, err
+	}
+
+	if n != nil && n.Attributes != nil && n.Content != nil {
+		n.Content, err = unmarshalMessageArray(n.Content.([]Node))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return n, nil
+}
+
+func unmarshalMessageArray(messages []Node) ([]interface{}, error) {
+	ret := make([]interface{}, len(messages))
+
+	for i, msg := range messages {
+		if msg.Description == "message" {
+			info, err := unmarshalWebMessageInfo(msg.Content.([]byte))
+			if err != nil {
+				return nil, err
+			}
+			ret[i] = info
+		} else {
+			ret[i] = msg
+		}
+	}
+
+	return ret, nil
+}
+
+func unmarshalWebMessageInfo(msg []byte) (*pb.WebMessageInfo, error) {
+	message := &pb.WebMessageInfo{}
+	err := proto.Unmarshal(msg, message)
+	if err != nil {
+		return nil, err
+	}
+	return message, nil
+}

vendor/github.com/Rhymen/go-whatsapp/binary/proto/def.proto

@@ -0,0 +1,417 @@
+syntax = "proto2";
+package proto;
+
+message FingerprintData {
+    optional string publicKey = 1;
+    optional string identifier = 2;
+}
+
+message CombinedFingerprint {
+    optional uint32 version = 1;
+    optional FingerprintData localFingerprint = 2;
+    optional FingerprintData remoteFingerprint = 3;
+}
+
+message MessageKey {
+    optional string remoteJid = 1;
+    optional bool fromMe = 2;
+    optional string id = 3;
+    optional string participant = 4;
+}
+
+message SenderKeyDistributionMessage {
+    optional string groupId = 1;
+    optional bytes axolotlSenderKeyDistributionMessage = 2;
+}
+
+message ImageMessage {
+    optional string url = 1;
+    optional string mimetype = 2;
+    optional string caption = 3;
+    optional bytes fileSha256 = 4;
+    optional uint64 fileLength = 5;
+    optional uint32 height = 6;
+    optional uint32 width = 7;
+    optional bytes mediaKey = 8;
+    optional bytes fileEncSha256 = 9;
+    repeated InteractiveAnnotation interactiveAnnotations = 10;
+    optional string directPath = 11;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+    optional bytes firstScanSidecar = 18;
+    optional uint32 firstScanLength = 19;
+}
+
+message ContactMessage {
+    optional string displayName = 1;
+    optional string vcard = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message LocationMessage {
+    optional double degreesLatitude = 1;
+    optional double degreesLongitude = 2;
+    optional string name = 3;
+    optional string address = 4;
+    optional string url = 5;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message ExtendedTextMessage {
+    optional string text = 1;
+    optional string matchedText = 2;
+    optional string canonicalUrl = 4;
+    optional string description = 5;
+    optional string title = 6;
+    optional fixed32 textArgb = 7;
+    optional fixed32 backgroundArgb = 8;
+    enum FONTTYPE {
+        SANS_SERIF = 0;
+        SERIF = 1;
+        NORICAN_REGULAR = 2;
+        BRYNDAN_WRITE = 3;
+        BEBASNEUE_REGULAR = 4;
+        OSWALD_HEAVY = 5;
+    }
+    optional FONTTYPE font = 9;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message DocumentMessage {
+    optional string url = 1;
+    optional string mimetype = 2;
+    optional string title = 3;
+    optional bytes fileSha256 = 4;
+    optional uint64 fileLength = 5;
+    optional uint32 pageCount = 6;
+    optional bytes mediaKey = 7;
+    optional string fileName = 8;
+    optional bytes fileEncSha256 = 9;
+    optional string directPath = 10;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message AudioMessage {
+    optional string url = 1;
+    optional string mimetype = 2;
+    optional bytes fileSha256 = 3;
+    optional uint64 fileLength = 4;
+    optional uint32 seconds = 5;
+    optional bool ptt = 6;
+    optional bytes mediaKey = 7;
+    optional bytes fileEncSha256 = 8;
+    optional string directPath = 9;
+    optional ContextInfo contextInfo = 17;
+    optional bytes streamingSidecar = 18;
+}
+
+message VideoMessage {
+    optional string url = 1;
+    optional string mimetype = 2;
+    optional bytes fileSha256 = 3;
+    optional uint64 fileLength = 4;
+    optional uint32 seconds = 5;
+    optional bytes mediaKey = 6;
+    optional string caption = 7;
+    optional bool gifPlayback = 8;
+    optional uint32 height = 9;
+    optional uint32 width = 10;
+    optional bytes fileEncSha256 = 11;
+    repeated InteractiveAnnotation interactiveAnnotations = 12;
+    optional string directPath = 13;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+    optional bytes streamingSidecar = 18;
+    enum ATTRIBUTION {
+        NONE = 0;
+        GIPHY = 1;
+        TENOR = 2;
+    }
+    optional ATTRIBUTION gifAttribution = 19;
+}
+
+message Call {
+    optional bytes callKey = 1;
+}
+
+message Chat {
+    optional string displayName = 1;
+    optional string id = 2;
+}
+
+message ProtocolMessage {
+    optional MessageKey key = 1;
+    enum TYPE {
+        REVOKE = 0;
+    }
+    optional TYPE type = 2;
+}
+
+message ContactsArrayMessage {
+    optional string displayName = 1;
+    repeated ContactMessage contacts = 2;
+    optional ContextInfo contextInfo = 17;
+}
+
+message HSMCurrency {
+    optional string currencyCode = 1;
+    optional int64 amount1000 = 2;
+}
+
+message HSMDateTimeComponent {
+    enum DAYOFWEEKTYPE {
+        MONDAY = 1;
+        TUESDAY = 2;
+        WEDNESDAY = 3;
+        THURSDAY = 4;
+        FRIDAY = 5;
+        SATURDAY = 6;
+        SUNDAY = 7;
+    }
+    optional DAYOFWEEKTYPE dayOfWeek = 1;
+    optional uint32 year = 2;
+    optional uint32 month = 3;
+    optional uint32 dayOfMonth = 4;
+    optional uint32 hour = 5;
+    optional uint32 minute = 6;
+    enum CALENDARTYPE {
+        GREGORIAN = 1;
+        SOLAR_HIJRI = 2;
+    }
+    optional CALENDARTYPE calendar = 7;
+}
+
+message HSMDateTimeUnixEpoch {
+    optional int64 timestamp = 1;
+}
+
+message HSMDateTime {
+    oneof datetimeOneof {
+        HSMDateTimeComponent component = 1;
+        HSMDateTimeUnixEpoch unixEpoch = 2;
+    }
+}
+
+message HSMLocalizableParameter {
+    optional string default = 1;
+    oneof paramOneof {
+        HSMCurrency currency = 2;
+        HSMDateTime dateTime = 3;
+    }
+}
+
+message HighlyStructuredMessage {
+    optional string namespace = 1;
+    optional string elementName = 2;
+    repeated string params = 3;
+    optional string fallbackLg = 4;
+    optional string fallbackLc = 5;
+    repeated HSMLocalizableParameter localizableParams = 6;
+}
+
+message SendPaymentMessage {
+    optional Message noteMessage = 2;
+}
+
+message RequestPaymentMessage {
+    optional string currencyCodeIso4217 = 1;
+    optional uint64 amount1000 = 2;
+    optional string requestFrom = 3;
+    optional Message noteMessage = 4;
+}
+
+message LiveLocationMessage {
+    optional double degreesLatitude = 1;
+    optional double degreesLongitude = 2;
+    optional uint32 accuracyInMeters = 3;
+    optional float speedInMps = 4;
+    optional uint32 degreesClockwiseFromMagneticNorth = 5;
+    optional string caption = 6;
+    optional int64 sequenceNumber = 7;
+    optional bytes jpegThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message StickerMessage {
+    optional string url = 1;
+    optional bytes fileSha256 = 2;
+    optional bytes fileEncSha256 = 3;
+    optional bytes mediaKey = 4;
+    optional string mimetype = 5;
+    optional uint32 height = 6;
+    optional uint32 width = 7;
+    optional string directPath = 8;
+    optional uint64 fileLength = 9;
+    optional bytes pngThumbnail = 16;
+    optional ContextInfo contextInfo = 17;
+}
+
+message Message {
+    optional string conversation = 1;
+    optional SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
+    optional ImageMessage imageMessage = 3;
+    optional ContactMessage contactMessage = 4;
+    optional LocationMessage locationMessage = 5;
+    optional ExtendedTextMessage extendedTextMessage = 6;
+    optional DocumentMessage documentMessage = 7;
+    optional AudioMessage audioMessage = 8;
+    optional VideoMessage videoMessage = 9;
+    optional Call call = 10;
+    optional Chat chat = 11;
+    optional ProtocolMessage protocolMessage = 12;
+    optional ContactsArrayMessage contactsArrayMessage = 13;
+    optional HighlyStructuredMessage highlyStructuredMessage = 14;
+    optional SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
+    optional SendPaymentMessage sendPaymentMessage = 16;
+    optional RequestPaymentMessage requestPaymentMessage = 17;
+    optional LiveLocationMessage liveLocationMessage = 18;
+    optional StickerMessage stickerMessage = 20;
+}
+
+message ContextInfo {
+    optional string stanzaId = 1;
+    optional string participant = 2;
+    repeated Message quotedMessage = 3;
+    optional string remoteJid = 4;
+    repeated string mentionedJid = 15;
+    optional string conversionSource = 18;
+    optional bytes conversionData = 19;
+    optional uint32 conversionDelaySeconds = 20;
+    optional bool isForwarded = 22;
+    reserved 16, 17;
+}
+
+message InteractiveAnnotation {
+    repeated Point polygonVertices = 1;
+    oneof action {
+        Location location = 2;
+    }
+}
+
+message Point {
+    optional double x = 3;
+    optional double y = 4;
+}
+
+message Location {
+    optional double degreesLatitude = 1;
+    optional double degreesLongitude = 2;
+    optional string name = 3;
+}
+
+message WebMessageInfo {
+    required MessageKey key = 1;
+    optional Message message = 2;
+    optional uint64 messageTimestamp = 3;
+    enum STATUS {
+        ERROR = 0;
+        PENDING = 1;
+        SERVER_ACK = 2;
+        DELIVERY_ACK = 3;
+        READ = 4;
+        PLAYED = 5;
+    }
+    optional STATUS status = 4 [default=PENDING];
+    optional string participant = 5;
+    optional bool ignore = 16;
+    optional bool starred = 17;
+    optional bool broadcast = 18;
+    optional string pushName = 19;
+    optional bytes mediaCiphertextSha256 = 20;
+    optional bool multicast = 21;
+    optional bool urlText = 22;
+    optional bool urlNumber = 23;
+    enum STUBTYPE {
+        UNKNOWN = 0;
+        REVOKE = 1;
+        CIPHERTEXT = 2;
+        FUTUREPROOF = 3;
+        NON_VERIFIED_TRANSITION = 4;
+        UNVERIFIED_TRANSITION = 5;
+        VERIFIED_TRANSITION = 6;
+        VERIFIED_LOW_UNKNOWN = 7;
+        VERIFIED_HIGH = 8;
+        VERIFIED_INITIAL_UNKNOWN = 9;
+        VERIFIED_INITIAL_LOW = 10;
+        VERIFIED_INITIAL_HIGH = 11;
+        VERIFIED_TRANSITION_ANY_TO_NONE = 12;
+        VERIFIED_TRANSITION_ANY_TO_HIGH = 13;
+        VERIFIED_TRANSITION_HIGH_TO_LOW = 14;
+        VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15;
+        VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16;
+        VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17;
+        VERIFIED_TRANSITION_NONE_TO_LOW = 18;
+        VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19;
+        GROUP_CREATE = 20;
+        GROUP_CHANGE_SUBJECT = 21;
+        GROUP_CHANGE_ICON = 22;
+        GROUP_CHANGE_INVITE_LINK = 23;
+        GROUP_CHANGE_DESCRIPTION = 24;
+        GROUP_CHANGE_RESTRICT = 25;
+        GROUP_CHANGE_ANNOUNCE = 26;
+        GROUP_PARTICIPANT_ADD = 27;
+        GROUP_PARTICIPANT_REMOVE = 28;
+        GROUP_PARTICIPANT_PROMOTE = 29;
+        GROUP_PARTICIPANT_DEMOTE = 30;
+        GROUP_PARTICIPANT_INVITE = 31;
+        GROUP_PARTICIPANT_LEAVE = 32;
+        GROUP_PARTICIPANT_CHANGE_NUMBER = 33;
+        BROADCAST_CREATE = 34;
+        BROADCAST_ADD = 35;
+        BROADCAST_REMOVE = 36;
+        GENERIC_NOTIFICATION = 37;
+        E2E_IDENTITY_CHANGED = 38;
+        E2E_ENCRYPTED = 39;
+        CALL_MISSED_VOICE = 40;
+        CALL_MISSED_VIDEO = 41;
+        INDIVIDUAL_CHANGE_NUMBER = 42;
+        GROUP_DELETE = 43;
+    }
+    optional STUBTYPE messageStubType = 24;
+    optional bool clearMedia = 25;
+    repeated string messageStubParameters = 26;
+    optional uint32 duration = 27;
+    repeated string labels = 28;
+}
+
+message WebNotificationsInfo {
+    optional uint64 timestamp = 2;
+    optional uint32 unreadChats = 3;
+    optional uint32 notifyMessageCount = 4;
+    repeated Message notifyMessages = 5;
+}
+
+message NotificationMessageInfo {
+    optional MessageKey key = 1;
+    optional Message message = 2;
+    optional uint64 messageTimestamp = 3;
+    optional string participant = 4;
+}
+
+message TabletNotificationsInfo {
+    optional uint64 timestamp = 2;
+    optional uint32 unreadChats = 3;
+    optional uint32 notifyMessageCount = 4;
+    repeated Message notifyMessage = 5;
+}
+
+message WebFeatures {
+    enum FLAG {
+        NOT_IMPLEMENTED = 0;
+        IMPLEMENTED = 1;
+        OPTIONAL = 2;
+    }
+    optional FLAG labelsDisplay = 1;
+    optional FLAG voipIndividualOutgoing = 2;
+    optional FLAG groupsV3 = 3;
+    optional FLAG groupsV3Create = 4;
+    optional FLAG changeNumberV2 = 5;
+    optional FLAG queryStatusV3Thumbnail = 6;
+    optional FLAG liveLocations = 7;
+    optional FLAG queryVname = 8;
+    optional FLAG voipIndividualIncoming = 9;
+    optional FLAG quickRepliesQuery = 10;
+}

vendor/github.com/Rhymen/go-whatsapp/binary/token/token.go

@@ -0,0 +1,78 @@
+package token
+
+import "fmt"
+
+var SingleByteTokens = [...]string{"", "", "", "200", "400", "404", "500", "501", "502", "action", "add",
+	"after", "archive", "author", "available", "battery", "before", "body",
+	"broadcast", "chat", "clear", "code", "composing", "contacts", "count",
+	"create", "debug", "delete", "demote", "duplicate", "encoding", "error",
+	"false", "filehash", "from", "g.us", "group", "groups_v2", "height", "id",
+	"image", "in", "index", "invis", "item", "jid", "kind", "last", "leave",
+	"live", "log", "media", "message", "mimetype", "missing", "modify", "name",
+	"notification", "notify", "out", "owner", "participant", "paused",
+	"picture", "played", "presence", "preview", "promote", "query", "raw",
+	"read", "receipt", "received", "recipient", "recording", "relay",
+	"remove", "response", "resume", "retry", "s.whatsapp.net", "seconds",
+	"set", "size", "status", "subject", "subscribe", "t", "text", "to", "true",
+	"type", "unarchive", "unavailable", "url", "user", "value", "web", "width",
+	"mute", "read_only", "admin", "creator", "short", "update", "powersave",
+	"checksum", "epoch", "block", "previous", "409", "replaced", "reason",
+	"spam", "modify_tag", "message_info", "delivery", "emoji", "title",
+	"description", "canonical-url", "matched-text", "star", "unstar",
+	"media_key", "filename", "identity", "unread", "page", "page_count",
+	"search", "media_message", "security", "call_log", "profile", "ciphertext",
+	"invite", "gif", "vcard", "frequent", "privacy", "blacklist", "whitelist",
+	"verify", "location", "document", "elapsed", "revoke_invite", "expiration",
+	"unsubscribe", "disable", "vname", "old_jid", "new_jid", "announcement",
+	"locked", "prop", "label", "color", "call", "offer", "call-id"}
+
+var doubleByteTokens = [...]string{}
+
+func GetSingleToken(i int) (string, error) {
+	if i < 3 || i >= len(SingleByteTokens) {
+		return "", fmt.Errorf("index out of single byte token bounds %d", i)
+	}
+
+	return SingleByteTokens[i], nil
+}
+
+func GetDoubleToken(index1 int, index2 int) (string, error) {
+	n := 256*index1 + index2
+	if n < 0 || n >= len(doubleByteTokens) {
+		return "", fmt.Errorf("index out of double byte token bounds %d", n)
+	}
+
+	return doubleByteTokens[n], nil
+}
+
+func IndexOfSingleToken(token string) int {
+	for i, t := range SingleByteTokens {
+		if t == token {
+			return i
+		}
+	}
+
+	return -1
+}
+
+const (
+	LIST_EMPTY   = 0
+	STREAM_END   = 2
+	DICTIONARY_0 = 236
+	DICTIONARY_1 = 237
+	DICTIONARY_2 = 238
+	DICTIONARY_3 = 239
+	LIST_8       = 248
+	LIST_16      = 249
+	JID_PAIR     = 250
+	HEX_8        = 251
+	BINARY_8     = 252
+	BINARY_20    = 253
+	BINARY_32    = 254
+	NIBBLE_8     = 255
+)
+
+const (
+	PACKED_MAX      = 254
+	SINGLE_BYTE_MAX = 256
+)

vendor/github.com/Rhymen/go-whatsapp/conn.go

@@ -0,0 +1,389 @@
+//Package whatsapp provides a developer API to interact with the WhatsAppWeb-Servers.
+package whatsapp
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Rhymen/go-whatsapp/binary"
+	"github.com/Rhymen/go-whatsapp/crypto/cbc"
+	"github.com/gorilla/websocket"
+)
+
+type metric byte
+
+const (
+	debugLog metric = iota + 1
+	queryResume
+	queryReceipt
+	queryMedia
+	queryChat
+	queryContacts
+	queryMessages
+	presence
+	presenceSubscribe
+	group
+	read
+	chat
+	received
+	pic
+	status
+	message
+	queryActions
+	block
+	queryGroup
+	queryPreview
+	queryEmoji
+	queryMessageInfo
+	spam
+	querySearch
+	queryIdentity
+	queryUrl
+	profile
+	contact
+	queryVcard
+	queryStatus
+	queryStatusUpdate
+	privacyStatus
+	queryLiveLocations
+	liveLocation
+	queryVname
+	queryLabels
+	call
+	queryCall
+	queryQuickReplies
+)
+
+type flag byte
+
+const (
+	ignore flag = 1 << (7 - iota)
+	ackRequest
+	available
+	notAvailable
+	expires
+	skipOffline
+)
+
+/*
+Conn is created by NewConn. Interacting with the initialized Conn is the main way of interacting with our package.
+It holds all necessary information to make the package work internally.
+*/
+type Conn struct {
+	wsConn         *websocket.Conn
+	wsConnOK       bool
+	wsConnMutex    sync.RWMutex
+	session        *Session
+	listener       map[string]chan string
+	listenerMutex  sync.RWMutex
+	writeChan      chan wsMsg
+	handler        []Handler
+	msgCount       int
+	msgTimeout     time.Duration
+	Info           *Info
+	Store          *Store
+	ServerLastSeen time.Time
+
+	longClientName  string
+	shortClientName string
+}
+
+type wsMsg struct {
+	messageType int
+	data        []byte
+}
+
+/*
+Creates a new connection with a given timeout. The websocket connection to the WhatsAppWeb servers get´s established.
+The goroutine for handling incoming messages is started
+*/
+func NewConn(timeout time.Duration) (*Conn, error) {
+	wac := &Conn{
+		wsConn:        nil, // will be set in connect()
+		wsConnMutex:   sync.RWMutex{},
+		listener:      make(map[string]chan string),
+		listenerMutex: sync.RWMutex{},
+		writeChan:     make(chan wsMsg),
+		handler:       make([]Handler, 0),
+		msgCount:      0,
+		msgTimeout:    timeout,
+		Store:         newStore(),
+
+		longClientName:  "github.com/rhymen/go-whatsapp",
+		shortClientName: "go-whatsapp",
+	}
+
+	if err := wac.connect(); err != nil {
+		return nil, err
+	}
+
+	go wac.readPump()
+	go wac.writePump()
+	go wac.keepAlive(20000, 90000)
+
+	return wac, nil
+}
+
+func (wac *Conn) isConnected() bool {
+	wac.wsConnMutex.RLock()
+	defer wac.wsConnMutex.RUnlock()
+	if wac.wsConn == nil {
+		return false
+	}
+	if wac.wsConnOK {
+		return true
+	}
+
+	// just send a keepalive to test the connection
+	wac.sendKeepAlive()
+
+	// this method is expected to be called by loops. So we can just return false
+	return false
+}
+
+// connect should be guarded with wsConnMutex
+func (wac *Conn) connect() error {
+	dialer := &websocket.Dialer{
+		ReadBufferSize:   25 * 1024 * 1024,
+		WriteBufferSize:  10 * 1024 * 1024,
+		HandshakeTimeout: wac.msgTimeout,
+	}
+
+	headers := http.Header{"Origin": []string{"https://web.whatsapp.com"}}
+	wsConn, _, err := dialer.Dial("wss://web.whatsapp.com/ws", headers)
+	if err != nil {
+		return fmt.Errorf("couldn't dial whatsapp web websocket: %v", err)
+	}
+
+	wsConn.SetCloseHandler(func(code int, text string) error {
+		fmt.Fprintf(os.Stderr, "websocket connection closed(%d, %s)\n", code, text)
+
+		// from default CloseHandler
+		message := websocket.FormatCloseMessage(code, "")
+		wsConn.WriteControl(websocket.CloseMessage, message, time.Now().Add(time.Second))
+
+		// our close handling
+		if websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
+			fmt.Println("Trigger reconnect")
+			go wac.reconnect()
+		}
+		return nil
+	})
+
+	wac.wsConn = wsConn
+	wac.wsConnOK = true
+	return nil
+}
+
+// reconnect should be run as go routine
+func (wac *Conn) reconnect() {
+	wac.wsConnMutex.Lock()
+	wac.wsConn.Close()
+	wac.wsConn = nil
+	wac.wsConnOK = false
+	wac.wsConnMutex.Unlock()
+
+	// wait up to 60 seconds and then reconnect. As writePump should send immediately, it might
+	// reconnect as well. So we check its existance before reconnecting
+	for !wac.isConnected() {
+		time.Sleep(time.Duration(rand.Intn(60)) * time.Second)
+
+		wac.wsConnMutex.Lock()
+		if wac.wsConn == nil {
+			if err := wac.connect(); err != nil {
+				fmt.Fprintf(os.Stderr, "could not reconnect to websocket: %v\n", err)
+			}
+		}
+		wac.wsConnMutex.Unlock()
+	}
+}
+
+func (wac *Conn) write(data []interface{}) (<-chan string, error) {
+	d, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	ts := time.Now().Unix()
+	messageTag := fmt.Sprintf("%d.--%d", ts, wac.msgCount)
+	msg := fmt.Sprintf("%s,%s", messageTag, d)
+
+	ch := make(chan string, 1)
+
+	wac.listenerMutex.Lock()
+	wac.listener[messageTag] = ch
+	wac.listenerMutex.Unlock()
+
+	wac.writeChan <- wsMsg{websocket.TextMessage, []byte(msg)}
+
+	wac.msgCount++
+	return ch, nil
+}
+
+func (wac *Conn) writeBinary(node binary.Node, metric metric, flag flag, tag string) (<-chan string, error) {
+	if len(tag) < 2 {
+		return nil, fmt.Errorf("no tag specified or to short")
+	}
+	b, err := binary.Marshal(node)
+	if err != nil {
+		return nil, err
+	}
+
+	cipher, err := cbc.Encrypt(wac.session.EncKey, nil, b)
+	if err != nil {
+		return nil, err
+	}
+
+	h := hmac.New(sha256.New, wac.session.MacKey)
+	h.Write(cipher)
+	hash := h.Sum(nil)
+
+	data := []byte(tag + ",")
+	data = append(data, byte(metric), byte(flag))
+	data = append(data, hash[:32]...)
+	data = append(data, cipher...)
+
+	ch := make(chan string, 1)
+
+	wac.listenerMutex.Lock()
+	wac.listener[tag] = ch
+	wac.listenerMutex.Unlock()
+
+	msg := wsMsg{websocket.BinaryMessage, data}
+	wac.writeChan <- msg
+
+	wac.msgCount++
+	return ch, nil
+}
+
+func (wac *Conn) readPump() {
+	defer wac.wsConn.Close()
+
+	for {
+		msgType, msg, err := wac.wsConn.ReadMessage()
+		if err != nil {
+			wac.wsConnOK = false
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
+				wac.handle(fmt.Errorf("unexpected websocket close: %v", err))
+			}
+			// sleep for a second and retry reading the next message
+			time.Sleep(time.Second)
+			continue
+		}
+		wac.wsConnOK = true
+
+		data := strings.SplitN(string(msg), ",", 2)
+
+		//Kepp-Alive Timestmap
+		if data[0][0] == '!' {
+			msecs, err := strconv.ParseInt(data[0][1:], 10, 64)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error converting time string to uint: %v\n", err)
+				continue
+			}
+			wac.ServerLastSeen = time.Unix(msecs/1000, (msecs%1000)*int64(time.Millisecond))
+			continue
+		}
+
+		wac.listenerMutex.RLock()
+		listener, hasListener := wac.listener[data[0]]
+		wac.listenerMutex.RUnlock()
+
+		if len(data[1]) == 0 {
+			continue
+		} else if hasListener {
+			listener <- data[1]
+
+			wac.listenerMutex.Lock()
+			delete(wac.listener, data[0])
+			wac.listenerMutex.Unlock()
+		} else if msgType == 2 && wac.session != nil && wac.session.EncKey != nil {
+			message, err := wac.decryptBinaryMessage([]byte(data[1]))
+			if err != nil {
+				wac.handle(fmt.Errorf("error decoding binary: %v", err))
+				continue
+			}
+
+			wac.dispatch(message)
+		} else {
+			wac.handle(string(data[1]))
+		}
+
+	}
+}
+
+func (wac *Conn) writePump() {
+	for msg := range wac.writeChan {
+		for !wac.isConnected() {
+			// reconnect to send the message ASAP
+			wac.wsConnMutex.Lock()
+			if wac.wsConn == nil {
+				if err := wac.connect(); err != nil {
+					fmt.Fprintf(os.Stderr, "could not reconnect to websocket: %v\n", err)
+				}
+			}
+			wac.wsConnMutex.Unlock()
+			if !wac.isConnected() {
+				// reconnecting failed. Sleep for a while and try again afterwards
+				time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
+			}
+		}
+		if err := wac.wsConn.WriteMessage(msg.messageType, msg.data); err != nil {
+			fmt.Fprintf(os.Stderr, "error writing to socket: %v\n", err)
+			wac.wsConnOK = false
+			// add message to channel again to no loose it
+			go func() {
+				wac.writeChan <- msg
+			}()
+		}
+	}
+}
+
+func (wac *Conn) sendKeepAlive() {
+	// whatever issues might be there allow sending this message
+	wac.wsConnOK = true
+	wac.writeChan <- wsMsg{
+		messageType: websocket.TextMessage,
+		data:        []byte("?,,"),
+	}
+}
+
+func (wac *Conn) keepAlive(minIntervalMs int, maxIntervalMs int) {
+	for {
+		wac.sendKeepAlive()
+		interval := rand.Intn(maxIntervalMs-minIntervalMs) + minIntervalMs
+		<-time.After(time.Duration(interval) * time.Millisecond)
+	}
+}
+
+func (wac *Conn) decryptBinaryMessage(msg []byte) (*binary.Node, error) {
+	//message validation
+	h2 := hmac.New(sha256.New, wac.session.MacKey)
+	h2.Write([]byte(msg[32:]))
+	if !hmac.Equal(h2.Sum(nil), msg[:32]) {
+		return nil, fmt.Errorf("message received with invalid hmac")
+	}
+
+	// message decrypt
+	d, err := cbc.Decrypt(wac.session.EncKey, nil, msg[32:])
+	if err != nil {
+		return nil, fmt.Errorf("error decrypting message with AES: %v", err)
+	}
+
+	// message unmarshal
+	message, err := binary.Unmarshal(d)
+	if err != nil {
+		return nil, fmt.Errorf("error decoding binary: %v", err)
+	}
+
+	return message, nil
+}

vendor/github.com/Rhymen/go-whatsapp/contact.go

@@ -0,0 +1,267 @@
+package whatsapp
+
+import (
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/binary"
+	"strconv"
+	"time"
+)
+
+type Presence string
+
+const (
+	PresenceAvailable   = "available"
+	PresenceUnavailable = "unavailable"
+	PresenceComposing   = "composing"
+	PresenceRecording	= "recording"
+	PresencePaused	= "paused"
+)
+
+//TODO: filename? WhatsApp uses Store.Contacts for these functions
+//TODO: functions probably shouldn't return a string, maybe build a struct / return json
+//TODO: check for further queries
+func (wac *Conn) GetProfilePicThumb(jid string) (<-chan string, error) {
+	data := []interface{}{"query", "ProfilePicThumb", jid}
+	return wac.write(data)
+}
+
+func (wac *Conn) GetStatus(jid string) (<-chan string, error) {
+	data := []interface{}{"query", "Status", jid}
+	return wac.write(data)
+}
+
+func (wac *Conn) GetGroupMetaData(jid string) (<-chan string, error) {
+	data := []interface{}{"query", "GroupMetadata", jid}
+	return wac.write(data)
+}
+
+func (wac *Conn) SubscribePresence(jid string) (<-chan string, error) {
+	data := []interface{}{"action", "presence", "subscribe", jid}
+	return wac.write(data)
+}
+
+func (wac *Conn) CreateGroup(subject string, participants []string) (<-chan string, error) {
+	return wac.setGroup("create", "", subject, participants)
+}
+
+func (wac *Conn) UpdateGroupSubject(subject string, jid string) (<-chan string, error) {
+	return wac.setGroup("subject", jid, subject, nil)
+}
+
+func (wac *Conn) SetAdmin(jid string, participants []string) (<-chan string, error) {
+	return wac.setGroup("promote", jid, "", participants)
+}
+
+func (wac *Conn) RemoveAdmin(jid string, participants []string) (<-chan string, error) {
+	return wac.setGroup("demote", jid, "", participants)
+}
+
+func (wac *Conn) AddMember(jid string, participants []string) (<-chan string, error) {
+	return wac.setGroup("add", jid, "", participants)
+}
+
+func (wac *Conn) RemoveMember(jid string, participants []string) (<-chan string, error) {
+	return wac.setGroup("remove", jid, "", participants)
+}
+
+func (wac *Conn) LeaveGroup(jid string) (<-chan string, error) {
+	return wac.setGroup("leave", jid, "", nil)
+}
+
+func (wac *Conn) Search(search string, count, page int) (*binary.Node, error) {
+	return wac.query("search", "", "", "", "", search, count, page)
+}
+
+func (wac *Conn) LoadMessages(jid, messageId string, count int) (*binary.Node, error) {
+	return wac.query("message", jid, "", "before", "true", "", count, 0)
+}
+
+func (wac *Conn) LoadMessagesBefore(jid, messageId string, count int) (*binary.Node, error) {
+	return wac.query("message", jid, messageId, "before", "true", "", count, 0)
+}
+
+func (wac *Conn) LoadMessagesAfter(jid, messageId string, count int) (*binary.Node, error) {
+	return wac.query("message", jid, messageId, "after", "true", "", count, 0)
+}
+
+func (wac *Conn) Presence(jid string, presence Presence) (<-chan string, error) {
+	ts := time.Now().Unix()
+	tag := fmt.Sprintf("%d.--%d", ts, wac.msgCount)
+
+	content := binary.Node{
+		Description: "presence",
+		Attributes: map[string]string{
+			"type": string(presence),
+		},
+	}
+	switch presence {
+	case PresenceComposing:
+		fallthrough
+	case PresenceRecording:
+		fallthrough
+	case PresencePaused:
+		content.Attributes["to"] = jid
+	}
+
+	n := binary.Node{
+		Description: "action",
+		Attributes: map[string]string{
+			"type":  "set",
+			"epoch": strconv.Itoa(wac.msgCount),
+		},
+		Content: []interface{}{content},
+	}
+
+	return wac.writeBinary(n, group, ignore, tag)
+}
+
+func (wac *Conn) Exist(jid string) (<-chan string, error) {
+	data := []interface{}{"query", "exist", jid}
+	return wac.write(data)
+}
+
+func (wac *Conn) Emoji() (*binary.Node, error) {
+	return wac.query("emoji", "", "", "", "", "", 0, 0)
+}
+
+func (wac *Conn) Contacts() (*binary.Node, error) {
+	return wac.query("contacts", "", "", "", "", "", 0, 0)
+}
+
+func (wac *Conn) Chats() (*binary.Node, error) {
+	return wac.query("chat", "", "", "", "", "", 0, 0)
+}
+
+func (wac *Conn) Read(jid, id string) (<-chan string, error) {
+	ts := time.Now().Unix()
+	tag := fmt.Sprintf("%d.--%d", ts, wac.msgCount)
+
+	n := binary.Node{
+		Description: "action",
+		Attributes: map[string]string{
+			"type":  "set",
+			"epoch": strconv.Itoa(wac.msgCount),
+		},
+		Content: []interface{}{binary.Node{
+			Description: "read",
+			Attributes: map[string]string{
+				"count": "1",
+				"index": id,
+				"jid":   jid,
+				"owner": "false",
+			},
+		}},
+	}
+
+	return wac.writeBinary(n, group, ignore, tag)
+}
+
+func (wac *Conn) query(t, jid, messageId, kind, owner, search string, count, page int) (*binary.Node, error) {
+	ts := time.Now().Unix()
+	tag := fmt.Sprintf("%d.--%d", ts, wac.msgCount)
+
+	n := binary.Node{
+		Description: "query",
+		Attributes: map[string]string{
+			"type":  t,
+			"epoch": strconv.Itoa(wac.msgCount),
+		},
+	}
+
+	if jid != "" {
+		n.Attributes["jid"] = jid
+	}
+
+	if messageId != "" {
+		n.Attributes["index"] = messageId
+	}
+
+	if kind != "" {
+		n.Attributes["kind"] = kind
+	}
+
+	if owner != "" {
+		n.Attributes["owner"] = owner
+	}
+
+	if search != "" {
+		n.Attributes["search"] = search
+	}
+
+	if count != 0 {
+		n.Attributes["count"] = strconv.Itoa(count)
+	}
+
+	if page != 0 {
+		n.Attributes["page"] = strconv.Itoa(page)
+	}
+
+	ch, err := wac.writeBinary(n, group, ignore, tag)
+	if err != nil {
+		return nil, err
+	}
+
+	msg, err := wac.decryptBinaryMessage([]byte(<-ch))
+	if err != nil {
+		return nil, err
+	}
+
+	//TODO: use parseProtoMessage
+	return msg, nil
+}
+
+func (wac *Conn) setGroup(t, jid, subject string, participants []string) (<-chan string, error) {
+	ts := time.Now().Unix()
+	tag := fmt.Sprintf("%d.--%d", ts, wac.msgCount)
+
+	//TODO: get proto or improve encoder to handle []interface{}
+
+	p := buildParticipantNodes(participants)
+
+	g := binary.Node{
+		Description: "group",
+		Attributes: map[string]string{
+			"author": wac.session.Wid,
+			"id":     tag,
+			"type":   t,
+		},
+		Content: p,
+	}
+
+	if jid != "" {
+		g.Attributes["jid"] = jid
+	}
+
+	if subject != "" {
+		g.Attributes["subject"] = subject
+	}
+
+	n := binary.Node{
+		Description: "action",
+		Attributes: map[string]string{
+			"type":  "set",
+			"epoch": strconv.Itoa(wac.msgCount),
+		},
+		Content: []interface{}{g},
+	}
+
+	return wac.writeBinary(n, group, ignore, tag)
+}
+
+func buildParticipantNodes(participants []string) []binary.Node {
+	l := len(participants)
+	if participants == nil || l == 0 {
+		return nil
+	}
+
+	p := make([]binary.Node, len(participants))
+	for i, participant := range participants {
+		p[i] = binary.Node{
+			Description: "participant",
+			Attributes: map[string]string{
+				"jid": participant,
+			},
+		}
+	}
+	return p
+}

vendor/github.com/Rhymen/go-whatsapp/crypto/cbc/cbc.go

@@ -0,0 +1,101 @@
+/*
+CBC describes a block cipher mode. In cryptography, a block cipher mode of operation is an algorithm that uses a
+block cipher to provide an information service such as confidentiality or authenticity. A block cipher by itself
+is only suitable for the secure cryptographic transformation (encryption or decryption) of one fixed-length group of
+bits called a block. A mode of operation describes how to repeatedly apply a cipher's single-block operation to
+securely transform amounts of data larger than a block.
+
+This package simplifies the usage of AES-256-CBC.
+*/
+package cbc
+
+/*
+Some code is provided by the GitHub user locked (github.com/locked):
+https://gist.github.com/locked/b066aa1ddeb2b28e855e
+Thanks!
+*/
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"fmt"
+	"io"
+)
+
+/*
+Decrypt is a function that decrypts a given cipher text with a provided key and initialization vector(iv).
+*/
+func Decrypt(key, iv, ciphertext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ciphertext) < aes.BlockSize {
+		return nil, fmt.Errorf("ciphertext is shorter then block size: %d / %d", len(ciphertext), aes.BlockSize)
+	}
+
+	if iv == nil {
+		iv = ciphertext[:aes.BlockSize]
+		ciphertext = ciphertext[aes.BlockSize:]
+	}
+
+	cbc := cipher.NewCBCDecrypter(block, iv)
+	cbc.CryptBlocks(ciphertext, ciphertext)
+
+	return unpad(ciphertext)
+}
+
+/*
+Encrypt is a function that encrypts plaintext with a given key and an optional initialization vector(iv).
+*/
+func Encrypt(key, iv, plaintext []byte) ([]byte, error) {
+	plaintext = pad(plaintext, aes.BlockSize)
+
+	if len(plaintext)%aes.BlockSize != 0 {
+		return nil, fmt.Errorf("plaintext is not a multiple of the block size: %d / %d", len(plaintext), aes.BlockSize)
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	var ciphertext []byte
+	if iv == nil {
+		ciphertext = make([]byte, aes.BlockSize+len(plaintext))
+		iv := ciphertext[:aes.BlockSize]
+		if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+			return nil, err
+		}
+
+		cbc := cipher.NewCBCEncrypter(block, iv)
+		cbc.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)
+	} else {
+		ciphertext = make([]byte, len(plaintext))
+
+		cbc := cipher.NewCBCEncrypter(block, iv)
+		cbc.CryptBlocks(ciphertext, plaintext)
+	}
+
+	return ciphertext, nil
+}
+
+func pad(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+func unpad(src []byte) ([]byte, error) {
+	length := len(src)
+	padLen := int(src[length-1])
+
+	if padLen > length {
+		return nil, fmt.Errorf("padding is greater then the length: %d / %d", padLen, length)
+	}
+
+	return src[:(length - padLen)], nil
+}

vendor/github.com/Rhymen/go-whatsapp/crypto/curve25519/curve.go

@@ -0,0 +1,44 @@
+/*
+In cryptography, Curve25519 is an elliptic curve offering 128 bits of security and designed for use with the elliptic
+curve Diffie–Hellman (ECDH) key agreement scheme. It is one of the fastest ECC curves and is not covered by any known
+patents. The reference implementation is public domain software. The original Curve25519 paper defined it
+as a Diffie–Hellman (DH) function.
+*/
+package curve25519
+
+import (
+	"crypto/rand"
+	"golang.org/x/crypto/curve25519"
+	"io"
+)
+
+/*
+GenerateKey generates a public private key pair using Curve25519.
+*/
+func GenerateKey() (privateKey *[32]byte, publicKey *[32]byte, err error) {
+	var pub, priv [32]byte
+
+	_, err = io.ReadFull(rand.Reader, priv[:])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	priv[0] &= 248
+	priv[31] &= 127
+	priv[31] |= 64
+
+	curve25519.ScalarBaseMult(&pub, &priv)
+
+	return &priv, &pub, nil
+}
+
+/*
+GenerateSharedSecret generates the shared secret with a given public private key pair.
+*/
+func GenerateSharedSecret(priv, pub [32]byte) []byte {
+	var secret [32]byte
+
+	curve25519.ScalarMult(&secret, &priv, &pub)
+
+	return secret[:]
+}

vendor/github.com/Rhymen/go-whatsapp/crypto/hkdf/hkdf.go

@@ -0,0 +1,52 @@
+/*
+HKDF is a simple key derivation function (KDF) based on
+a hash-based message authentication code (HMAC). It was initially proposed by its authors as a building block in
+various protocols and applications, as well as to discourage the proliferation of multiple KDF mechanisms.
+The main approach HKDF follows is the "extract-then-expand" paradigm, where the KDF logically consists of two modules:
+the first stage takes the input keying material and "extracts" from it a fixed-length pseudorandom key, and then the
+second stage "expands" this key into several additional pseudorandom keys (the output of the KDF).
+*/
+package hkdf
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"fmt"
+	"golang.org/x/crypto/hkdf"
+	"io"
+)
+
+/*
+Expand expands a given key with the HKDF algorithm.
+*/
+func Expand(key []byte, length int, info string) ([]byte, error) {
+	if info == "" {
+		keyBlock := hmac.New(sha256.New, key)
+		var out, last []byte
+
+		var blockIndex byte = 1
+		for i := 0; len(out) < length; i++ {
+			keyBlock.Reset()
+			//keyBlock.Write(append(append(last, []byte(info)...), blockIndex))
+			keyBlock.Write(last)
+			keyBlock.Write([]byte(info))
+			keyBlock.Write([]byte{blockIndex})
+			last = keyBlock.Sum(nil)
+			blockIndex += 1
+			out = append(out, last...)
+		}
+		return out[:length], nil
+	} else {
+		h := hkdf.New(sha256.New, key, nil, []byte(info))
+		out := make([]byte, length)
+		n, err := io.ReadAtLeast(h, out, length)
+		if err != nil {
+			return nil, err
+		}
+		if n != length {
+			return nil, fmt.Errorf("new key to short")
+		}
+
+		return out[:length], nil
+	}
+}

vendor/github.com/Rhymen/go-whatsapp/go.mod

@@ -0,0 +1,8 @@
+module github.com/Rhymen/go-whatsapp
+
+require (
+	github.com/golang/protobuf v1.2.0
+	github.com/gorilla/websocket v1.4.0
+	golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613
+	golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 // indirect
+)

vendor/github.com/Rhymen/go-whatsapp/go.sum

@@ -0,0 +1,4 @@
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

vendor/github.com/Rhymen/go-whatsapp/handler.go

@@ -0,0 +1,169 @@
+package whatsapp
+
+import (
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/binary"
+	"github.com/Rhymen/go-whatsapp/binary/proto"
+	"os"
+)
+
+/*
+The Handler interface is the minimal interface that needs to be implemented
+to be accepted as a valid handler for our dispatching system.
+The minimal handler is used to dispatch error messages. These errors occur on unexpected behavior by the websocket
+connection or if we are unable to handle or interpret an incoming message. Error produced by user actions are not
+dispatched through this handler. They are returned as an error on the specific function call.
+*/
+type Handler interface {
+	HandleError(err error)
+}
+
+/*
+The TextMessageHandler interface needs to be implemented to receive text messages dispatched by the dispatcher.
+*/
+type TextMessageHandler interface {
+	Handler
+	HandleTextMessage(message TextMessage)
+}
+
+/*
+The ImageMessageHandler interface needs to be implemented to receive image messages dispatched by the dispatcher.
+*/
+type ImageMessageHandler interface {
+	Handler
+	HandleImageMessage(message ImageMessage)
+}
+
+/*
+The VideoMessageHandler interface needs to be implemented to receive video messages dispatched by the dispatcher.
+*/
+type VideoMessageHandler interface {
+	Handler
+	HandleVideoMessage(message VideoMessage)
+}
+
+/*
+The AudioMessageHandler interface needs to be implemented to receive audio messages dispatched by the dispatcher.
+*/
+type AudioMessageHandler interface {
+	Handler
+	HandleAudioMessage(message AudioMessage)
+}
+
+/*
+The DocumentMessageHandler interface needs to be implemented to receive document messages dispatched by the dispatcher.
+*/
+type DocumentMessageHandler interface {
+	Handler
+	HandleDocumentMessage(message DocumentMessage)
+}
+
+/*
+The JsonMessageHandler interface needs to be implemented to receive json messages dispatched by the dispatcher.
+These json messages contain status updates of every kind sent by WhatsAppWeb servers. WhatsAppWeb uses these messages
+to built a Store, which is used to save these "secondary" information. These messages may contain
+presence (available, last see) information, or just the battery status of your phone.
+*/
+type JsonMessageHandler interface {
+	Handler
+	HandleJsonMessage(message string)
+}
+
+/**
+The RawMessageHandler interface needs to be implemented to receive raw messages dispatched by the dispatcher.
+Raw messages are the raw protobuf structs instead of the easy-to-use structs in TextMessageHandler, ImageMessageHandler, etc..
+*/
+type RawMessageHandler interface {
+	Handler
+	HandleRawMessage(message *proto.WebMessageInfo)
+}
+
+/*
+AddHandler adds an handler to the list of handler that receive dispatched messages.
+The provided handler must at least implement the Handler interface. Additionally implemented
+handlers(TextMessageHandler, ImageMessageHandler) are optional. At runtime it is checked if they are implemented
+and they are called if so and needed.
+*/
+func (wac *Conn) AddHandler(handler Handler) {
+	wac.handler = append(wac.handler, handler)
+}
+
+func (wac *Conn) handle(message interface{}) {
+	switch m := message.(type) {
+	case error:
+		for _, h := range wac.handler {
+			go h.HandleError(m)
+		}
+	case string:
+		for _, h := range wac.handler {
+			if x, ok := h.(JsonMessageHandler); ok {
+				go x.HandleJsonMessage(m)
+			}
+		}
+	case TextMessage:
+		for _, h := range wac.handler {
+			if x, ok := h.(TextMessageHandler); ok {
+				go x.HandleTextMessage(m)
+			}
+		}
+	case ImageMessage:
+		for _, h := range wac.handler {
+			if x, ok := h.(ImageMessageHandler); ok {
+				go x.HandleImageMessage(m)
+			}
+		}
+	case VideoMessage:
+		for _, h := range wac.handler {
+			if x, ok := h.(VideoMessageHandler); ok {
+				go x.HandleVideoMessage(m)
+			}
+		}
+	case AudioMessage:
+		for _, h := range wac.handler {
+			if x, ok := h.(AudioMessageHandler); ok {
+				go x.HandleAudioMessage(m)
+			}
+		}
+	case DocumentMessage:
+		for _, h := range wac.handler {
+			if x, ok := h.(DocumentMessageHandler); ok {
+				go x.HandleDocumentMessage(m)
+			}
+		}
+	case *proto.WebMessageInfo:
+		for _, h := range wac.handler {
+			if x, ok := h.(RawMessageHandler); ok {
+				go x.HandleRawMessage(m)
+			}
+		}
+	}
+
+}
+
+func (wac *Conn) dispatch(msg interface{}) {
+	if msg == nil {
+		return
+	}
+
+	switch message := msg.(type) {
+	case *binary.Node:
+		if message.Description == "action" {
+			if con, ok := message.Content.([]interface{}); ok {
+				for a := range con {
+					if v, ok := con[a].(*proto.WebMessageInfo); ok {
+						wac.handle(v)
+						wac.handle(parseProtoMessage(v))
+					}
+				}
+			}
+		} else if message.Description == "response" && message.Attributes["type"] == "contacts" {
+			wac.updateContacts(message.Content)
+		}
+	case error:
+		wac.handle(message)
+	case string:
+		wac.handle(message)
+	default:
+		fmt.Fprintf(os.Stderr, "unknown type in dipatcher chan: %T", msg)
+	}
+}

vendor/github.com/Rhymen/go-whatsapp/media.go

@@ -0,0 +1,199 @@
+package whatsapp
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/crypto/cbc"
+	"github.com/Rhymen/go-whatsapp/crypto/hkdf"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+func Download(url string, mediaKey []byte, appInfo MediaType, fileLength int) ([]byte, error) {
+	if url == "" {
+		return nil, fmt.Errorf("no url present")
+	}
+	file, mac, err := downloadMedia(url)
+	if err != nil {
+		return nil, err
+	}
+	iv, cipherKey, macKey, _, err := getMediaKeys(mediaKey, appInfo)
+	if err != nil {
+		return nil, err
+	}
+	if err = validateMedia(iv, file, macKey, mac); err != nil {
+		return nil, err
+	}
+	data, err := cbc.Decrypt(cipherKey, iv, file)
+	if err != nil {
+		return nil, err
+	}
+	if len(data) != fileLength {
+		return nil, fmt.Errorf("file length does not match")
+	}
+	return data, nil
+}
+
+func validateMedia(iv []byte, file []byte, macKey []byte, mac []byte) error {
+	h := hmac.New(sha256.New, macKey)
+	n, err := h.Write(append(iv, file...))
+	if err != nil {
+		return err
+	}
+	if n < 10 {
+		return fmt.Errorf("hash to short")
+	}
+	if !hmac.Equal(h.Sum(nil)[:10], mac) {
+		return fmt.Errorf("invalid media hmac")
+	}
+	return nil
+}
+
+func getMediaKeys(mediaKey []byte, appInfo MediaType) (iv, cipherKey, macKey, refKey []byte, err error) {
+	mediaKeyExpanded, err := hkdf.Expand(mediaKey, 112, string(appInfo))
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+	return mediaKeyExpanded[:16], mediaKeyExpanded[16:48], mediaKeyExpanded[48:80], mediaKeyExpanded[80:], nil
+}
+
+func downloadMedia(url string) (file []byte, mac []byte, err error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, nil, err
+	}
+	if resp.StatusCode != 200 {
+		return nil, nil, fmt.Errorf("download failed")
+	}
+	defer resp.Body.Close()
+	if resp.ContentLength <= 10 {
+		return nil, nil, fmt.Errorf("file to short")
+	}
+	data, err := ioutil.ReadAll(resp.Body)
+	n := len(data)
+	if err != nil {
+		return nil, nil, err
+	}
+	return data[:n-10], data[n-10 : n], nil
+}
+
+func (wac *Conn) Upload(reader io.Reader, appInfo MediaType) (url string, mediaKey []byte, fileEncSha256 []byte, fileSha256 []byte, fileLength uint64, err error) {
+	data, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	mediaKey = make([]byte, 32)
+	rand.Read(mediaKey)
+
+	iv, cipherKey, macKey, _, err := getMediaKeys(mediaKey, appInfo)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	enc, err := cbc.Encrypt(cipherKey, iv, data)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	fileLength = uint64(len(data))
+
+	h := hmac.New(sha256.New, macKey)
+	h.Write(append(iv, enc...))
+	mac := h.Sum(nil)[:10]
+
+	sha := sha256.New()
+	sha.Write(data)
+	fileSha256 = sha.Sum(nil)
+
+	sha.Reset()
+	sha.Write(append(enc, mac...))
+	fileEncSha256 = sha.Sum(nil)
+
+	var filetype string
+	switch appInfo {
+	case MediaImage:
+		filetype = "image"
+	case MediaAudio:
+		filetype = "audio"
+	case MediaDocument:
+		filetype = "document"
+	case MediaVideo:
+		filetype = "video"
+	}
+
+	uploadReq := []interface{}{"action", "encr_upload", filetype, base64.StdEncoding.EncodeToString(fileEncSha256)}
+	ch, err := wac.write(uploadReq)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	var resp map[string]interface{}
+	select {
+	case r := <-ch:
+		if err = json.Unmarshal([]byte(r), &resp); err != nil {
+			return "", nil, nil, nil, 0, fmt.Errorf("error decoding upload response: %v\n", err)
+		}
+	case <-time.After(wac.msgTimeout):
+		return "", nil, nil, nil, 0, fmt.Errorf("restore session init timed out")
+	}
+
+	if int(resp["status"].(float64)) != 200 {
+		return "", nil, nil, nil, 0, fmt.Errorf("upload responsed with %d", resp["status"])
+	}
+
+	var b bytes.Buffer
+	w := multipart.NewWriter(&b)
+	hashWriter, err := w.CreateFormField("hash")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+	}
+	io.Copy(hashWriter, strings.NewReader(base64.StdEncoding.EncodeToString(fileEncSha256)))
+
+	fileWriter, err := w.CreateFormFile("file", "blob")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+	}
+	io.Copy(fileWriter, bytes.NewReader(append(enc, mac...)))
+	err = w.Close()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+	}
+
+	req, err := http.NewRequest("POST", resp["url"].(string), &b)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	req.Header.Set("Origin", "https://web.whatsapp.com")
+	req.Header.Set("Referer", "https://web.whatsapp.com/")
+
+	req.URL.Query().Set("f", "j")
+
+	client := &http.Client{}
+	// Submit the request
+	res, err := client.Do(req)
+	if err != nil {
+		return "", nil, nil, nil, 0, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return "", nil, nil, nil, 0, fmt.Errorf("upload failed with status code %d", res.StatusCode)
+	}
+
+	var jsonRes map[string]string
+	json.NewDecoder(res.Body).Decode(&jsonRes)
+
+	return jsonRes["url"], mediaKey, fileEncSha256, fileSha256, fileLength, nil
+}

vendor/github.com/Rhymen/go-whatsapp/message.go

@@ -0,0 +1,442 @@
+package whatsapp
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"github.com/Rhymen/go-whatsapp/binary"
+	"github.com/Rhymen/go-whatsapp/binary/proto"
+	"io"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type MediaType string
+
+const (
+	MediaImage    MediaType = "WhatsApp Image Keys"
+	MediaVideo    MediaType = "WhatsApp Video Keys"
+	MediaAudio    MediaType = "WhatsApp Audio Keys"
+	MediaDocument MediaType = "WhatsApp Document Keys"
+)
+
+func (wac *Conn) Send(msg interface{}) error {
+	var err error
+	var ch <-chan string
+
+	switch m := msg.(type) {
+	case *proto.WebMessageInfo:
+		ch, err = wac.sendProto(m)
+	case TextMessage:
+		ch, err = wac.sendProto(getTextProto(m))
+	case ImageMessage:
+		m.url, m.mediaKey, m.fileEncSha256, m.fileSha256, m.fileLength, err = wac.Upload(m.Content, MediaImage)
+		if err != nil {
+			return fmt.Errorf("image upload failed: %v", err)
+		}
+		ch, err = wac.sendProto(getImageProto(m))
+	case VideoMessage:
+		m.url, m.mediaKey, m.fileEncSha256, m.fileSha256, m.fileLength, err = wac.Upload(m.Content, MediaVideo)
+		if err != nil {
+			return fmt.Errorf("video upload failed: %v", err)
+		}
+		ch, err = wac.sendProto(getVideoProto(m))
+	case DocumentMessage:
+		m.url, m.mediaKey, m.fileEncSha256, m.fileSha256, m.fileLength, err = wac.Upload(m.Content, MediaDocument)
+		if err != nil {
+			return fmt.Errorf("document upload failed: %v", err)
+		}
+		ch, err = wac.sendProto(getDocumentProto(m))
+	case AudioMessage:
+		m.url, m.mediaKey, m.fileEncSha256, m.fileSha256, m.fileLength, err = wac.Upload(m.Content, MediaAudio)
+		if err != nil {
+			return fmt.Errorf("audio upload failed: %v", err)
+		}
+		ch, err = wac.sendProto(getAudioProto(m))
+	default:
+		return fmt.Errorf("cannot match type %T, use message types declared in the package", msg)
+	}
+
+	if err != nil {
+		return fmt.Errorf("could not send proto: %v", err)
+	}
+
+	select {
+	case response := <-ch:
+		var resp map[string]interface{}
+		if err = json.Unmarshal([]byte(response), &resp); err != nil {
+			return fmt.Errorf("error decoding sending response: %v\n", err)
+		}
+		if int(resp["status"].(float64)) != 200 {
+			return fmt.Errorf("message sending responded with %d", resp["status"])
+		}
+	case <-time.After(wac.msgTimeout):
+		return fmt.Errorf("sending message timed out")
+	}
+
+	return nil
+}
+
+func (wac *Conn) sendProto(p *proto.WebMessageInfo) (<-chan string, error) {
+	n := binary.Node{
+		Description: "action",
+		Attributes: map[string]string{
+			"type":  "relay",
+			"epoch": strconv.Itoa(wac.msgCount),
+		},
+		Content: []interface{}{p},
+	}
+	return wac.writeBinary(n, message, ignore, p.Key.GetId())
+}
+
+func init() {
+	rand.Seed(time.Now().UTC().UnixNano())
+}
+
+/*
+MessageInfo contains general message information. It is part of every of every message type.
+*/
+type MessageInfo struct {
+	Id              string
+	RemoteJid       string
+	SenderJid       string
+	FromMe          bool
+	Timestamp       uint64
+	PushName        string
+	Status          MessageStatus
+	QuotedMessageID string
+
+	Source *proto.WebMessageInfo
+}
+
+type MessageStatus int
+
+const (
+	Error       MessageStatus = 0
+	Pending                   = 1
+	ServerAck                 = 2
+	DeliveryAck               = 3
+	Read                      = 4
+	Played                    = 5
+)
+
+func getMessageInfo(msg *proto.WebMessageInfo) MessageInfo {
+	return MessageInfo{
+		Id:        msg.GetKey().GetId(),
+		RemoteJid: msg.GetKey().GetRemoteJid(),
+		SenderJid: msg.GetKey().GetParticipant(),
+		FromMe:    msg.GetKey().GetFromMe(),
+		Timestamp: msg.GetMessageTimestamp(),
+		Status:    MessageStatus(msg.GetStatus()),
+		PushName:  msg.GetPushName(),
+		Source:    msg,
+	}
+}
+
+func getInfoProto(info *MessageInfo) *proto.WebMessageInfo {
+	if info.Id == "" || len(info.Id) < 2 {
+		b := make([]byte, 10)
+		rand.Read(b)
+		info.Id = strings.ToUpper(hex.EncodeToString(b))
+	}
+	if info.Timestamp == 0 {
+		info.Timestamp = uint64(time.Now().Unix())
+	}
+	info.FromMe = true
+
+	status := proto.WebMessageInfo_STATUS(info.Status)
+
+	return &proto.WebMessageInfo{
+		Key: &proto.MessageKey{
+			FromMe:    &info.FromMe,
+			RemoteJid: &info.RemoteJid,
+			Id:        &info.Id,
+		},
+		MessageTimestamp: &info.Timestamp,
+		Status:           &status,
+	}
+}
+
+/*
+TextMessage represents a text message.
+*/
+type TextMessage struct {
+	Info MessageInfo
+	Text string
+}
+
+func getTextMessage(msg *proto.WebMessageInfo) TextMessage {
+	text := TextMessage{Info: getMessageInfo(msg)}
+	if m := msg.GetMessage().GetExtendedTextMessage(); m != nil {
+		text.Text = m.GetText()
+		text.Info.QuotedMessageID = m.GetContextInfo().GetStanzaId()
+	} else {
+		text.Text = msg.GetMessage().GetConversation()
+	}
+	return text
+}
+
+func getTextProto(msg TextMessage) *proto.WebMessageInfo {
+	p := getInfoProto(&msg.Info)
+	p.Message = &proto.Message{
+		Conversation: &msg.Text,
+	}
+	return p
+}
+
+/*
+ImageMessage represents a image message. Unexported fields are needed for media up/downloading and media validation.
+Provide a io.Reader as Content for message sending.
+*/
+type ImageMessage struct {
+	Info          MessageInfo
+	Caption       string
+	Thumbnail     []byte
+	Type          string
+	Content       io.Reader
+	url           string
+	mediaKey      []byte
+	fileEncSha256 []byte
+	fileSha256    []byte
+	fileLength    uint64
+}
+
+func getImageMessage(msg *proto.WebMessageInfo) ImageMessage {
+	image := msg.GetMessage().GetImageMessage()
+	return ImageMessage{
+		Info:          getMessageInfo(msg),
+		Caption:       image.GetCaption(),
+		Thumbnail:     image.GetJpegThumbnail(),
+		url:           image.GetUrl(),
+		mediaKey:      image.GetMediaKey(),
+		Type:          image.GetMimetype(),
+		fileEncSha256: image.GetFileEncSha256(),
+		fileSha256:    image.GetFileSha256(),
+		fileLength:    image.GetFileLength(),
+	}
+}
+
+func getImageProto(msg ImageMessage) *proto.WebMessageInfo {
+	p := getInfoProto(&msg.Info)
+	p.Message = &proto.Message{
+		ImageMessage: &proto.ImageMessage{
+			Caption:       &msg.Caption,
+			JpegThumbnail: msg.Thumbnail,
+			Url:           &msg.url,
+			MediaKey:      msg.mediaKey,
+			Mimetype:      &msg.Type,
+			FileEncSha256: msg.fileEncSha256,
+			FileSha256:    msg.fileSha256,
+			FileLength:    &msg.fileLength,
+		},
+	}
+	return p
+}
+
+/*
+Download is the function to retrieve media data. The media gets downloaded, validated and returned.
+*/
+func (m *ImageMessage) Download() ([]byte, error) {
+	return Download(m.url, m.mediaKey, MediaImage, int(m.fileLength))
+}
+
+/*
+VideoMessage represents a video message. Unexported fields are needed for media up/downloading and media validation.
+Provide a io.Reader as Content for message sending.
+*/
+type VideoMessage struct {
+	Info          MessageInfo
+	Caption       string
+	Thumbnail     []byte
+	Length        uint32
+	Type          string
+	Content       io.Reader
+	url           string
+	mediaKey      []byte
+	fileEncSha256 []byte
+	fileSha256    []byte
+	fileLength    uint64
+}
+
+func getVideoMessage(msg *proto.WebMessageInfo) VideoMessage {
+	vid := msg.GetMessage().GetVideoMessage()
+	return VideoMessage{
+		Info:          getMessageInfo(msg),
+		Caption:       vid.GetCaption(),
+		Thumbnail:     vid.GetJpegThumbnail(),
+		url:           vid.GetUrl(),
+		mediaKey:      vid.GetMediaKey(),
+		Length:        vid.GetSeconds(),
+		Type:          vid.GetMimetype(),
+		fileEncSha256: vid.GetFileEncSha256(),
+		fileSha256:    vid.GetFileSha256(),
+		fileLength:    vid.GetFileLength(),
+	}
+}
+
+func getVideoProto(msg VideoMessage) *proto.WebMessageInfo {
+	p := getInfoProto(&msg.Info)
+	p.Message = &proto.Message{
+		VideoMessage: &proto.VideoMessage{
+			Caption:       &msg.Caption,
+			JpegThumbnail: msg.Thumbnail,
+			Url:           &msg.url,
+			MediaKey:      msg.mediaKey,
+			Seconds:       &msg.Length,
+			FileEncSha256: msg.fileEncSha256,
+			FileSha256:    msg.fileSha256,
+			FileLength:    &msg.fileLength,
+			Mimetype:      &msg.Type,
+		},
+	}
+	return p
+}
+
+/*
+Download is the function to retrieve media data. The media gets downloaded, validated and returned.
+*/
+func (m *VideoMessage) Download() ([]byte, error) {
+	return Download(m.url, m.mediaKey, MediaVideo, int(m.fileLength))
+}
+
+/*
+AudioMessage represents a audio message. Unexported fields are needed for media up/downloading and media validation.
+Provide a io.Reader as Content for message sending.
+*/
+type AudioMessage struct {
+	Info          MessageInfo
+	Length        uint32
+	Type          string
+	Content       io.Reader
+	url           string
+	mediaKey      []byte
+	fileEncSha256 []byte
+	fileSha256    []byte
+	fileLength    uint64
+}
+
+func getAudioMessage(msg *proto.WebMessageInfo) AudioMessage {
+	aud := msg.GetMessage().GetAudioMessage()
+	return AudioMessage{
+		Info:          getMessageInfo(msg),
+		url:           aud.GetUrl(),
+		mediaKey:      aud.GetMediaKey(),
+		Length:        aud.GetSeconds(),
+		Type:          aud.GetMimetype(),
+		fileEncSha256: aud.GetFileEncSha256(),
+		fileSha256:    aud.GetFileSha256(),
+		fileLength:    aud.GetFileLength(),
+	}
+}
+
+func getAudioProto(msg AudioMessage) *proto.WebMessageInfo {
+	p := getInfoProto(&msg.Info)
+	p.Message = &proto.Message{
+		AudioMessage: &proto.AudioMessage{
+			Url:           &msg.url,
+			MediaKey:      msg.mediaKey,
+			Seconds:       &msg.Length,
+			FileEncSha256: msg.fileEncSha256,
+			FileSha256:    msg.fileSha256,
+			FileLength:    &msg.fileLength,
+			Mimetype:      &msg.Type,
+		},
+	}
+	return p
+}
+
+/*
+Download is the function to retrieve media data. The media gets downloaded, validated and returned.
+*/
+func (m *AudioMessage) Download() ([]byte, error) {
+	return Download(m.url, m.mediaKey, MediaAudio, int(m.fileLength))
+}
+
+/*
+DocumentMessage represents a document message. Unexported fields are needed for media up/downloading and media
+validation. Provide a io.Reader as Content for message sending.
+*/
+type DocumentMessage struct {
+	Info          MessageInfo
+	Title         string
+	PageCount     uint32
+	Type          string
+	Thumbnail     []byte
+	Content       io.Reader
+	url           string
+	mediaKey      []byte
+	fileEncSha256 []byte
+	fileSha256    []byte
+	fileLength    uint64
+}
+
+func getDocumentMessage(msg *proto.WebMessageInfo) DocumentMessage {
+	doc := msg.GetMessage().GetDocumentMessage()
+	return DocumentMessage{
+		Info:          getMessageInfo(msg),
+		Thumbnail:     doc.GetJpegThumbnail(),
+		url:           doc.GetUrl(),
+		mediaKey:      doc.GetMediaKey(),
+		fileEncSha256: doc.GetFileEncSha256(),
+		fileSha256:    doc.GetFileSha256(),
+		fileLength:    doc.GetFileLength(),
+		PageCount:     doc.GetPageCount(),
+		Title:         doc.GetTitle(),
+		Type:          doc.GetMimetype(),
+	}
+}
+
+func getDocumentProto(msg DocumentMessage) *proto.WebMessageInfo {
+	p := getInfoProto(&msg.Info)
+	p.Message = &proto.Message{
+		DocumentMessage: &proto.DocumentMessage{
+			JpegThumbnail: msg.Thumbnail,
+			Url:           &msg.url,
+			MediaKey:      msg.mediaKey,
+			FileEncSha256: msg.fileEncSha256,
+			FileSha256:    msg.fileSha256,
+			FileLength:    &msg.fileLength,
+			PageCount:     &msg.PageCount,
+			Title:         &msg.Title,
+			Mimetype:      &msg.Type,
+		},
+	}
+	return p
+}
+
+/*
+Download is the function to retrieve media data. The media gets downloaded, validated and returned.
+*/
+func (m *DocumentMessage) Download() ([]byte, error) {
+	return Download(m.url, m.mediaKey, MediaDocument, int(m.fileLength))
+}
+
+func parseProtoMessage(msg *proto.WebMessageInfo) interface{} {
+	switch {
+
+	case msg.GetMessage().GetAudioMessage() != nil:
+		return getAudioMessage(msg)
+
+	case msg.GetMessage().GetImageMessage() != nil:
+		return getImageMessage(msg)
+
+	case msg.GetMessage().GetVideoMessage() != nil:
+		return getVideoMessage(msg)
+
+	case msg.GetMessage().GetDocumentMessage() != nil:
+		return getDocumentMessage(msg)
+
+	case msg.GetMessage().GetConversation() != "":
+		return getTextMessage(msg)
+
+	case msg.GetMessage().GetExtendedTextMessage() != nil:
+		return getTextMessage(msg)
+
+	default:
+		//cannot match message
+	}
+
+	return nil
+}

vendor/github.com/Rhymen/go-whatsapp/session.go

@@ -0,0 +1,389 @@
+package whatsapp
+
+import (
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/Rhymen/go-whatsapp/crypto/cbc"
+	"github.com/Rhymen/go-whatsapp/crypto/curve25519"
+	"github.com/Rhymen/go-whatsapp/crypto/hkdf"
+)
+
+/*
+Session contains session individual information. To be able to resume the connection without scanning the qr code
+every time you should save the Session returned by Login and use RestoreSession the next time you want to login.
+Every successful created connection returns a new Session. The Session(ClientToken, ServerToken) is altered after
+every re-login and should be saved every time.
+*/
+type Session struct {
+	ClientId    string
+	ClientToken string
+	ServerToken string
+	EncKey      []byte
+	MacKey      []byte
+	Wid         string
+}
+
+type Info struct {
+	Battery   int
+	Platform  string
+	Connected bool
+	Pushname  string
+	Wid       string
+	Lc        string
+	Phone     *PhoneInfo
+	Plugged   bool
+	Tos       int
+	Lg        string
+	Is24h     bool
+}
+
+type PhoneInfo struct {
+	Mcc                string
+	Mnc                string
+	OsVersion          string
+	DeviceManufacturer string
+	DeviceModel        string
+	OsBuildNumber      string
+	WaVersion          string
+}
+
+func newInfoFromReq(info map[string]interface{}) *Info {
+	phoneInfo := info["phone"].(map[string]interface{})
+
+	ret := &Info{
+		Battery:   int(info["battery"].(float64)),
+		Platform:  info["platform"].(string),
+		Connected: info["connected"].(bool),
+		Pushname:  info["pushname"].(string),
+		Wid:       info["wid"].(string),
+		Lc:        info["lc"].(string),
+		Phone: &PhoneInfo{
+			phoneInfo["mcc"].(string),
+			phoneInfo["mnc"].(string),
+			phoneInfo["os_version"].(string),
+			phoneInfo["device_manufacturer"].(string),
+			phoneInfo["device_model"].(string),
+			phoneInfo["os_build_number"].(string),
+			phoneInfo["wa_version"].(string),
+		},
+		Plugged: info["plugged"].(bool),
+		Lg:      info["lg"].(string),
+		Tos:     int(info["tos"].(float64)),
+	}
+
+	if is24h, ok := info["is24h"]; ok {
+		ret.Is24h = is24h.(bool)
+	}
+
+	return ret
+}
+
+/*
+SetClientName sets the long and short client names that are sent to WhatsApp when logging in and displayed in the
+WhatsApp Web device list. As the values are only sent when logging in, changing them after logging in is not possible.
+*/
+func (wac *Conn) SetClientName(long, short string) error {
+	if wac.session != nil && (wac.session.EncKey != nil || wac.session.MacKey != nil) {
+		return fmt.Errorf("cannot change client name after logging in")
+	}
+	wac.longClientName, wac.shortClientName = long, short
+	return nil
+}
+
+/*
+Login is the function that creates a new whatsapp session and logs you in. If you do not want to scan the qr code
+every time, you should save the returned session and use RestoreSession the next time. Login takes a writable channel
+as an parameter. This channel is used to push the data represented by the qr code back to the user. The received data
+should be displayed as an qr code in a way you prefer. To print a qr code to console you can use:
+github.com/Baozisoftware/qrcode-terminal-go Example login procedure:
+	wac, err := whatsapp.NewConn(5 * time.Second)
+	if err != nil {
+		panic(err)
+	}
+
+	qr := make(chan string)
+	go func() {
+		terminal := qrcodeTerminal.New()
+		terminal.Get(<-qr).Print()
+	}()
+
+	session, err := wac.Login(qr)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error during login: %v\n", err)
+	}
+	fmt.Printf("login successful, session: %v\n", session)
+*/
+func (wac *Conn) Login(qrChan chan<- string) (Session, error) {
+	session := Session{}
+
+	if wac.session != nil && (wac.session.EncKey != nil || wac.session.MacKey != nil) {
+		return session, fmt.Errorf("already logged in")
+	}
+
+	clientId := make([]byte, 16)
+	_, err := rand.Read(clientId)
+	if err != nil {
+		return session, fmt.Errorf("error creating random ClientId: %v", err)
+	}
+
+	session.ClientId = base64.StdEncoding.EncodeToString(clientId)
+	//oldVersion=8691
+	login := []interface{}{"admin", "init", []int{0, 3, 225}, []string{wac.longClientName, wac.shortClientName}, session.ClientId, true}
+	loginChan, err := wac.write(login)
+	if err != nil {
+		return session, fmt.Errorf("error writing login: %v\n", err)
+	}
+
+	var r string
+	select {
+	case r = <-loginChan:
+	case <-time.After(wac.msgTimeout):
+		return session, fmt.Errorf("login connection timed out")
+	}
+
+	var resp map[string]interface{}
+	if err = json.Unmarshal([]byte(r), &resp); err != nil {
+		return session, fmt.Errorf("error decoding login resp: %v\n", err)
+	}
+
+	ref := resp["ref"].(string)
+
+	priv, pub, err := curve25519.GenerateKey()
+	if err != nil {
+		return session, fmt.Errorf("error generating keys: %v\n", err)
+	}
+
+	//listener for Login response
+	messageTag := "s1"
+	wac.listener[messageTag] = make(chan string, 1)
+
+	qrChan <- fmt.Sprintf("%v,%v,%v", ref, base64.StdEncoding.EncodeToString(pub[:]), session.ClientId)
+
+	var resp2 []interface{}
+	select {
+	case r1 := <-wac.listener[messageTag]:
+		if err := json.Unmarshal([]byte(r1), &resp2); err != nil {
+			return session, fmt.Errorf("error decoding qr code resp: %v", err)
+		}
+	case <-time.After(time.Duration(resp["ttl"].(float64)) * time.Millisecond):
+		return session, fmt.Errorf("qr code scan timed out")
+	}
+
+	info := resp2[1].(map[string]interface{})
+
+	wac.Info = newInfoFromReq(info)
+
+	session.ClientToken = info["clientToken"].(string)
+	session.ServerToken = info["serverToken"].(string)
+	session.Wid = info["wid"].(string)
+	s := info["secret"].(string)
+	decodedSecret, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return session, fmt.Errorf("error decoding secret: %v", err)
+	}
+
+	var pubKey [32]byte
+	copy(pubKey[:], decodedSecret[:32])
+
+	sharedSecret := curve25519.GenerateSharedSecret(*priv, pubKey)
+
+	hash := sha256.New
+
+	nullKey := make([]byte, 32)
+	h := hmac.New(hash, nullKey)
+	h.Write(sharedSecret)
+
+	sharedSecretExtended, err := hkdf.Expand(h.Sum(nil), 80, "")
+	if err != nil {
+		return session, fmt.Errorf("hkdf error: %v", err)
+	}
+
+	//login validation
+	checkSecret := make([]byte, 112)
+	copy(checkSecret[:32], decodedSecret[:32])
+	copy(checkSecret[32:], decodedSecret[64:])
+	h2 := hmac.New(hash, sharedSecretExtended[32:64])
+	h2.Write(checkSecret)
+	if !hmac.Equal(h2.Sum(nil), decodedSecret[32:64]) {
+		return session, fmt.Errorf("abort login")
+	}
+
+	keysEncrypted := make([]byte, 96)
+	copy(keysEncrypted[:16], sharedSecretExtended[64:])
+	copy(keysEncrypted[16:], decodedSecret[64:])
+
+	keyDecrypted, err := cbc.Decrypt(sharedSecretExtended[:32], nil, keysEncrypted)
+	if err != nil {
+		return session, fmt.Errorf("error decryptAes: %v", err)
+	}
+
+	session.EncKey = keyDecrypted[:32]
+	session.MacKey = keyDecrypted[32:64]
+	wac.session = &session
+
+	return session, nil
+}
+
+/*
+RestoreSession is the function that restores a given session. It will try to reestablish the connection to the
+WhatsAppWeb servers with the provided session. If it succeeds it will return a new session. This new session has to be
+saved because the Client and Server-Token will change after every login. Logging in with old tokens is possible, but not
+suggested. If so, a challenge has to be resolved which is just another possible point of failure.
+*/
+func (wac *Conn) RestoreSession(session Session) (Session, error) {
+	if wac.session != nil && (wac.session.EncKey != nil || wac.session.MacKey != nil) {
+		return Session{}, fmt.Errorf("already logged in")
+	}
+
+	wac.session = &session
+
+	//listener for Conn or challenge; s1 is not allowed to drop
+	wac.listener["s1"] = make(chan string, 1)
+
+	//admin init
+	init := []interface{}{"admin", "init", []int{0, 3, 225}, []string{wac.longClientName, wac.shortClientName}, session.ClientId, true}
+	initChan, err := wac.write(init)
+	if err != nil {
+		wac.session = nil
+		return Session{}, fmt.Errorf("error writing admin init: %v\n", err)
+	}
+
+	//admin login with takeover
+	login := []interface{}{"admin", "login", session.ClientToken, session.ServerToken, session.ClientId, "takeover"}
+	loginChan, err := wac.write(login)
+	if err != nil {
+		wac.session = nil
+		return Session{}, fmt.Errorf("error writing admin login: %v\n", err)
+	}
+
+	select {
+	case r := <-initChan:
+		var resp map[string]interface{}
+		if err = json.Unmarshal([]byte(r), &resp); err != nil {
+			wac.session = nil
+			return Session{}, fmt.Errorf("error decoding login connResp: %v\n", err)
+		}
+
+		if int(resp["status"].(float64)) != 200 {
+			wac.session = nil
+			return Session{}, fmt.Errorf("init responded with %d", resp["status"])
+		}
+	case <-time.After(wac.msgTimeout):
+		wac.session = nil
+		return Session{}, fmt.Errorf("restore session init timed out")
+	}
+
+	//wait for s1
+	var connResp []interface{}
+	select {
+	case r1 := <-wac.listener["s1"]:
+		if err := json.Unmarshal([]byte(r1), &connResp); err != nil {
+			wac.session = nil
+			return Session{}, fmt.Errorf("error decoding s1 message: %v\n", err)
+		}
+	case <-time.After(wac.msgTimeout):
+		wac.session = nil
+		return Session{}, fmt.Errorf("restore session connection timed out")
+	}
+
+	//check if challenge is present
+	if len(connResp) == 2 && connResp[0] == "Cmd" && connResp[1].(map[string]interface{})["type"] == "challenge" {
+		wac.listener["s2"] = make(chan string, 1)
+
+		if err := wac.resolveChallenge(connResp[1].(map[string]interface{})["challenge"].(string)); err != nil {
+			wac.session = nil
+			return Session{}, fmt.Errorf("error resolving challenge: %v\n", err)
+		}
+
+		select {
+		case r := <-wac.listener["s2"]:
+			if err := json.Unmarshal([]byte(r), &connResp); err != nil {
+				wac.session = nil
+				return Session{}, fmt.Errorf("error decoding s2 message: %v\n", err)
+			}
+		case <-time.After(wac.msgTimeout):
+			wac.session = nil
+			return Session{}, fmt.Errorf("restore session challenge timed out")
+		}
+	}
+
+	//check for login 200 --> login success
+	select {
+	case r := <-loginChan:
+		var resp map[string]interface{}
+		if err = json.Unmarshal([]byte(r), &resp); err != nil {
+			wac.session = nil
+			return Session{}, fmt.Errorf("error decoding login connResp: %v\n", err)
+		}
+
+		if int(resp["status"].(float64)) != 200 {
+			wac.session = nil
+			return Session{}, fmt.Errorf("admin login responded with %d", resp["status"])
+		}
+	case <-time.After(wac.msgTimeout):
+		wac.session = nil
+		return Session{}, fmt.Errorf("restore session login timed out")
+	}
+
+	info := connResp[1].(map[string]interface{})
+
+	wac.Info = newInfoFromReq(info)
+
+	//set new tokens
+	session.ClientToken = info["clientToken"].(string)
+	session.ServerToken = info["serverToken"].(string)
+	session.Wid = info["wid"].(string)
+
+	return *wac.session, nil
+}
+
+func (wac *Conn) resolveChallenge(challenge string) error {
+	decoded, err := base64.StdEncoding.DecodeString(challenge)
+	if err != nil {
+		return err
+	}
+
+	h2 := hmac.New(sha256.New, wac.session.MacKey)
+	h2.Write([]byte(decoded))
+
+	ch := []interface{}{"admin", "challenge", base64.StdEncoding.EncodeToString(h2.Sum(nil)), wac.session.ServerToken, wac.session.ClientId}
+	challengeChan, err := wac.write(ch)
+	if err != nil {
+		return fmt.Errorf("error writing challenge: %v\n", err)
+	}
+
+	select {
+	case r := <-challengeChan:
+		var resp map[string]interface{}
+		if err := json.Unmarshal([]byte(r), &resp); err != nil {
+			return fmt.Errorf("error decoding login resp: %v\n", err)
+		}
+		if int(resp["status"].(float64)) != 200 {
+			return fmt.Errorf("challenge responded with %d\n", resp["status"])
+		}
+	case <-time.After(wac.msgTimeout):
+		return fmt.Errorf("connection timed out")
+	}
+
+	return nil
+}
+
+/*
+Logout is the function to logout from a WhatsApp session. Logging out means invalidating the current session.
+The session can not be resumed and will disappear on your phone in the WhatsAppWeb client list.
+*/
+func (wac *Conn) Logout() error {
+	login := []interface{}{"admin", "Conn", "disconnect"}
+	_, err := wac.write(login)
+	if err != nil {
+		return fmt.Errorf("error writing logout: %v\n", err)
+	}
+
+	return nil
+}

vendor/github.com/Rhymen/go-whatsapp/store.go

@@ -0,0 +1,45 @@
+package whatsapp
+
+import (
+	"github.com/Rhymen/go-whatsapp/binary"
+	"strings"
+)
+
+type Store struct {
+	Contacts map[string]Contact
+}
+
+type Contact struct {
+	Jid    string
+	Notify string
+	Name   string
+	Short  string
+}
+
+func newStore() *Store {
+	return &Store{
+		make(map[string]Contact),
+	}
+}
+
+func (wac *Conn) updateContacts(contacts interface{}) {
+	c, ok := contacts.([]interface{})
+	if !ok {
+		return
+	}
+
+	for _, contact := range c {
+		contactNode, ok := contact.(binary.Node)
+		if !ok {
+			continue
+		}
+
+		jid := strings.Replace(contactNode.Attributes["jid"], "@c.us", "@s.whatsapp.net", 1)
+		wac.Store.Contacts[jid] = Contact{
+			jid,
+			contactNode.Attributes["notify"],
+			contactNode.Attributes["name"],
+			contactNode.Attributes["short"],
+		}
+	}
+}

vendor/github.com/d5/tengo/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Daniel Kang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/d5/tengo/compiler/ast/array_lit.go

@@ -0,0 +1,35 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+)
+
+// ArrayLit represents an array literal.
+type ArrayLit struct {
+	Elements []Expr
+	LBrack   source.Pos
+	RBrack   source.Pos
+}
+
+func (e *ArrayLit) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *ArrayLit) Pos() source.Pos {
+	return e.LBrack
+}
+
+// End returns the position of first character immediately after the node.
+func (e *ArrayLit) End() source.Pos {
+	return e.RBrack + 1
+}
+
+func (e *ArrayLit) String() string {
+	var elements []string
+	for _, m := range e.Elements {
+		elements = append(elements, m.String())
+	}
+
+	return "[" + strings.Join(elements, ", ") + "]"
+}

vendor/github.com/d5/tengo/compiler/ast/assign_stmt.go

@@ -0,0 +1,40 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+	"github.com/d5/tengo/compiler/token"
+)
+
+// AssignStmt represents an assignment statement.
+type AssignStmt struct {
+	LHS      []Expr
+	RHS      []Expr
+	Token    token.Token
+	TokenPos source.Pos
+}
+
+func (s *AssignStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *AssignStmt) Pos() source.Pos {
+	return s.LHS[0].Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (s *AssignStmt) End() source.Pos {
+	return s.RHS[len(s.RHS)-1].End()
+}
+
+func (s *AssignStmt) String() string {
+	var lhs, rhs []string
+	for _, e := range s.LHS {
+		lhs = append(lhs, e.String())
+	}
+	for _, e := range s.RHS {
+		rhs = append(rhs, e.String())
+	}
+
+	return strings.Join(lhs, ", ") + " " + s.Token.String() + " " + strings.Join(rhs, ", ")
+}

vendor/github.com/d5/tengo/compiler/ast/ast.go

@@ -0,0 +1,5 @@
+package ast
+
+const (
+	nullRep = "<null>"
+)

vendor/github.com/d5/tengo/compiler/ast/bad_expr.go

@@ -0,0 +1,25 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// BadExpr represents a bad expression.
+type BadExpr struct {
+	From source.Pos
+	To   source.Pos
+}
+
+func (e *BadExpr) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *BadExpr) Pos() source.Pos {
+	return e.From
+}
+
+// End returns the position of first character immediately after the node.
+func (e *BadExpr) End() source.Pos {
+	return e.To
+}
+
+func (e *BadExpr) String() string {
+	return "<bad expression>"
+}

vendor/github.com/d5/tengo/compiler/ast/bad_stmt.go

@@ -0,0 +1,25 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// BadStmt represents a bad statement.
+type BadStmt struct {
+	From source.Pos
+	To   source.Pos
+}
+
+func (s *BadStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *BadStmt) Pos() source.Pos {
+	return s.From
+}
+
+// End returns the position of first character immediately after the node.
+func (s *BadStmt) End() source.Pos {
+	return s.To
+}
+
+func (s *BadStmt) String() string {
+	return "<bad statement>"
+}

vendor/github.com/d5/tengo/compiler/ast/binary_expr.go

@@ -0,0 +1,30 @@
+package ast
+
+import (
+	"github.com/d5/tengo/compiler/source"
+	"github.com/d5/tengo/compiler/token"
+)
+
+// BinaryExpr represents a binary operator expression.
+type BinaryExpr struct {
+	LHS      Expr
+	RHS      Expr
+	Token    token.Token
+	TokenPos source.Pos
+}
+
+func (e *BinaryExpr) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *BinaryExpr) Pos() source.Pos {
+	return e.LHS.Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (e *BinaryExpr) End() source.Pos {
+	return e.RHS.End()
+}
+
+func (e *BinaryExpr) String() string {
+	return "(" + e.LHS.String() + " " + e.Token.String() + " " + e.RHS.String() + ")"
+}

vendor/github.com/d5/tengo/compiler/ast/block_stmt.go

@@ -0,0 +1,35 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+)
+
+// BlockStmt represents a block statement.
+type BlockStmt struct {
+	Stmts  []Stmt
+	LBrace source.Pos
+	RBrace source.Pos
+}
+
+func (s *BlockStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *BlockStmt) Pos() source.Pos {
+	return s.LBrace
+}
+
+// End returns the position of first character immediately after the node.
+func (s *BlockStmt) End() source.Pos {
+	return s.RBrace + 1
+}
+
+func (s *BlockStmt) String() string {
+	var list []string
+	for _, e := range s.Stmts {
+		list = append(list, e.String())
+	}
+
+	return "{" + strings.Join(list, "; ") + "}"
+}

vendor/github.com/d5/tengo/compiler/ast/bool_lit.go

@@ -0,0 +1,26 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// BoolLit represents a boolean literal.
+type BoolLit struct {
+	Value    bool
+	ValuePos source.Pos
+	Literal  string
+}
+
+func (e *BoolLit) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *BoolLit) Pos() source.Pos {
+	return e.ValuePos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *BoolLit) End() source.Pos {
+	return source.Pos(int(e.ValuePos) + len(e.Literal))
+}
+
+func (e *BoolLit) String() string {
+	return e.Literal
+}

vendor/github.com/d5/tengo/compiler/ast/branch_stmt.go

@@ -0,0 +1,38 @@
+package ast
+
+import (
+	"github.com/d5/tengo/compiler/source"
+	"github.com/d5/tengo/compiler/token"
+)
+
+// BranchStmt represents a branch statement.
+type BranchStmt struct {
+	Token    token.Token
+	TokenPos source.Pos
+	Label    *Ident
+}
+
+func (s *BranchStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *BranchStmt) Pos() source.Pos {
+	return s.TokenPos
+}
+
+// End returns the position of first character immediately after the node.
+func (s *BranchStmt) End() source.Pos {
+	if s.Label != nil {
+		return s.Label.End()
+	}
+
+	return source.Pos(int(s.TokenPos) + len(s.Token.String()))
+}
+
+func (s *BranchStmt) String() string {
+	var label string
+	if s.Label != nil {
+		label = " " + s.Label.Name
+	}
+
+	return s.Token.String() + label
+}

vendor/github.com/d5/tengo/compiler/ast/call_expr.go

@@ -0,0 +1,36 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+)
+
+// CallExpr represents a function call expression.
+type CallExpr struct {
+	Func   Expr
+	LParen source.Pos
+	Args   []Expr
+	RParen source.Pos
+}
+
+func (e *CallExpr) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *CallExpr) Pos() source.Pos {
+	return e.Func.Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (e *CallExpr) End() source.Pos {
+	return e.RParen + 1
+}
+
+func (e *CallExpr) String() string {
+	var args []string
+	for _, e := range e.Args {
+		args = append(args, e.String())
+	}
+
+	return e.Func.String() + "(" + strings.Join(args, ", ") + ")"
+}

vendor/github.com/d5/tengo/compiler/ast/char_lit.go

@@ -0,0 +1,26 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// CharLit represents a character literal.
+type CharLit struct {
+	Value    rune
+	ValuePos source.Pos
+	Literal  string
+}
+
+func (e *CharLit) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *CharLit) Pos() source.Pos {
+	return e.ValuePos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *CharLit) End() source.Pos {
+	return source.Pos(int(e.ValuePos) + len(e.Literal))
+}
+
+func (e *CharLit) String() string {
+	return e.Literal
+}

vendor/github.com/d5/tengo/compiler/ast/cond_expr.go

@@ -0,0 +1,30 @@
+package ast
+
+import (
+	"github.com/d5/tengo/compiler/source"
+)
+
+// CondExpr represents a ternary conditional expression.
+type CondExpr struct {
+	Cond        Expr
+	True        Expr
+	False       Expr
+	QuestionPos source.Pos
+	ColonPos    source.Pos
+}
+
+func (e *CondExpr) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *CondExpr) Pos() source.Pos {
+	return e.Cond.Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (e *CondExpr) End() source.Pos {
+	return e.False.End()
+}
+
+func (e *CondExpr) String() string {
+	return "(" + e.Cond.String() + " ? " + e.True.String() + " : " + e.False.String() + ")"
+}

vendor/github.com/d5/tengo/compiler/ast/empty_stmt.go

@@ -0,0 +1,29 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// EmptyStmt represents an empty statement.
+type EmptyStmt struct {
+	Semicolon source.Pos
+	Implicit  bool
+}
+
+func (s *EmptyStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *EmptyStmt) Pos() source.Pos {
+	return s.Semicolon
+}
+
+// End returns the position of first character immediately after the node.
+func (s *EmptyStmt) End() source.Pos {
+	if s.Implicit {
+		return s.Semicolon
+	}
+
+	return s.Semicolon + 1
+}
+
+func (s *EmptyStmt) String() string {
+	return ";"
+}

vendor/github.com/d5/tengo/compiler/ast/error_expr.go

@@ -0,0 +1,29 @@
+package ast
+
+import (
+	"github.com/d5/tengo/compiler/source"
+)
+
+// ErrorExpr represents an error expression
+type ErrorExpr struct {
+	Expr     Expr
+	ErrorPos source.Pos
+	LParen   source.Pos
+	RParen   source.Pos
+}
+
+func (e *ErrorExpr) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *ErrorExpr) Pos() source.Pos {
+	return e.ErrorPos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *ErrorExpr) End() source.Pos {
+	return e.RParen
+}
+
+func (e *ErrorExpr) String() string {
+	return "error(" + e.Expr.String() + ")"
+}

vendor/github.com/d5/tengo/compiler/ast/export_stmt.go

@@ -0,0 +1,27 @@
+package ast
+
+import (
+	"github.com/d5/tengo/compiler/source"
+)
+
+// ExportStmt represents an export statement.
+type ExportStmt struct {
+	ExportPos source.Pos
+	Result    Expr
+}
+
+func (s *ExportStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *ExportStmt) Pos() source.Pos {
+	return s.ExportPos
+}
+
+// End returns the position of first character immediately after the node.
+func (s *ExportStmt) End() source.Pos {
+	return s.Result.End()
+}
+
+func (s *ExportStmt) String() string {
+	return "export " + s.Result.String()
+}

vendor/github.com/d5/tengo/compiler/ast/expr.go

@@ -0,0 +1,7 @@
+package ast
+
+// Expr represents an expression node in the AST.
+type Expr interface {
+	Node
+	exprNode()
+}

vendor/github.com/d5/tengo/compiler/ast/expr_stmt.go

@@ -0,0 +1,24 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// ExprStmt represents an expression statement.
+type ExprStmt struct {
+	Expr Expr
+}
+
+func (s *ExprStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *ExprStmt) Pos() source.Pos {
+	return s.Expr.Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (s *ExprStmt) End() source.Pos {
+	return s.Expr.End()
+}
+
+func (s *ExprStmt) String() string {
+	return s.Expr.String()
+}

vendor/github.com/d5/tengo/compiler/ast/file.go

@@ -0,0 +1,32 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+)
+
+// File represents a file unit.
+type File struct {
+	InputFile *source.File
+	Stmts     []Stmt
+}
+
+// Pos returns the position of first character belonging to the node.
+func (n *File) Pos() source.Pos {
+	return source.Pos(n.InputFile.Base)
+}
+
+// End returns the position of first character immediately after the node.
+func (n *File) End() source.Pos {
+	return source.Pos(n.InputFile.Base + n.InputFile.Size)
+}
+
+func (n *File) String() string {
+	var stmts []string
+	for _, e := range n.Stmts {
+		stmts = append(stmts, e.String())
+	}
+
+	return strings.Join(stmts, "; ")
+}

vendor/github.com/d5/tengo/compiler/ast/float_lit.go

@@ -0,0 +1,26 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// FloatLit represents a floating point literal.
+type FloatLit struct {
+	Value    float64
+	ValuePos source.Pos
+	Literal  string
+}
+
+func (e *FloatLit) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *FloatLit) Pos() source.Pos {
+	return e.ValuePos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *FloatLit) End() source.Pos {
+	return source.Pos(int(e.ValuePos) + len(e.Literal))
+}
+
+func (e *FloatLit) String() string {
+	return e.Literal
+}

vendor/github.com/d5/tengo/compiler/ast/for_in_stmt.go

@@ -0,0 +1,32 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// ForInStmt represents a for-in statement.
+type ForInStmt struct {
+	ForPos   source.Pos
+	Key      *Ident
+	Value    *Ident
+	Iterable Expr
+	Body     *BlockStmt
+}
+
+func (s *ForInStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *ForInStmt) Pos() source.Pos {
+	return s.ForPos
+}
+
+// End returns the position of first character immediately after the node.
+func (s *ForInStmt) End() source.Pos {
+	return s.Body.End()
+}
+
+func (s *ForInStmt) String() string {
+	if s.Value != nil {
+		return "for " + s.Key.String() + ", " + s.Value.String() + " in " + s.Iterable.String() + " " + s.Body.String()
+	}
+
+	return "for " + s.Key.String() + " in " + s.Iterable.String() + " " + s.Body.String()
+}

vendor/github.com/d5/tengo/compiler/ast/for_stmt.go

@@ -0,0 +1,43 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// ForStmt represents a for statement.
+type ForStmt struct {
+	ForPos source.Pos
+	Init   Stmt
+	Cond   Expr
+	Post   Stmt
+	Body   *BlockStmt
+}
+
+func (s *ForStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *ForStmt) Pos() source.Pos {
+	return s.ForPos
+}
+
+// End returns the position of first character immediately after the node.
+func (s *ForStmt) End() source.Pos {
+	return s.Body.End()
+}
+
+func (s *ForStmt) String() string {
+	var init, cond, post string
+	if s.Init != nil {
+		init = s.Init.String()
+	}
+	if s.Cond != nil {
+		cond = s.Cond.String() + " "
+	}
+	if s.Post != nil {
+		post = s.Post.String()
+	}
+
+	if init != "" || post != "" {
+		return "for " + init + " ; " + cond + " ; " + post + s.Body.String()
+	}
+
+	return "for " + cond + s.Body.String()
+}

vendor/github.com/d5/tengo/compiler/ast/func_lit.go

@@ -0,0 +1,25 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// FuncLit represents a function literal.
+type FuncLit struct {
+	Type *FuncType
+	Body *BlockStmt
+}
+
+func (e *FuncLit) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *FuncLit) Pos() source.Pos {
+	return e.Type.Pos()
+}
+
+// End returns the position of first character immediately after the node.
+func (e *FuncLit) End() source.Pos {
+	return e.Body.End()
+}
+
+func (e *FuncLit) String() string {
+	return "func" + e.Type.Params.String() + " " + e.Body.String()
+}

vendor/github.com/d5/tengo/compiler/ast/func_type.go

@@ -0,0 +1,25 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// FuncType represents a function type definition.
+type FuncType struct {
+	FuncPos source.Pos
+	Params  *IdentList
+}
+
+func (e *FuncType) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *FuncType) Pos() source.Pos {
+	return e.FuncPos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *FuncType) End() source.Pos {
+	return e.Params.End()
+}
+
+func (e *FuncType) String() string {
+	return "func" + e.Params.String()
+}

vendor/github.com/d5/tengo/compiler/ast/ident.go

@@ -0,0 +1,29 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// Ident represents an identifier.
+type Ident struct {
+	Name    string
+	NamePos source.Pos
+}
+
+func (e *Ident) exprNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (e *Ident) Pos() source.Pos {
+	return e.NamePos
+}
+
+// End returns the position of first character immediately after the node.
+func (e *Ident) End() source.Pos {
+	return source.Pos(int(e.NamePos) + len(e.Name))
+}
+
+func (e *Ident) String() string {
+	if e != nil {
+		return e.Name
+	}
+
+	return nullRep
+}

vendor/github.com/d5/tengo/compiler/ast/ident_list.go

@@ -0,0 +1,58 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/d5/tengo/compiler/source"
+)
+
+// IdentList represents a list of identifiers.
+type IdentList struct {
+	LParen source.Pos
+	List   []*Ident
+	RParen source.Pos
+}
+
+// Pos returns the position of first character belonging to the node.
+func (n *IdentList) Pos() source.Pos {
+	if n.LParen.IsValid() {
+		return n.LParen
+	}
+
+	if len(n.List) > 0 {
+		return n.List[0].Pos()
+	}
+
+	return source.NoPos
+}
+
+// End returns the position of first character immediately after the node.
+func (n *IdentList) End() source.Pos {
+	if n.RParen.IsValid() {
+		return n.RParen + 1
+	}
+
+	if l := len(n.List); l > 0 {
+		return n.List[l-1].End()
+	}
+
+	return source.NoPos
+}
+
+// NumFields returns the number of fields.
+func (n *IdentList) NumFields() int {
+	if n == nil {
+		return 0
+	}
+
+	return len(n.List)
+}
+
+func (n *IdentList) String() string {
+	var list []string
+	for _, e := range n.List {
+		list = append(list, e.String())
+	}
+
+	return "(" + strings.Join(list, ", ") + ")"
+}

vendor/github.com/d5/tengo/compiler/ast/if_stmt.go

@@ -0,0 +1,40 @@
+package ast
+
+import "github.com/d5/tengo/compiler/source"
+
+// IfStmt represents an if statement.
+type IfStmt struct {
+	IfPos source.Pos
+	Init  Stmt
+	Cond  Expr
+	Body  *BlockStmt
+	Else  Stmt // else branch; or nil
+}
+
+func (s *IfStmt) stmtNode() {}
+
+// Pos returns the position of first character belonging to the node.
+func (s *IfStmt) Pos() source.Pos {
+	return s.IfPos
+}
+
+// End returns the position of first character immediately after the node.
+func (s *IfStmt) End() source.Pos {
+	if s.Else != nil {
+		return s.Else.End()
+	}
+
+	return s.Body.End()
+}
+
+func (s *IfStmt) String() string {
+	var initStmt, elseStmt string
+	if s.Init != nil {
+		initStmt = s.Init.String() + "; "
+	}
+	if s.Else != nil {
+		elseStmt = " else " + s.Else.String()
+	}
+
+	return "if " + initStmt + s.Cond.String() + " " + s.Body.String() + elseStmt
+}