Release v1.11.3

Currently numbers are stripped not just after the color control code (\x03) but also after other formatting such as bold (\x02) and italic (\x1D), which is both unnecessary and leads to missing text from irc. This fixes that by only stripping numbers after the color control code.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,36 @@
+<!-- This is a bug report template. By following the instructions below and
+filling out the sections with your information, you will help the us to get all
+the necessary data to fix your issue.
+
+You can also preview your report before submitting it.
+
+Text between <!-- and --​> marks will be invisible in the report.
+-->
+
+<!-- If you have a configuration problem, please first try to create a basic configuration following the instructions on [the wiki](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) before filing an issue. -->
+
+
+### Environment
+<!-- run `matterbridge -version` -->
+<!-- If you're having problems with mattermost also specify the mattermost version. -->
+Version:
+
+<!-- What operating system are you using ? (be as specific as possible) -->
+Operating system:
+
+<!-- If you compiled matterbridge yourself:
+       * Specify the output of `go version` 
+       * Specify the output of `git rev-parse HEAD` -->
+
+### Please describe the expected behavior.
+
+
+### Please describe the actual behavior. 
+<!-- Use logs from running `matterbridge -debug` if possible. -->
+
+
+### Any steps to reproduce the behavior?
+
+
+### Please add your configuration file 
+<!-- (be sure to exclude or anonymize private data (tokens/passwords)) -->

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve. (Check the FAQ on the wiki first)
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots/debug logs**
+If applicable, add screenshots to help explain your problem.
+Use logs from running `matterbridge -debug` if possible.
+
+**Environment (please complete the following information):**
+ - OS: [e.g. linux]
+ - Matterbridge version: output of  `matterbridge -version`
+ - If self compiled: output of `git rev-parse HEAD`
+
+**Additional context**
+Please add your configuration file  (be sure to exclude or anonymize private data (tokens/passwords))

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.travis.yml

@@ -0,0 +1,51 @@
+language: go
+go:
+    #- 1.7.x
+    - 1.10.x
+      # - tip
+
+# we have everything vendored
+install: true
+
+env:
+    - GOOS=linux GOARCH=amd64
+      #    - GOOS=windows GOARCH=amd64
+      #- GOOS=linux GOARCH=arm
+
+matrix:
+  # It's ok if our code fails on unstable development versions of Go.
+  allow_failures:
+    - go: tip
+  # Don't wait for tip tests to finish. Mark the test run green if the
+  # tests pass on the stable versions of Go.
+  fast_finish: true
+
+notifications:
+      email: false
+
+before_script:
+  - MY_VERSION=$(git describe --tags)
+  - GO_FILES=$(find . -iname '*.go' | grep -v /vendor/)  # All the .go files, excluding vendor/
+  - PKGS=$(go list ./... | grep -v /vendor/)             # All the import paths, excluding vendor/
+#  - go get github.com/golang/lint/golint                 # Linter
+  - go get honnef.co/go/tools/cmd/megacheck              # Badass static analyzer/linter
+
+# Anything in before_script: that returns a nonzero exit code will
+# flunk the build and immediately stop. It's sorta like having
+# set -e enabled in bash. 
+script:
+ #- test -z $(gofmt -s -l $GO_FILES)  # Fail if a .go file hasn't been formatted with gofmt
+  - go test -v -race $PKGS            # Run all the tests with the race detector enabled
+ #  - go vet $PKGS                      # go vet is the official Go static analyzer
+  - megacheck $PKGS                   # "go vet on steroids" + linter
+  - /bin/bash ci/bintray.sh
+  #- golint -set_exit_status $PKGS     # one last linter
+
+deploy:
+  provider: bintray
+  edge:
+    branch: v1.8.47
+  file: ci/deploy.json
+  user: 42wim
+  key:
+     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="

Dockerfile

@@ -0,0 +1,11 @@
+FROM alpine:edge
+ENTRYPOINT ["/bin/matterbridge"]
+
+COPY . /go/src/github.com/42wim/matterbridge
+RUN apk update && apk add go git gcc musl-dev ca-certificates \
+        && cd /go/src/github.com/42wim/matterbridge \
+        && export GOPATH=/go \
+        && go get \
+        && go build -x -ldflags "-X main.githash=$(git log --pretty=format:'%h' -n 1)" -o /bin/matterbridge \
+        && rm -rf /go \
+        && apk del --purge git go gcc musl-dev

README.md

@@ -1,17 +1,81 @@
 # matterbridge
+Click on one of the badges below to join the chat   
 
-Simple bridge between mattermost and IRC. Uses the in/outgoing webhooks.  
-Relays public channel messages between mattermost and IRC.  
+[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?colorB=42f4242)](https://gitter.im/42wim/matterbridge) [![Join the IRC chat at https://webchat.freenode.net/?channels=matterbridgechat](https://img.shields.io/badge/IRC-matterbridgechat-green.svg?colorB=42f4242)](https://webchat.freenode.net/?channels=matterbridgechat) [![Discord](https://img.shields.io/badge/discord-matterbridge-green.svg?colorB=42f4242)](https://discord.gg/AkKPtrQ) [![Matrix](https://img.shields.io/badge/matrix-matterbridge-green.svg?colorB=42f4242)](https://riot.im/app/#/room/#matterbridge:matrix.org) [![Slack](https://img.shields.io/badge/slack-matterbridgechat-green.svg?colorB=42f4242)](https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA) [![Mattermost](https://img.shields.io/badge/mattermost-matterbridge-green.svg?colorB=42f4242)](https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e) [![Xmpp](https://img.shields.io/badge/xmpp-matterbridge@conference.jabber.de-green.svg?colorB=42f4242)](https://inverse.chat) [![Twitch](https://img.shields.io/badge/twitch-matterbridge-green.svg?colorB=42f4242)](https://www.twitch.tv/matterbridge) [![Zulip](https://img.shields.io/badge/zulip-matterbridge-green.svg?colorB=42f4242)](https://matterbridge.zulipchat.com/register/)
 
-Requires mattermost 1.2.0+
+[![Download stable](https://img.shields.io/github/release/42wim/matterbridge.svg?label=download%20stable)](https://github.com/42wim/matterbridge/releases/latest) [![Download dev](https://img.shields.io/bintray/v/42wim/nightly/Matterbridge.svg?label=download%20dev&colorB=007ec6)](https://bintray.com/42wim/nightly/Matterbridge/_latestVersion)
 
-There is also [matterbridge-plus] (https://github.com/42wim/matterbridge-plus) which uses the mattermost API and needs a dedicated user (bot). But requires no incoming/outgoing webhook setup. 
+![matterbridge.gif](https://github.com/42wim/matterbridge/blob/master/img/matterbridge.gif)
 
-## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/tag/v0.3)
+Simple bridge between IRC, XMPP, Gitter, Mattermost, Slack, Discord, Telegram, Rocket.Chat, Hipchat(via xmpp), Matrix, Steam, ssh-chat and Zulip
+Has a REST API.   
+Minecraft server chat support via [MatterLink](https://github.com/elytra/MatterLink)
 
-## building
-Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
+**Mattermost isn't required to run matterbridge. It bridges between any supported protocol.**   
+(The name matterbridge is a remnant when it was only bridging mattermost)
+
+# Table of Contents
+ * [Features](https://github.com/42wim/matterbridge/wiki/Features)
+ * [Requirements](#requirements)
+ * [Screenshots](https://github.com/42wim/matterbridge/wiki/)
+ * [Installing](#installing)
+   * [Binaries](#binaries)
+   * [Building](#building)
+ * [Configuration](#configuration)
+   * [Howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config)
+   * [Examples](#examples) 
+ * [Running](#running)
+   * [Docker](#docker)
+ * [Changelog](#changelog)
+ * [FAQ](#faq)
+ * [Thanks](#thanks)
+
+# Features
+* [Support bridging between any protocols](https://github.com/42wim/matterbridge/wiki/Features#support-bridging-between-any-protocols)
+* [Support multiple gateways(bridges) for your protocols](https://github.com/42wim/matterbridge/wiki/Features#support-multiple-gatewaysbridges-for-your-protocols)
+* [Message edits and deletes](https://github.com/42wim/matterbridge/wiki/Features#message-edits-and-deletes)
+* [Attachment / files handling](https://github.com/42wim/matterbridge/wiki/Features#attachment--files-handling)
+* [Username and avatar spoofing](https://github.com/42wim/matterbridge/wiki/Features#username-and-avatar-spoofing)
+* [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 and rather undocumented.
+
+Used by at least 2 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)
+
+# Requirements
+Accounts to one of the supported bridges
+* [Mattermost](https://github.com/mattermost/platform/) 3.8.x - 3.10.x, 4.x, 5.x
+* [IRC](http://www.mirc.com/servers.html)
+* [XMPP](https://jabber.org)
+* [Gitter](https://gitter.im)
+* [Slack](https://slack.com)
+* [Discord](https://discordapp.com)
+* [Telegram](https://telegram.org)
+* [Hipchat](https://www.hipchat.com)
+* [Rocket.chat](https://rocket.chat)
+* [Matrix](https://matrix.org)
+* [Steam](https://store.steampowered.com/)
+* [Twitch](https://twitch.tv)
+* [Ssh-chat](https://github.com/shazow/ssh-chat)
+* [Zulip](https://zulipchat.com)
+
+# Screenshots
+See https://github.com/42wim/matterbridge/wiki
+
+# Installing
+## Binaries
+* Latest stable release [v1.11.3](https://github.com/42wim/matterbridge/releases/latest)
+* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)  
+
+## 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).
+
+After Go is setup, download matterbridge to your $GOPATH directory. 
 
 ```
 cd $GOPATH
@@ -25,78 +89,117 @@ $ ls bin/
 matterbridge
 ```
 
-## running
-1) Copy the matterbridge.conf.sample to matterbridge.conf in the same directory as the matterbridge binary.  
-2) Edit matterbridge.conf with the settings for your environment. See below for more config information.  
-3) Now you can run matterbridge. 
+# Configuration
+## Basic configuration
+See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
 
+## Advanced configuration
+* [matterbridge.toml.sample](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
+
+## Examples 
+### Bridge mattermost (off-topic) - irc (#testing)
 ```
-Usage of matterbridge:
-  -conf="matterbridge.conf": config file
-```
-
-Matterbridge will:
-* start a webserver listening on the port specified in the configuration.
-* connect to specified irc server and channel.
-* send messages from mattermost to irc and vice versa, messages in mattermost will appear with irc-nick
-
-## config
-### matterbridge
-matterbridge looks for matterbridge.conf in current directory. (use -conf to specify another file)
-
-Look at matterbridge.conf.sample for an example
-
-
-```
-[IRC]
-server="irc.freenode.net"
-port=6667
-UseTLS=false
-SkipTLSVerify=true
-nick="matterbot"
-channel="#matterbridge"
-UseSlackCircumfix=false
+[irc]
+    [irc.freenode]
+    Server="irc.freenode.net:6667"
+    Nick="yourbotname"
 
 [mattermost]
-#url is your incoming webhook url (account settings - integrations - incoming webhooks)
-url="http://mattermost.yourdomain.com/hooks/incomingwebhookkey"  
-#port the bridge webserver will listen on
-port=9999
-#address the webserver will bind to
-BindAddress="0.0.0.0"
-showjoinpart=true #show irc users joining and parting
-#the token you get from the outgoing webhook in mattermost. If empty no token check will be done.
-#if you use multiple IRC channel (see below, this must be empty!)
-token=yourtokenfrommattermost
-#disable certificate checking (selfsigned certificates)
-#SkipTLSVerify=true
+    [mattermost.work]
+    Server="yourmattermostserver.tld"
+    Team="yourteam"
+    Login="yourlogin"
+    Password="yourpass"
+    PrefixMessagesWithNick=true
+    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
-#multiple channel config
-#token you can find in your outgoing webhook
-[Token "outgoingwebhooktoken1"] 
-IRCChannel="#off-topic"
-MMChannel="off-topic"
+[[gateway]]
+name="mygateway"
+enable=true
+    [[gateway.inout]]
+    account="irc.freenode"
+    channel="#testing"
 
-[Token "outgoingwebhooktoken2"]
-IRCChannel="#testing"
-MMChannel="testing"
-
-[general]
-#request your API key on https://github.com/giphy/GiphyAPI. This is a public beta key
-GiphyApiKey="dc6zaTOxFJmzC"
+    [[gateway.inout]]
+    account="mattermost.work"
+    channel="off-topic"
 ```
 
-### mattermost
-You'll have to configure the incoming en outgoing webhooks. 
+### Bridge slack (#general) - discord (general)
+```
+[slack]
+[slack.test]
+Token="yourslacktoken"
+PrefixMessagesWithNick=true
 
-* incoming webhooks
-Go to "account settings" - integrations - "incoming webhooks".  
-Choose a channel at "Add a new incoming webhook", this will create a webhook URL right below.  
-This URL should be set in the matterbridge.conf in the [mattermost] section (see above)  
+[discord]
+[discord.test]
+Token="yourdiscordtoken"
+Server="yourdiscordservername"
 
-* outgoing webhooks
-Go to "account settings" - integrations - "outgoing webhooks".  
-Choose a channel (the same as the one from incoming webhooks) and fill in the address and port of the server matterbridge will run on.  
+[general]
+RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
 
-e.g. http://192.168.1.1:9999 (9999 is the port specified in [mattermost] section of matterbridge.conf)
+[[gateway]]
+    name = "mygateway"
+    enable=true
 
+    [[gateway.inout]]
+    account = "discord.test"
+    channel="general"
+
+    [[gateway.inout]]
+    account ="slack.test"
+    channel = "general"
+```
+
+# Running
+
+See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
+
+```
+Usage of ./matterbridge:
+  -conf string
+        config file (default "matterbridge.toml")
+  -debug
+        enable debug
+  -gops
+        enable gops agent
+  -version
+        show version
+```
+
+## Docker
+Create your matterbridge.toml file locally eg in ```/tmp/matterbridge.toml```
+```
+docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
+```
+
+# Changelog
+See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.md)
+
+# FAQ
+
+See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
+
+Want to tip ? 
+* eth: 0xb3f9b5387c66ad6be892bcb7bbc67862f3abc16f
+* btc: 1N7cKHj5SfqBHBzDJ6kad4BzeqUBBS2zhs
+
+# Thanks
+[![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
+
+Matterbridge wouldn't exist without these libraries:
+* discord - https://github.com/bwmarrin/discordgo
+* echo - https://github.com/labstack/echo
+* gitter - https://github.com/sromku/go-gitter
+* gops - https://github.com/google/gops
+* gozulipbot - https://github.com/ifo/gozulipbot
+* irc - https://github.com/lrstanley/girc
+* mattermost - https://github.com/mattermost/platform
+* matrix - https://github.com/matrix-org/gomatrix
+* 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
+* zulip - https://github.com/ifo/gozulipbot

bridge/api/api.go

@@ -0,0 +1,121 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/labstack/echo"
+	"github.com/labstack/echo/middleware"
+	"github.com/zfjagann/golang-ring"
+)
+
+type Api struct {
+	Messages ring.Ring
+	sync.RWMutex
+	*bridge.Config
+}
+
+type ApiMessage struct {
+	Text     string `json:"text"`
+	Username string `json:"username"`
+	UserID   string `json:"userid"`
+	Avatar   string `json:"avatar"`
+	Gateway  string `json:"gateway"`
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Api{Config: cfg}
+	e := echo.New()
+	e.HideBanner = true
+	e.HidePort = true
+	b.Messages = ring.Ring{}
+	b.Messages.SetCapacity(b.GetInt("Buffer"))
+	if b.GetString("Token") != "" {
+		e.Use(middleware.KeyAuth(func(key string, c echo.Context) (bool, error) {
+			return key == b.GetString("Token"), nil
+		}))
+	}
+	e.GET("/api/messages", b.handleMessages)
+	e.GET("/api/stream", b.handleStream)
+	e.POST("/api/message", b.handlePostMessage)
+	go func() {
+		if b.GetString("BindAddress") == "" {
+			b.Log.Fatalf("No BindAddress configured.")
+		}
+		b.Log.Infof("Listening on %s", b.GetString("BindAddress"))
+		b.Log.Fatal(e.Start(b.GetString("BindAddress")))
+	}()
+	return b
+}
+
+func (b *Api) Connect() error {
+	return nil
+}
+func (b *Api) Disconnect() error {
+	return nil
+
+}
+func (b *Api) JoinChannel(channel config.ChannelInfo) error {
+	return nil
+
+}
+
+func (b *Api) Send(msg config.Message) (string, error) {
+	b.Lock()
+	defer b.Unlock()
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+	b.Messages.Enqueue(&msg)
+	return "", nil
+}
+
+func (b *Api) handlePostMessage(c echo.Context) error {
+	message := config.Message{}
+	if err := c.Bind(&message); err != nil {
+		return err
+	}
+	// these values are fixed
+	message.Channel = "api"
+	message.Protocol = "api"
+	message.Account = b.Account
+	message.ID = ""
+	message.Timestamp = time.Now()
+	b.Log.Debugf("Sending message from %s on %s to gateway", message.Username, "api")
+	b.Remote <- message
+	return c.JSON(http.StatusOK, message)
+}
+
+func (b *Api) handleMessages(c echo.Context) error {
+	b.Lock()
+	defer b.Unlock()
+	c.JSONPretty(http.StatusOK, b.Messages.Values(), " ")
+	b.Messages = ring.Ring{}
+	return nil
+}
+
+func (b *Api) handleStream(c echo.Context) error {
+	c.Response().Header().Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	c.Response().WriteHeader(http.StatusOK)
+	closeNotifier := c.Response().CloseNotify()
+	for {
+		select {
+		case <-closeNotifier:
+			return nil
+		default:
+			msg := b.Messages.Dequeue()
+			if msg != nil {
+				if err := json.NewEncoder(c.Response()).Encode(msg); err != nil {
+					return err
+				}
+				c.Response().Flush()
+			}
+			time.Sleep(200 * time.Millisecond)
+		}
+	}
+}

bridge/bridge.go

@@ -0,0 +1,104 @@
+package bridge
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/sirupsen/logrus"
+
+	"strings"
+)
+
+type Bridger interface {
+	Send(msg config.Message) (string, error)
+	Connect() error
+	JoinChannel(channel config.ChannelInfo) error
+	Disconnect() error
+}
+
+type Bridge struct {
+	Bridger
+	Name     string
+	Account  string
+	Protocol string
+	Channels map[string]config.ChannelInfo
+	Joined   map[string]bool
+	Log      *log.Entry
+	Config   *config.Config
+	General  *config.Protocol
+}
+
+type Config struct {
+	//	General *config.Protocol
+	Remote chan config.Message
+	Log    *log.Entry
+	*Bridge
+}
+
+// Factory is the factory function to create a bridge
+type Factory func(*Config) Bridger
+
+func New(bridge *config.Bridge) *Bridge {
+	b := new(Bridge)
+	b.Channels = make(map[string]config.ChannelInfo)
+	accInfo := strings.Split(bridge.Account, ".")
+	protocol := accInfo[0]
+	name := accInfo[1]
+	b.Name = name
+	b.Protocol = protocol
+	b.Account = bridge.Account
+	b.Joined = make(map[string]bool)
+	return b
+}
+
+func (b *Bridge) JoinChannels() error {
+	err := b.joinChannels(b.Channels, b.Joined)
+	return err
+}
+
+func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map[string]bool) error {
+	for ID, channel := range channels {
+		if !exists[ID] {
+			b.Log.Infof("%s: joining %s (ID: %s)", b.Account, channel.Name, ID)
+			err := b.JoinChannel(channel)
+			if err != nil {
+				return err
+			}
+			exists[ID] = true
+		}
+	}
+	return nil
+}
+
+func (b *Bridge) GetBool(key string) bool {
+	if b.Config.GetBool(b.Account + "." + key) {
+		return b.Config.GetBool(b.Account + "." + key)
+	}
+	return b.Config.GetBool("general." + key)
+}
+
+func (b *Bridge) GetInt(key string) int {
+	if b.Config.GetInt(b.Account+"."+key) != 0 {
+		return b.Config.GetInt(b.Account + "." + key)
+	}
+	return b.Config.GetInt("general." + key)
+}
+
+func (b *Bridge) GetString(key string) string {
+	if b.Config.GetString(b.Account+"."+key) != "" {
+		return b.Config.GetString(b.Account + "." + key)
+	}
+	return b.Config.GetString("general." + key)
+}
+
+func (b *Bridge) GetStringSlice(key string) []string {
+	if len(b.Config.GetStringSlice(b.Account+"."+key)) != 0 {
+		return b.Config.GetStringSlice(b.Account + "." + key)
+	}
+	return b.Config.GetStringSlice("general." + key)
+}
+
+func (b *Bridge) GetStringSlice2D(key string) [][]string {
+	if len(b.Config.GetStringSlice2D(b.Account+"."+key)) != 0 {
+		return b.Config.GetStringSlice2D(b.Account + "." + key)
+	}
+	return b.Config.GetStringSlice2D("general." + key)
+}

bridge/config/config.go

@@ -0,0 +1,286 @@
+package config
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+)
+
+const (
+	EVENT_JOIN_LEAVE        = "join_leave"
+	EVENT_TOPIC_CHANGE      = "topic_change"
+	EVENT_FAILURE           = "failure"
+	EVENT_FILE_FAILURE_SIZE = "file_failure_size"
+	EVENT_AVATAR_DOWNLOAD   = "avatar_download"
+	EVENT_REJOIN_CHANNELS   = "rejoin_channels"
+	EVENT_USER_ACTION       = "user_action"
+	EVENT_MSG_DELETE        = "msg_delete"
+)
+
+type Message struct {
+	Text      string    `json:"text"`
+	Channel   string    `json:"channel"`
+	Username  string    `json:"username"`
+	UserID    string    `json:"userid"` // userid on the bridge
+	Avatar    string    `json:"avatar"`
+	Account   string    `json:"account"`
+	Event     string    `json:"event"`
+	Protocol  string    `json:"protocol"`
+	Gateway   string    `json:"gateway"`
+	Timestamp time.Time `json:"timestamp"`
+	ID        string    `json:"id"`
+	Extra     map[string][]interface{}
+}
+
+type FileInfo struct {
+	Name    string
+	Data    *[]byte
+	Comment string
+	URL     string
+	Size    int64
+	Avatar  bool
+	SHA     string
+}
+
+type ChannelInfo struct {
+	Name        string
+	Account     string
+	Direction   string
+	ID          string
+	SameChannel map[string]bool
+	Options     ChannelOptions
+}
+
+type Protocol struct {
+	AuthCode               string // steam
+	BindAddress            string // mattermost, slack // DEPRECATED
+	Buffer                 int    // api
+	Charset                string // irc
+	ColorNicks             bool   // only irc for now
+	Debug                  bool   // general
+	DebugLevel             int    // only for irc now
+	EditSuffix             string // mattermost, slack, discord, telegram, gitter
+	EditDisable            bool   // mattermost, slack, discord, telegram, gitter
+	IconURL                string // mattermost, slack
+	IgnoreNicks            string // all protocols
+	IgnoreMessages         string // all protocols
+	Jid                    string // xmpp
+	Label                  string // all protocols
+	Login                  string // mattermost, matrix
+	MediaDownloadBlackList []string
+	MediaDownloadPath      string // Basically MediaServerUpload, but instead of uploading it, just write it to a file on the same server.
+	MediaDownloadSize      int    // all protocols
+	MediaServerDownload    string
+	MediaServerUpload      string
+	MessageDelay           int        // IRC, time in millisecond to wait between messages
+	MessageFormat          string     // telegram
+	MessageLength          int        // IRC, max length of a message allowed
+	MessageQueue           int        // IRC, size of message queue for flood control
+	MessageSplit           bool       // IRC, split long messages with newlines on MessageLength instead of clipping
+	Muc                    string     // xmpp
+	Name                   string     // all protocols
+	Nick                   string     // all protocols
+	NickFormatter          string     // mattermost, slack
+	NickServNick           string     // IRC
+	NickServUsername       string     // IRC
+	NickServPassword       string     // IRC
+	NicksPerRow            int        // mattermost, slack
+	NoHomeServerSuffix     bool       // matrix
+	NoSendJoinPart         bool       // all protocols
+	NoTLS                  bool       // mattermost
+	Password               string     // IRC,mattermost,XMPP,matrix
+	PrefixMessagesWithNick bool       // mattemost, slack
+	Protocol               string     // all protocols
+	QuoteDisable           bool       // telegram
+	QuoteFormat            string     // telegram
+	RejoinDelay            int        // IRC
+	ReplaceMessages        [][]string // all protocols
+	ReplaceNicks           [][]string // all protocols
+	RemoteNickFormat       string     // all protocols
+	Server                 string     // IRC,mattermost,XMPP,discord
+	ShowJoinPart           bool       // all protocols
+	ShowTopicChange        bool       // slack
+	ShowEmbeds             bool       // discord
+	SkipTLSVerify          bool       // IRC, mattermost
+	StripNick              bool       // all protocols
+	Team                   string     // mattermost
+	Token                  string     // gitter, slack, discord, api
+	Topic                  string     // zulip
+	URL                    string     // mattermost, slack // DEPRECATED
+	UseAPI                 bool       // mattermost, slack
+	UseSASL                bool       // IRC
+	UseTLS                 bool       // IRC
+	UseFirstName           bool       // telegram
+	UseUserName            bool       // discord
+	UseInsecureURL         bool       // telegram
+	WebhookBindAddress     string     // mattermost, slack
+	WebhookURL             string     // mattermost, slack
+	WebhookUse             string     // mattermost, slack, discord
+}
+
+type ChannelOptions struct {
+	Key        string // irc, xmpp
+	WebhookURL string // discord
+}
+
+type Bridge struct {
+	Account     string
+	Channel     string
+	Options     ChannelOptions
+	SameChannel bool
+}
+
+type Gateway struct {
+	Name   string
+	Enable bool
+	In     []Bridge
+	Out    []Bridge
+	InOut  []Bridge
+}
+
+type SameChannelGateway struct {
+	Name     string
+	Enable   bool
+	Channels []string
+	Accounts []string
+}
+
+type ConfigValues struct {
+	Api                map[string]Protocol
+	Irc                map[string]Protocol
+	Mattermost         map[string]Protocol
+	Matrix             map[string]Protocol
+	Slack              map[string]Protocol
+	Steam              map[string]Protocol
+	Gitter             map[string]Protocol
+	Xmpp               map[string]Protocol
+	Discord            map[string]Protocol
+	Telegram           map[string]Protocol
+	Rocketchat         map[string]Protocol
+	Sshchat            map[string]Protocol
+	Zulip              map[string]Protocol
+	General            Protocol
+	Gateway            []Gateway
+	SameChannelGateway []SameChannelGateway
+}
+
+type Config struct {
+	v *viper.Viper
+	*ConfigValues
+	sync.RWMutex
+}
+
+func NewConfig(cfgfile string) *Config {
+	log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false})
+	flog := log.WithFields(log.Fields{"prefix": "config"})
+	var cfg ConfigValues
+	viper.SetConfigType("toml")
+	viper.SetConfigFile(cfgfile)
+	viper.SetEnvPrefix("matterbridge")
+	viper.AddConfigPath(".")
+	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	viper.AutomaticEnv()
+	f, err := os.Open(cfgfile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = viper.ReadConfig(f)
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = viper.Unmarshal(&cfg)
+	if err != nil {
+		log.Fatal("blah", err)
+	}
+	mycfg := new(Config)
+	mycfg.v = viper.GetViper()
+	if cfg.General.MediaDownloadSize == 0 {
+		cfg.General.MediaDownloadSize = 1000000
+	}
+	viper.WatchConfig()
+	viper.OnConfigChange(func(e fsnotify.Event) {
+		flog.Println("Config file changed:", e.Name)
+	})
+
+	mycfg.ConfigValues = &cfg
+	return mycfg
+}
+
+func NewConfigFromString(input []byte) *Config {
+	var cfg ConfigValues
+	viper.SetConfigType("toml")
+	err := viper.ReadConfig(bytes.NewBuffer(input))
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = viper.Unmarshal(&cfg)
+	if err != nil {
+		log.Fatal(err)
+	}
+	mycfg := new(Config)
+	mycfg.v = viper.GetViper()
+	mycfg.ConfigValues = &cfg
+	return mycfg
+}
+
+func (c *Config) GetBool(key string) bool {
+	c.RLock()
+	defer c.RUnlock()
+	//	log.Debugf("getting bool %s = %#v", key, c.v.GetBool(key))
+	return c.v.GetBool(key)
+}
+
+func (c *Config) GetInt(key string) int {
+	c.RLock()
+	defer c.RUnlock()
+	//	log.Debugf("getting int %s = %d", key, c.v.GetInt(key))
+	return c.v.GetInt(key)
+}
+
+func (c *Config) GetString(key string) string {
+	c.RLock()
+	defer c.RUnlock()
+	//	log.Debugf("getting String %s = %s", key, c.v.GetString(key))
+	return c.v.GetString(key)
+}
+
+func (c *Config) GetStringSlice(key string) []string {
+	c.RLock()
+	defer c.RUnlock()
+	// log.Debugf("getting StringSlice %s = %#v", key, c.v.GetStringSlice(key))
+	return c.v.GetStringSlice(key)
+}
+
+func (c *Config) GetStringSlice2D(key string) [][]string {
+	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
+	}
+	return result
+}
+
+func GetIconURL(msg *Message, iconURL string) string {
+	info := strings.Split(msg.Account, ".")
+	protocol := info[0]
+	name := info[1]
+	iconURL = strings.Replace(iconURL, "{NICK}", msg.Username, -1)
+	iconURL = strings.Replace(iconURL, "{BRIDGE}", name, -1)
+	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
+	return iconURL
+}

bridge/discord/discord.go

@@ -0,0 +1,434 @@
+package bdiscord
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/matterbridge/discordgo"
+)
+
+const MessageLength = 1950
+
+type Bdiscord struct {
+	c              *discordgo.Session
+	Channels       []*discordgo.Channel
+	Nick           string
+	UseChannelID   bool
+	userMemberMap  map[string]*discordgo.Member
+	guildID        string
+	webhookID      string
+	webhookToken   string
+	channelInfoMap map[string]*config.ChannelInfo
+	sync.RWMutex
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bdiscord{Config: cfg}
+	b.userMemberMap = make(map[string]*discordgo.Member)
+	b.channelInfoMap = make(map[string]*config.ChannelInfo)
+	if b.GetString("WebhookURL") != "" {
+		b.Log.Debug("Configuring Discord Incoming Webhook")
+		b.webhookID, b.webhookToken = b.splitURL(b.GetString("WebhookURL"))
+	}
+	return b
+}
+
+func (b *Bdiscord) Connect() error {
+	var err error
+	var token string
+	b.Log.Info("Connecting")
+	if b.GetString("WebhookURL") == "" {
+		b.Log.Info("Connecting using token")
+	} else {
+		b.Log.Info("Connecting using webhookurl (for posting) and token")
+	}
+	if !strings.HasPrefix(b.GetString("Token"), "Bot ") {
+		token = "Bot " + b.GetString("Token")
+	}
+	b.c, err = discordgo.New(token)
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	b.c.AddHandler(b.messageCreate)
+	b.c.AddHandler(b.memberUpdate)
+	b.c.AddHandler(b.messageUpdate)
+	b.c.AddHandler(b.messageDelete)
+	err = b.c.Open()
+	if err != nil {
+		return err
+	}
+	guilds, err := b.c.UserGuilds(100, "", "")
+	if err != nil {
+		return err
+	}
+	userinfo, err := b.c.User("@me")
+	if err != nil {
+		return err
+	}
+	b.Nick = userinfo.Username
+	for _, guild := range guilds {
+		if guild.Name == b.GetString("Server") {
+			b.Channels, err = b.c.GuildChannels(guild.ID)
+			b.guildID = guild.ID
+			if err != nil {
+				return err
+			}
+		}
+	}
+	for _, channel := range b.Channels {
+		b.Log.Debugf("found channel %#v", channel)
+	}
+	return nil
+}
+
+func (b *Bdiscord) Disconnect() error {
+	return b.c.Close()
+}
+
+func (b *Bdiscord) JoinChannel(channel config.ChannelInfo) error {
+	b.channelInfoMap[channel.ID] = &channel
+	idcheck := strings.Split(channel.Name, "ID:")
+	if len(idcheck) > 1 {
+		b.UseChannelID = true
+	}
+	return nil
+}
+
+func (b *Bdiscord) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	channelID := b.getChannelID(msg.Channel)
+	if channelID == "" {
+		return "", fmt.Errorf("Could not find channelID for %v", msg.Channel)
+	}
+
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
+	}
+
+	// use initial webhook
+	wID := b.webhookID
+	wToken := b.webhookToken
+
+	// check if have a channel specific webhook
+	if ci, ok := b.channelInfoMap[msg.Channel+b.Account]; ok {
+		if ci.Options.WebhookURL != "" {
+			wID, wToken = b.splitURL(ci.Options.WebhookURL)
+		}
+	}
+
+	// Use webhook to send the message
+	if wID != "" {
+		// skip events
+		if msg.Event != "" && msg.Event != config.EVENT_JOIN_LEAVE && msg.Event != config.EVENT_TOPIC_CHANGE {
+			return "", nil
+		}
+		b.Log.Debugf("Broadcasting using Webhook")
+		for _, f := range msg.Extra["file"] {
+			fi := f.(config.FileInfo)
+			if fi.URL != "" {
+				msg.Text += " " + fi.URL
+			}
+		}
+		// skip empty messages
+		if msg.Text == "" {
+			return "", nil
+		}
+
+		msg.Text = helper.ClipMessage(msg.Text, MessageLength)
+		err := b.c.WebhookExecute(
+			wID,
+			wToken,
+			true,
+			&discordgo.WebhookParams{
+				Content:   msg.Text,
+				Username:  msg.Username,
+				AvatarURL: msg.Avatar,
+			})
+		return "", err
+	}
+
+	b.Log.Debugf("Broadcasting using token (API)")
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		err := b.c.ChannelMessageDelete(channelID, msg.ID)
+		return "", err
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			rmsg.Text = helper.ClipMessage(rmsg.Text, MessageLength)
+			b.c.ChannelMessageSend(channelID, rmsg.Username+rmsg.Text)
+		}
+		// check if we have files to upload (from slack, telegram or mattermost)
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&msg, channelID)
+		}
+	}
+
+	msg.Text = helper.ClipMessage(msg.Text, MessageLength)
+	// Edit message
+	if msg.ID != "" {
+		_, err := b.c.ChannelMessageEdit(channelID, msg.ID, msg.Username+msg.Text)
+		return msg.ID, err
+	}
+
+	// Post normal message
+	res, err := b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
+	if err != nil {
+		return "", err
+	}
+	return res.ID, err
+}
+
+func (b *Bdiscord) messageDelete(s *discordgo.Session, m *discordgo.MessageDelete) {
+	rmsg := config.Message{Account: b.Account, ID: m.ID, Event: config.EVENT_MSG_DELETE, Text: config.EVENT_MSG_DELETE}
+	rmsg.Channel = b.getChannelName(m.ChannelID)
+	if b.UseChannelID {
+		rmsg.Channel = "ID:" + m.ChannelID
+	}
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
+	if b.GetBool("EditDisable") {
+		return
+	}
+	// only when message is actually edited
+	if m.Message.EditedTimestamp != "" {
+		b.Log.Debugf("Sending edit message")
+		m.Content = m.Content + b.GetString("EditSuffix")
+		b.messageCreate(s, (*discordgo.MessageCreate)(m))
+	}
+}
+
+func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+	var err error
+
+	// not relay our own messages
+	if m.Author.Username == b.Nick {
+		return
+	}
+	// if using webhooks, do not relay if it's ours
+	if b.useWebhook() && m.Author.Bot && b.isWebhookID(m.Author.ID) {
+		return
+	}
+
+	// add the url of the attachments to content
+	if len(m.Attachments) > 0 {
+		for _, attach := range m.Attachments {
+			m.Content = m.Content + "\n" + attach.URL
+		}
+	}
+
+	rmsg := config.Message{Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg", UserID: m.Author.ID, ID: m.ID}
+
+	if m.Content != "" {
+		b.Log.Debugf("== Receiving event %#v", m.Message)
+		m.Message.Content = b.stripCustomoji(m.Message.Content)
+		m.Message.Content = b.replaceChannelMentions(m.Message.Content)
+		rmsg.Text, err = m.ContentWithMoreMentionsReplaced(b.c)
+		if err != nil {
+			b.Log.Errorf("ContentWithMoreMentionsReplaced failed: %s", err)
+			rmsg.Text = m.ContentWithMentionsReplaced()
+		}
+	}
+
+	// set channel name
+	rmsg.Channel = b.getChannelName(m.ChannelID)
+	if b.UseChannelID {
+		rmsg.Channel = "ID:" + m.ChannelID
+	}
+
+	// set username
+	if !b.GetBool("UseUserName") {
+		rmsg.Username = b.getNick(m.Author)
+	} else {
+		rmsg.Username = m.Author.Username
+	}
+
+	// if we have embedded content add it to text
+	if b.GetBool("ShowEmbeds") && m.Message.Embeds != nil {
+		for _, embed := range m.Message.Embeds {
+			rmsg.Text = rmsg.Text + "embed: " + embed.Title + " - " + embed.Description + " - " + embed.URL + "\n"
+		}
+	}
+
+	// no empty messages
+	if rmsg.Text == "" {
+		return
+	}
+
+	// do we have a /me action
+	var ok bool
+	rmsg.Text, ok = b.replaceAction(rmsg.Text)
+	if ok {
+		rmsg.Event = config.EVENT_USER_ACTION
+	}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
+	b.Lock()
+	if _, ok := b.userMemberMap[m.Member.User.ID]; ok {
+		b.Log.Debugf("%s: memberupdate: user %s (nick %s) changes nick to %s", b.Account, m.Member.User.Username, b.userMemberMap[m.Member.User.ID].Nick, m.Member.Nick)
+	}
+	b.userMemberMap[m.Member.User.ID] = m.Member
+	b.Unlock()
+}
+
+func (b *Bdiscord) getNick(user *discordgo.User) string {
+	var err error
+	b.Lock()
+	defer b.Unlock()
+	if _, ok := b.userMemberMap[user.ID]; ok {
+		if b.userMemberMap[user.ID] != nil {
+			if b.userMemberMap[user.ID].Nick != "" {
+				// only return if nick is set
+				return b.userMemberMap[user.ID].Nick
+			}
+			// otherwise return username
+			return user.Username
+		}
+	}
+	// if we didn't find nick, search for it
+	member, err := b.c.GuildMember(b.guildID, user.ID)
+	if err != nil {
+		return user.Username
+	}
+	b.userMemberMap[user.ID] = member
+	// only return if nick is set
+	if b.userMemberMap[user.ID].Nick != "" {
+		return b.userMemberMap[user.ID].Nick
+	}
+	return user.Username
+}
+
+func (b *Bdiscord) getChannelID(name string) string {
+	idcheck := strings.Split(name, "ID:")
+	if len(idcheck) > 1 {
+		return idcheck[1]
+	}
+	for _, channel := range b.Channels {
+		if channel.Name == name {
+			return channel.ID
+		}
+	}
+	return ""
+}
+
+func (b *Bdiscord) getChannelName(id string) string {
+	for _, channel := range b.Channels {
+		if channel.ID == id {
+			return channel.Name
+		}
+	}
+	return ""
+}
+
+func (b *Bdiscord) replaceChannelMentions(text string) string {
+	var err error
+	re := regexp.MustCompile("<#[0-9]+>")
+	text = re.ReplaceAllStringFunc(text, func(m string) string {
+		channel := b.getChannelName(m[2 : len(m)-1])
+		// if at first don't succeed, try again
+		if channel == "" {
+			b.Channels, err = b.c.GuildChannels(b.guildID)
+			if err != nil {
+				return "#unknownchannel"
+			}
+			channel = b.getChannelName(m[2 : len(m)-1])
+			return "#" + channel
+		}
+		return "#" + channel
+	})
+	return text
+}
+
+func (b *Bdiscord) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "_") && strings.HasSuffix(text, "_") {
+		return strings.Replace(text, "_", "", -1), true
+	}
+	return text, false
+}
+
+func (b *Bdiscord) stripCustomoji(text string) string {
+	// <:doge:302803592035958784>
+	re := regexp.MustCompile("<(:.*?:)[0-9]+>")
+	return re.ReplaceAllString(text, `$1`)
+}
+
+// splitURL splits a webhookURL and returns the id and token
+func (b *Bdiscord) splitURL(url string) (string, string) {
+	webhookURLSplit := strings.Split(url, "/")
+	if len(webhookURLSplit) != 7 {
+		b.Log.Fatalf("%s is no correct discord WebhookURL", url)
+	}
+	return webhookURLSplit[len(webhookURLSplit)-2], webhookURLSplit[len(webhookURLSplit)-1]
+}
+
+// useWebhook returns true if we have a webhook defined somewhere
+func (b *Bdiscord) useWebhook() bool {
+	if b.GetString("WebhookURL") != "" {
+		return true
+	}
+	for _, channel := range b.channelInfoMap {
+		if channel.Options.WebhookURL != "" {
+			return true
+		}
+	}
+	return false
+}
+
+// isWebhookID returns true if the specified id is used in a defined webhook
+func (b *Bdiscord) isWebhookID(id string) bool {
+	if b.GetString("WebhookURL") != "" {
+		wID, _ := b.splitURL(b.GetString("WebhookURL"))
+		if wID == id {
+			return true
+		}
+	}
+	for _, channel := range b.channelInfoMap {
+		if channel.Options.WebhookURL != "" {
+			wID, _ := b.splitURL(channel.Options.WebhookURL)
+			if wID == id {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// handleUploadFile handles native upload of files
+func (b *Bdiscord) handleUploadFile(msg *config.Message, channelID string) (string, error) {
+	var err error
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		files := []*discordgo.File{}
+		files = append(files, &discordgo.File{fi.Name, "", bytes.NewReader(*fi.Data)})
+		_, err = b.c.ChannelMessageSendComplex(channelID, &discordgo.MessageSend{Content: msg.Username + fi.Comment, Files: files})
+		if err != nil {
+			return "", fmt.Errorf("file upload failed: %#v", err)
+		}
+	}
+	return "", nil
+}

bridge/gitter/gitter.go

@@ -0,0 +1,182 @@
+package bgitter
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/42wim/go-gitter"
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+)
+
+type Bgitter struct {
+	c     *gitter.Gitter
+	User  *gitter.User
+	Users []gitter.User
+	Rooms []gitter.Room
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bgitter{Config: cfg}
+}
+
+func (b *Bgitter) Connect() error {
+	var err error
+	b.Log.Info("Connecting")
+	b.c = gitter.New(b.GetString("Token"))
+	b.User, err = b.c.GetUser()
+	if err != nil {
+		return err
+	}
+	b.Rooms, err = b.c.GetRooms()
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	return nil
+}
+
+func (b *Bgitter) Disconnect() error {
+	return nil
+
+}
+
+func (b *Bgitter) JoinChannel(channel config.ChannelInfo) error {
+	roomID, err := b.c.GetRoomId(channel.Name)
+	if err != nil {
+		return fmt.Errorf("Could not find roomID for %v. Please create the room on gitter.im", channel.Name)
+	}
+	room, err := b.c.GetRoom(roomID)
+	if err != nil {
+		return err
+	}
+	b.Rooms = append(b.Rooms, *room)
+	user, err := b.c.GetUser()
+	if err != nil {
+		return err
+	}
+	_, err = b.c.JoinRoom(roomID, user.ID)
+	if err != nil {
+		return err
+	}
+	users, _ := b.c.GetUsersInRoom(roomID)
+	b.Users = append(b.Users, users...)
+	stream := b.c.Stream(roomID)
+	go b.c.Listen(stream)
+
+	go func(stream *gitter.Stream, room string) {
+		for event := range stream.Event {
+			switch ev := event.Data.(type) {
+			case *gitter.MessageReceived:
+				// ignore message sent from ourselves
+				if ev.Message.From.ID != b.User.ID {
+					b.Log.Debugf("<= Sending message from %s on %s to gateway", ev.Message.From.Username, b.Account)
+					rmsg := config.Message{Username: ev.Message.From.Username, Text: ev.Message.Text, Channel: room,
+						Account: b.Account, Avatar: b.getAvatar(ev.Message.From.Username), UserID: ev.Message.From.ID,
+						ID: ev.Message.ID}
+					if strings.HasPrefix(ev.Message.Text, "@"+ev.Message.From.Username) {
+						rmsg.Event = config.EVENT_USER_ACTION
+						rmsg.Text = strings.Replace(rmsg.Text, "@"+ev.Message.From.Username+" ", "", -1)
+					}
+					b.Log.Debugf("<= Message is %#v", rmsg)
+					b.Remote <- rmsg
+				}
+			case *gitter.GitterConnectionClosed:
+				b.Log.Errorf("connection with gitter closed for room %s", room)
+			}
+		}
+	}(stream, room.URI)
+	return nil
+}
+
+func (b *Bgitter) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+	roomID := b.getRoomID(msg.Channel)
+	if roomID == "" {
+		b.Log.Errorf("Could not find roomID for %v", msg.Channel)
+		return "", nil
+	}
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		// gitter has no delete message api so we edit message to ""
+		_, err := b.c.UpdateMessage(roomID, msg.ID, "")
+		if err != nil {
+			return "", err
+		}
+		return "", nil
+	}
+
+	// Upload a file (in gitter case send the upload URL because gitter has no native upload support)
+	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)
+		}
+	}
+
+	// Edit message
+	if msg.ID != "" {
+		b.Log.Debugf("updating message with id %s", msg.ID)
+		_, err := b.c.UpdateMessage(roomID, msg.ID, msg.Username+msg.Text)
+		if err != nil {
+			return "", err
+		}
+		return "", nil
+	}
+
+	// Post normal message
+	resp, err := b.c.SendMessage(roomID, msg.Username+msg.Text)
+	if err != nil {
+		return "", err
+	}
+	return resp.ID, nil
+}
+
+func (b *Bgitter) getRoomID(channel string) string {
+	for _, v := range b.Rooms {
+		if v.URI == channel {
+			return v.ID
+		}
+	}
+	return ""
+}
+
+func (b *Bgitter) getAvatar(user string) string {
+	var avatar string
+	if b.Users != nil {
+		for _, u := range b.Users {
+			if user == u.Username {
+				return u.AvatarURLSmall
+			}
+		}
+	}
+	return avatar
+}
+
+func (b *Bgitter) handleUploadFile(msg *config.Message, roomID string) (string, error) {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if fi.Comment != "" {
+			msg.Text += fi.Comment + ": "
+		}
+		if fi.URL != "" {
+			msg.Text = fi.URL
+			if fi.Comment != "" {
+				msg.Text = fi.Comment + ": " + fi.URL
+			}
+		}
+		_, err := b.c.SendMessage(roomID, msg.Username+msg.Text)
+		if err != nil {
+			return "", err
+		}
+	}
+	return "", nil
+}

bridge/helper/helper.go

@@ -0,0 +1,130 @@
+package helper
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/sirupsen/logrus"
+)
+
+func DownloadFile(url string) (*[]byte, error) {
+	return DownloadFileAuth(url, "")
+}
+
+func DownloadFileAuth(url string, auth string) (*[]byte, error) {
+	var buf bytes.Buffer
+	client := &http.Client{
+		Timeout: time.Second * 5,
+	}
+	req, err := http.NewRequest("GET", url, nil)
+	if auth != "" {
+		req.Header.Add("Authorization", auth)
+	}
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	io.Copy(&buf, resp.Body)
+	data := buf.Bytes()
+	return &data, nil
+}
+
+func SplitStringLength(input string, length int) string {
+	a := []rune(input)
+	str := ""
+	for i, r := range a {
+		str = str + string(r)
+		if i > 0 && (i+1)%length == 0 {
+			str += "\n"
+		}
+	}
+	return str
+}
+
+// handle all the stuff we put into extra
+func HandleExtra(msg *config.Message, general *config.Protocol) []config.Message {
+	extra := msg.Extra
+	rmsg := []config.Message{}
+	if len(extra[config.EVENT_FILE_FAILURE_SIZE]) > 0 {
+		for _, f := range extra[config.EVENT_FILE_FAILURE_SIZE] {
+			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})
+		}
+		return rmsg
+	}
+	return rmsg
+}
+
+func GetAvatar(av map[string]string, userid string, general *config.Protocol) string {
+	if sha, ok := av[userid]; ok {
+		return general.MediaServerDownload + "/" + sha + "/" + userid + ".png"
+	}
+	return ""
+}
+
+func HandleDownloadSize(flog *log.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)
+				continue
+			}
+			if re.MatchString(name) {
+				return fmt.Errorf("Matching blacklist %s. Not downloading %s", entry, name)
+			}
+		}
+	}
+	flog.Debugf("Trying to download %#v with size %#v", name, size)
+	if int(size) > general.MediaDownloadSize {
+		msg.Event = config.EVENT_FILE_FAILURE_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 *log.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))
+	if msg.Event == config.EVENT_AVATAR_DOWNLOAD {
+		avatar = true
+	}
+	msg.Extra["file"] = append(msg.Extra["file"], config.FileInfo{Name: name, Data: data, URL: url, Comment: comment, Avatar: avatar})
+}
+
+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
+}
+
+func ClipMessage(text string, length int) string {
+	// clip too long messages
+	if len(text) > length {
+		text = text[:length-len(" *message clipped*")]
+		if r, size := utf8.DecodeLastRuneInString(text); r == utf8.RuneError {
+			text = text[:len(text)-size]
+		}
+		text += " *message clipped*"
+	}
+	return text
+}

bridge/irc/helper.go

@@ -0,0 +1,61 @@
+package birc
+
+import (
+	"strings"
+)
+
+/*
+func tableformatter(nicks []string, nicksPerRow int, continued bool) string {
+	result := "|IRC users"
+	if continued {
+		result = "|(continued)"
+	}
+	for i := 0; i < 2; i++ {
+		for j := 1; j <= nicksPerRow && j <= len(nicks); j++ {
+			if i == 0 {
+				result += "|"
+			} else {
+				result += ":-|"
+			}
+		}
+		result += "\r\n|"
+	}
+	result += nicks[0] + "|"
+	for i := 1; i < len(nicks); i++ {
+		if i%nicksPerRow == 0 {
+			result += "\r\n|" + nicks[i] + "|"
+		} else {
+			result += nicks[i] + "|"
+		}
+	}
+	return result
+}
+*/
+
+func plainformatter(nicks []string, nicksPerRow int) string {
+	return strings.Join(nicks, ", ") + " currently on IRC"
+}
+
+func IsMarkup(message string) bool {
+	switch message[0] {
+	case '|':
+		fallthrough
+	case '#':
+		fallthrough
+	case '_':
+		fallthrough
+	case '*':
+		fallthrough
+	case '~':
+		fallthrough
+	case '-':
+		fallthrough
+	case ':':
+		fallthrough
+	case '>':
+		fallthrough
+	case '=':
+		return true
+	}
+	return false
+}

bridge/irc/irc.go

@@ -0,0 +1,466 @@
+package birc
+
+import (
+	"bytes"
+	"crypto/tls"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"io/ioutil"
+	"net"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/dfordsoft/golib/ic"
+	"github.com/lrstanley/girc"
+	"github.com/paulrosania/go-charset/charset"
+	_ "github.com/paulrosania/go-charset/data"
+	"github.com/saintfish/chardet"
+)
+
+type Birc struct {
+	i                                         *girc.Client
+	Nick                                      string
+	names                                     map[string][]string
+	connected                                 chan struct{}
+	Local                                     chan config.Message // local queue for flood control
+	FirstConnection                           bool
+	MessageDelay, MessageQueue, MessageLength int
+
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Birc{}
+	b.Config = cfg
+	b.Nick = b.GetString("Nick")
+	b.names = make(map[string][]string)
+	b.connected = make(chan struct{})
+	if b.GetInt("MessageDelay") == 0 {
+		b.MessageDelay = 1300
+	} else {
+		b.MessageDelay = b.GetInt("MessageDelay")
+	}
+	if b.GetInt("MessageQueue") == 0 {
+		b.MessageQueue = 30
+	} else {
+		b.MessageQueue = b.GetInt("MessageQueue")
+	}
+	if b.GetInt("MessageLength") == 0 {
+		b.MessageLength = 400
+	} else {
+		b.MessageLength = b.GetInt("MessageLength")
+	}
+	b.FirstConnection = true
+	return b
+}
+
+func (b *Birc) Command(msg *config.Message) string {
+	switch msg.Text {
+	case "!users":
+		b.i.Handlers.Add(girc.RPL_NAMREPLY, b.storeNames)
+		b.i.Handlers.Add(girc.RPL_ENDOFNAMES, b.endNames)
+		b.i.Cmd.SendRaw("NAMES " + msg.Channel)
+	}
+	return ""
+}
+
+func (b *Birc) Connect() error {
+	b.Local = make(chan config.Message, b.MessageQueue+10)
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	server, portstr, err := net.SplitHostPort(b.GetString("Server"))
+	if err != nil {
+		return err
+	}
+	port, err := strconv.Atoi(portstr)
+	if err != nil {
+		return err
+	}
+	// fix strict user handling of girc
+	user := b.GetString("Nick")
+	for !girc.IsValidUser(user) {
+		if len(user) == 1 {
+			user = "matterbridge"
+			break
+		}
+		user = user[1:]
+	}
+
+	i := girc.New(girc.Config{
+		Server:     server,
+		ServerPass: b.GetString("Password"),
+		Port:       port,
+		Nick:       b.GetString("Nick"),
+		User:       user,
+		Name:       b.GetString("Nick"),
+		SSL:        b.GetBool("UseTLS"),
+		TLSConfig:  &tls.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"), ServerName: server},
+		PingDelay:  time.Minute,
+	})
+
+	if b.GetBool("UseSASL") {
+		i.Config.SASL = &girc.SASLPlain{b.GetString("NickServNick"), b.GetString("NickServPassword")}
+	}
+
+	i.Handlers.Add(girc.RPL_WELCOME, b.handleNewConnection)
+	i.Handlers.Add(girc.RPL_ENDOFMOTD, b.handleOtherAuth)
+	i.Handlers.Add(girc.ALL_EVENTS, b.handleOther)
+	go func() {
+		for {
+			if err := i.Connect(); err != nil {
+				b.Log.Errorf("disconnect: error: %s", err)
+			} else {
+				b.Log.Info("disconnect: client requested quit")
+			}
+
+			b.Log.Info("reconnecting in 30 seconds...")
+			time.Sleep(30 * time.Second)
+			i.Handlers.Clear(girc.RPL_WELCOME)
+			i.Handlers.Add(girc.RPL_WELCOME, func(client *girc.Client, event girc.Event) {
+				b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: "", Account: b.Account, Event: config.EVENT_REJOIN_CHANNELS}
+				// set our correct nick on reconnect if necessary
+				b.Nick = event.Source.Name
+			})
+		}
+	}()
+	b.i = i
+	select {
+	case <-b.connected:
+		b.Log.Info("Connection succeeded")
+	case <-time.After(time.Second * 30):
+		return fmt.Errorf("connection timed out")
+	}
+	//i.Debug = false
+	if b.GetInt("DebugLevel") == 0 {
+		i.Handlers.Clear(girc.ALL_EVENTS)
+	}
+	go b.doSend()
+	return nil
+}
+
+func (b *Birc) Disconnect() error {
+	b.i.Close()
+	close(b.Local)
+	return nil
+}
+
+func (b *Birc) JoinChannel(channel config.ChannelInfo) error {
+	if channel.Options.Key != "" {
+		b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
+		b.i.Cmd.JoinKey(channel.Name, channel.Options.Key)
+	} else {
+		b.i.Cmd.Join(channel.Name)
+	}
+	return nil
+}
+
+func (b *Birc) Send(msg config.Message) (string, error) {
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// we can be in between reconnects #385
+	if !b.i.IsConnected() {
+		b.Log.Error("Not connected to server, dropping message")
+	}
+
+	// Execute a command
+	if strings.HasPrefix(msg.Text, "!") {
+		b.Command(&msg)
+	}
+
+	// convert to specified charset
+	if b.GetString("Charset") != "" {
+		switch b.GetString("Charset") {
+		case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
+			msg.Text = ic.ConvertString("utf-8", b.GetString("Charset"), msg.Text)
+		default:
+			buf := new(bytes.Buffer)
+			w, err := charset.NewWriter(b.GetString("Charset"), buf)
+			if err != nil {
+				b.Log.Errorf("charset from utf-8 conversion failed: %s", err)
+				return "", err
+			}
+			fmt.Fprint(w, msg.Text)
+			w.Close()
+			msg.Text = buf.String()
+		}
+	}
+
+	// Handle files
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.Local <- rmsg
+		}
+		if len(msg.Extra["file"]) > 0 {
+			for _, f := range msg.Extra["file"] {
+				fi := f.(config.FileInfo)
+				if fi.Comment != "" {
+					msg.Text += fi.Comment + ": "
+				}
+				if fi.URL != "" {
+					msg.Text = fi.URL
+					if fi.Comment != "" {
+						msg.Text = fi.Comment + ": " + fi.URL
+					}
+				}
+				b.Local <- config.Message{Text: msg.Text, Username: msg.Username, Channel: msg.Channel, Event: msg.Event}
+			}
+			return "", nil
+		}
+	}
+
+	// split long messages on messageLength, to avoid clipped messages #281
+	if b.GetBool("MessageSplit") {
+		msg.Text = helper.SplitStringLength(msg.Text, b.MessageLength)
+	}
+	for _, text := range strings.Split(msg.Text, "\n") {
+		if len(text) > b.MessageLength {
+			text = text[:b.MessageLength-len(" <message clipped>")]
+			if r, size := utf8.DecodeLastRuneInString(text); r == utf8.RuneError {
+				text = text[:len(text)-size]
+			}
+			text += " <message clipped>"
+		}
+		if len(b.Local) < b.MessageQueue {
+			if len(b.Local) == b.MessageQueue-1 {
+				text = text + " <message clipped>"
+			}
+			b.Local <- config.Message{Text: text, Username: msg.Username, Channel: msg.Channel, Event: msg.Event}
+		} else {
+			b.Log.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
+		}
+	}
+	return "", nil
+}
+
+func (b *Birc) doSend() {
+	rate := time.Millisecond * time.Duration(b.MessageDelay)
+	throttle := time.NewTicker(rate)
+	for msg := range b.Local {
+		<-throttle.C
+		username := msg.Username
+		if b.GetBool("Colornicks") {
+			checksum := crc32.ChecksumIEEE([]byte(msg.Username))
+			colorCode := checksum%14 + 2 // quick fix - prevent white or black color codes
+			username = fmt.Sprintf("\x03%02d%s\x0F", colorCode, msg.Username)
+		}
+		if msg.Event == config.EVENT_USER_ACTION {
+			b.i.Cmd.Action(msg.Channel, username+msg.Text)
+		} else {
+			b.Log.Debugf("Sending to channel %s", msg.Channel)
+			b.i.Cmd.Message(msg.Channel, username+msg.Text)
+		}
+	}
+}
+
+func (b *Birc) endNames(client *girc.Client, event girc.Event) {
+	channel := event.Params[1]
+	sort.Strings(b.names[channel])
+	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
+	continued := false
+	for len(b.names[channel]) > maxNamesPerPost {
+		b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel][0:maxNamesPerPost], continued),
+			Channel: channel, Account: b.Account}
+		b.names[channel] = b.names[channel][maxNamesPerPost:]
+		continued = true
+	}
+	b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel], continued),
+		Channel: channel, Account: b.Account}
+	b.names[channel] = nil
+	b.i.Handlers.Clear(girc.RPL_NAMREPLY)
+	b.i.Handlers.Clear(girc.RPL_ENDOFNAMES)
+}
+
+func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
+	b.Log.Debug("Registering callbacks")
+	i := b.i
+	b.Nick = event.Params[0]
+
+	i.Handlers.Add(girc.RPL_ENDOFMOTD, b.handleOtherAuth)
+	i.Handlers.Add("PRIVMSG", b.handlePrivMsg)
+	i.Handlers.Add("CTCP_ACTION", b.handlePrivMsg)
+	i.Handlers.Add(girc.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
+	i.Handlers.Add(girc.NOTICE, b.handleNotice)
+	i.Handlers.Add("JOIN", b.handleJoinPart)
+	i.Handlers.Add("PART", b.handleJoinPart)
+	i.Handlers.Add("QUIT", b.handleJoinPart)
+	i.Handlers.Add("KICK", b.handleJoinPart)
+	// we are now fully connected
+	b.connected <- struct{}{}
+}
+
+func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
+	if len(event.Params) == 0 {
+		b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
+		return
+	}
+	channel := strings.ToLower(event.Params[0])
+	if event.Command == "KICK" && event.Params[1] == b.Nick {
+		b.Log.Infof("Got kicked from %s by %s", channel, event.Source.Name)
+		time.Sleep(time.Duration(b.GetInt("RejoinDelay")) * time.Second)
+		b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: channel, Account: b.Account, Event: config.EVENT_REJOIN_CHANNELS}
+		return
+	}
+	if event.Command == "QUIT" {
+		if event.Source.Name == b.Nick && strings.Contains(event.Trailing, "Ping timeout") {
+			b.Log.Infof("%s reconnecting ..", b.Account)
+			b.Remote <- config.Message{Username: "system", Text: "reconnect", Channel: channel, Account: b.Account, Event: config.EVENT_FAILURE}
+			return
+		}
+	}
+	if event.Source.Name != b.Nick {
+		if b.GetBool("nosendjoinpart") {
+			return
+		}
+		b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
+		msg := config.Message{Username: "system", Text: event.Source.Name + " " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EVENT_JOIN_LEAVE}
+		b.Log.Debugf("<= Message is %#v", msg)
+		b.Remote <- msg
+		return
+	}
+	b.Log.Debugf("handle %#v", event)
+}
+
+func (b *Birc) handleNotice(client *girc.Client, event girc.Event) {
+	if strings.Contains(event.String(), "This nickname is registered") && event.Source.Name == b.GetString("NickServNick") {
+		b.Log.Debugf("Sending identify to nickserv %s", b.GetString("NickServNick"))
+		b.i.Cmd.Message(b.GetString("NickServNick"), "IDENTIFY "+b.GetString("NickServPassword"))
+	} else {
+		b.handlePrivMsg(client, event)
+	}
+}
+
+func (b *Birc) handleOther(client *girc.Client, event girc.Event) {
+	if b.GetInt("DebugLevel") == 1 {
+		if event.Command != "CLIENT_STATE_UPDATED" &&
+			event.Command != "CLIENT_GENERAL_UPDATED" {
+			b.Log.Debugf("%#v", event.String())
+		}
+		return
+	}
+	switch event.Command {
+	case "372", "375", "376", "250", "251", "252", "253", "254", "255", "265", "266", "002", "003", "004", "005":
+		return
+	}
+	b.Log.Debugf("%#v", event.String())
+}
+
+func (b *Birc) handleOtherAuth(client *girc.Client, event girc.Event) {
+	if strings.EqualFold(b.GetString("NickServNick"), "Q@CServe.quakenet.org") {
+		b.Log.Debugf("Authenticating %s against %s", b.GetString("NickServUsername"), b.GetString("NickServNick"))
+		b.i.Cmd.Message(b.GetString("NickServNick"), "AUTH "+b.GetString("NickServUsername")+" "+b.GetString("NickServPassword"))
+	}
+}
+
+func (b *Birc) skipPrivMsg(event girc.Event) bool {
+	// Our nick can be changed
+	b.Nick = b.i.GetNick()
+
+	// freenode doesn't send 001 as first reply
+	if event.Command == "NOTICE" {
+		return true
+	}
+	// don't forward queries to the bot
+	if event.Params[0] == b.Nick {
+		return true
+	}
+	// don't forward message from ourself
+	if event.Source.Name == b.Nick {
+		return true
+	}
+	return false
+}
+
+func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
+	if b.skipPrivMsg(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)
+
+	// set action event
+	if event.IsAction() {
+		rmsg.Event = config.EVENT_USER_ACTION
+	}
+
+	// strip action, we made an event if it was an action
+	rmsg.Text += event.StripAction()
+
+	// strip IRC colors
+	re := regexp.MustCompile(`\x03(?:\d{1,2}(?:,\d{1,2})?)?|[[:cntrl:]]`)
+	rmsg.Text = re.ReplaceAllString(rmsg.Text, "")
+
+	// start detecting the charset
+	var r io.Reader
+	var err error
+	mycharset := b.GetString("Charset")
+	if mycharset == "" {
+		// detect what were sending so that we convert it to utf-8
+		detector := chardet.NewTextDetector()
+		result, err := detector.DetectBest([]byte(rmsg.Text))
+		if err != nil {
+			b.Log.Infof("detection failed for rmsg.Text: %#v", rmsg.Text)
+			return
+		}
+		b.Log.Debugf("detected %s confidence %#v", result.Charset, result.Confidence)
+		mycharset = result.Charset
+		// if we're not sure, just pick ISO-8859-1
+		if result.Confidence < 80 {
+			mycharset = "ISO-8859-1"
+		}
+	}
+	switch mycharset {
+	case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
+		rmsg.Text = ic.ConvertString("utf-8", b.GetString("Charset"), rmsg.Text)
+	default:
+		r, err = charset.NewReader(mycharset, strings.NewReader(rmsg.Text))
+		if err != nil {
+			b.Log.Errorf("charset to utf-8 conversion failed: %s", err)
+			return
+		}
+		output, _ := ioutil.ReadAll(r)
+		rmsg.Text = string(output)
+	}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", event.Params[0], b.Account)
+	b.Remote <- rmsg
+}
+
+func (b *Birc) handleTopicWhoTime(client *girc.Client, event girc.Event) {
+	parts := strings.Split(event.Params[2], "!")
+	t, err := strconv.ParseInt(event.Params[3], 10, 64)
+	if err != nil {
+		b.Log.Errorf("Invalid time stamp: %s", event.Params[3])
+	}
+	user := parts[0]
+	if len(parts) > 1 {
+		user += " [" + parts[1] + "]"
+	}
+	b.Log.Debugf("%s: Topic set by %s [%s]", event.Command, user, time.Unix(t, 0))
+}
+
+func (b *Birc) nicksPerRow() int {
+	return 4
+}
+
+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), " ")...)
+}
+
+func (b *Birc) formatnicks(nicks []string, continued bool) string {
+	return plainformatter(nicks, b.nicksPerRow())
+}

bridge/matrix/matrix.go

@@ -0,0 +1,312 @@
+package bmatrix
+
+import (
+	"bytes"
+	"fmt"
+	"mime"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	matrix "github.com/matterbridge/gomatrix"
+)
+
+type Bmatrix struct {
+	mc      *matrix.Client
+	UserID  string
+	RoomMap map[string]string
+	sync.RWMutex
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmatrix{Config: cfg}
+	b.RoomMap = make(map[string]string)
+	return b
+}
+
+func (b *Bmatrix) Connect() error {
+	var err error
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	b.mc, err = matrix.NewClient(b.GetString("Server"), "", "")
+	if err != nil {
+		return err
+	}
+	resp, err := b.mc.Login(&matrix.ReqLogin{
+		Type:     "m.login.password",
+		User:     b.GetString("Login"),
+		Password: b.GetString("Password"),
+	})
+	if err != nil {
+		return err
+	}
+	b.mc.SetCredentials(resp.UserID, resp.AccessToken)
+	b.UserID = resp.UserID
+	b.Log.Info("Connection succeeded")
+	go b.handlematrix()
+	return nil
+}
+
+func (b *Bmatrix) Disconnect() error {
+	return nil
+}
+
+func (b *Bmatrix) JoinChannel(channel config.ChannelInfo) error {
+	resp, err := b.mc.JoinRoom(channel.Name, "", nil)
+	if err != nil {
+		return err
+	}
+	b.Lock()
+	b.RoomMap[resp.RoomID] = channel.Name
+	b.Unlock()
+	return err
+}
+
+func (b *Bmatrix) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	channel := b.getRoomID(msg.Channel)
+	b.Log.Debugf("Channel %s maps to channel id %s", msg.Channel, channel)
+
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		resp, err := b.mc.SendMessageEvent(channel, "m.room.message",
+			matrix.TextMessage{"m.emote", msg.Username + msg.Text})
+		if err != nil {
+			return "", err
+		}
+		return resp.EventID, err
+	}
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		resp, err := b.mc.RedactEvent(channel, msg.ID, &matrix.ReqRedact{})
+		if err != nil {
+			return "", err
+		}
+		return resp.EventID, err
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.mc.SendText(channel, rmsg.Username+rmsg.Text)
+		}
+		// check if we have files to upload (from slack, telegram or mattermost)
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&msg, channel)
+		}
+	}
+
+	// Edit message if we have an ID
+	// matrix has no editing support
+
+	// Post normal message
+	resp, err := b.mc.SendText(channel, msg.Username+msg.Text)
+	if err != nil {
+		return "", err
+	}
+	return resp.EventID, err
+}
+
+func (b *Bmatrix) getRoomID(channel string) string {
+	b.RLock()
+	defer b.RUnlock()
+	for ID, name := range b.RoomMap {
+		if name == channel {
+			return ID
+		}
+	}
+	return ""
+}
+
+func (b *Bmatrix) handlematrix() error {
+	syncer := b.mc.Syncer.(*matrix.DefaultSyncer)
+	syncer.OnEventType("m.room.redaction", b.handleEvent)
+	syncer.OnEventType("m.room.message", b.handleEvent)
+	go func() {
+		for {
+			if err := b.mc.Sync(); err != nil {
+				b.Log.Println("Sync() returned ", err)
+			}
+		}
+	}()
+	return nil
+}
+
+func (b *Bmatrix) handleEvent(ev *matrix.Event) {
+	b.Log.Debugf("== Receiving event: %#v", ev)
+	if ev.Sender != b.UserID {
+		b.RLock()
+		channel, ok := b.RoomMap[ev.RoomID]
+		b.RUnlock()
+		if !ok {
+			b.Log.Debugf("Unknown room %s", ev.RoomID)
+			return
+		}
+
+		// TODO download avatar
+
+		// Create our message
+		rmsg := config.Message{Username: ev.Sender[1:], Channel: channel, Account: b.Account, UserID: ev.Sender, ID: ev.ID}
+
+		// Text must be a string
+		if rmsg.Text, ok = ev.Content["body"].(string); !ok {
+			b.Log.Errorf("Content[body] wasn't a %T ?", rmsg.Text)
+			return
+		}
+
+		// Remove homeserver suffix if configured
+		if b.GetBool("NoHomeServerSuffix") {
+			re := regexp.MustCompile("(.*?):.*")
+			rmsg.Username = re.ReplaceAllString(rmsg.Username, `$1`)
+		}
+
+		// Delete event
+		if ev.Type == "m.room.redaction" {
+			rmsg.Event = config.EVENT_MSG_DELETE
+			rmsg.ID = ev.Redacts
+			rmsg.Text = config.EVENT_MSG_DELETE
+			b.Remote <- rmsg
+			return
+		}
+
+		// Do we have a /me action
+		if ev.Content["msgtype"].(string) == "m.emote" {
+			rmsg.Event = config.EVENT_USER_ACTION
+		}
+
+		// Do we have attachments
+		if b.containsAttachment(ev.Content) {
+			err := b.handleDownloadFile(&rmsg, ev.Content)
+			if err != nil {
+				b.Log.Errorf("download failed: %#v", err)
+			}
+		}
+
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", ev.Sender, b.Account)
+		b.Remote <- rmsg
+	}
+}
+
+// handleDownloadFile handles file download
+func (b *Bmatrix) handleDownloadFile(rmsg *config.Message, content map[string]interface{}) error {
+	var (
+		ok                        bool
+		url, name, msgtype, mtype string
+		info                      map[string]interface{}
+		size                      float64
+	)
+
+	rmsg.Extra = make(map[string][]interface{})
+	if url, ok = content["url"].(string); !ok {
+		return fmt.Errorf("url isn't a %T", url)
+	}
+	url = strings.Replace(url, "mxc://", b.GetString("Server")+"/_matrix/media/v1/download/", -1)
+
+	if info, ok = content["info"].(map[string]interface{}); !ok {
+		return fmt.Errorf("info isn't a %T", info)
+	}
+	if size, ok = info["size"].(float64); !ok {
+		return fmt.Errorf("size isn't a %T", size)
+	}
+	if name, ok = content["body"].(string); !ok {
+		return fmt.Errorf("name isn't a %T", name)
+	}
+	if msgtype, ok = content["msgtype"].(string); !ok {
+		return fmt.Errorf("msgtype isn't a %T", msgtype)
+	}
+	if mtype, ok = info["mimetype"].(string); !ok {
+		return fmt.Errorf("mtype isn't a %T", mtype)
+	}
+
+	// check if we have an image uploaded without extension
+	if !strings.Contains(name, ".") {
+		if msgtype == "m.image" {
+			mext, _ := mime.ExtensionsByType(mtype)
+			if len(mext) > 0 {
+				name = name + mext[0]
+			}
+		} else {
+			// just a default .png extension if we don't have mime info
+			name = name + ".png"
+		}
+	}
+
+	// check if the size is ok
+	err := helper.HandleDownloadSize(b.Log, rmsg, name, int64(size), b.General)
+	if err != nil {
+		return err
+	}
+	// actually download the file
+	data, err := helper.DownloadFile(url)
+	if err != nil {
+		return fmt.Errorf("download %s failed %#v", url, err)
+	}
+	// add the downloaded data to the message
+	helper.HandleDownloadData(b.Log, rmsg, name, "", url, data, b.General)
+	return nil
+}
+
+// handleUploadFile handles native upload of files
+func (b *Bmatrix) handleUploadFile(msg *config.Message, channel string) (string, error) {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		content := bytes.NewReader(*fi.Data)
+		sp := strings.Split(fi.Name, ".")
+		mtype := mime.TypeByExtension("." + sp[len(sp)-1])
+		if strings.Contains(mtype, "image") ||
+			strings.Contains(mtype, "video") {
+			if fi.Comment != "" {
+				_, err := b.mc.SendText(channel, msg.Username+fi.Comment)
+				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)))
+			if err != nil {
+				b.Log.Errorf("file upload failed: %#v", err)
+				continue
+			}
+			if strings.Contains(mtype, "video") {
+				b.Log.Debugf("sendVideo %s", res.ContentURI)
+				_, err = b.mc.SendVideo(channel, fi.Name, res.ContentURI)
+				if err != nil {
+					b.Log.Errorf("sendVideo failed: %#v", err)
+				}
+			}
+			if strings.Contains(mtype, "image") {
+				b.Log.Debugf("sendImage %s", res.ContentURI)
+				_, err = b.mc.SendImage(channel, fi.Name, res.ContentURI)
+				if err != nil {
+					b.Log.Errorf("sendImage failed: %#v", err)
+				}
+			}
+			b.Log.Debugf("result: %#v", res)
+		}
+	}
+	return "", nil
+}
+
+// skipMessages returns true if this message should not be handled
+func (b *Bmatrix) containsAttachment(content map[string]interface{}) bool {
+	// Skip empty messages
+	if content["msgtype"] == nil {
+		return false
+	}
+
+	// Only allow image,video or file msgtypes
+	if !(content["msgtype"].(string) == "m.image" ||
+		content["msgtype"].(string) == "m.video" ||
+		content["msgtype"].(string) == "m.file") {
+		return false
+	}
+	return true
+}

bridge/mattermost/mattermost.go

@@ -0,0 +1,467 @@
+package bmattermost
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/matterclient"
+	"github.com/42wim/matterbridge/matterhook"
+	"github.com/rs/xid"
+)
+
+type Bmattermost struct {
+	mh     *matterhook.Client
+	mc     *matterclient.MMClient
+	uuid   string
+	TeamID string
+	*bridge.Config
+	avatarMap map[string]string
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmattermost{Config: cfg, avatarMap: make(map[string]string)}
+	b.uuid = xid.New().String()
+	return b
+}
+
+func (b *Bmattermost) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bmattermost) Connect() error {
+	if b.GetString("WebhookBindAddress") != "" {
+		if 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"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		} else if b.GetString("Token") != "" {
+			b.Log.Info("Connecting using token (sending)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+		} else if b.GetString("Login") != "" {
+			b.Log.Info("Connecting using login/password (sending)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+		} else {
+			b.Log.Info("Connecting using webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.GetString("WebhookURL"),
+				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		}
+		go b.handleMatter()
+		return nil
+	}
+	if b.GetString("WebhookURL") != "" {
+		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("Token") != "" {
+			b.Log.Info("Connecting using token (receiving)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+			go b.handleMatter()
+		} else if b.GetString("Login") != "" {
+			b.Log.Info("Connecting using login/password (receiving)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+			go b.handleMatter()
+		}
+		return nil
+	} else if b.GetString("Token") != "" {
+		b.Log.Info("Connecting using token (sending and receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+		go b.handleMatter()
+	} else if b.GetString("Login") != "" {
+		b.Log.Info("Connecting using login/password (sending and receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+		go b.handleMatter()
+	}
+	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" && b.GetString("Login") == "" && b.GetString("Token") == "" {
+		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Token/Login/Password/Server/Team configured")
+	}
+	return nil
+}
+
+func (b *Bmattermost) Disconnect() error {
+	return nil
+}
+
+func (b *Bmattermost) JoinChannel(channel config.ChannelInfo) error {
+	// we can only join channels using the API
+	if b.GetString("WebhookURL") == "" && b.GetString("WebhookBindAddress") == "" {
+		id := b.mc.GetChannelId(channel.Name, "")
+		if id == "" {
+			return fmt.Errorf("Could not find channel ID for channel %s", channel.Name)
+		}
+		return b.mc.JoinChannel(id)
+	}
+	return nil
+}
+
+func (b *Bmattermost) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "*" + msg.Text + "*"
+	}
+
+	// map the file SHA to our user (caches the avatar)
+	if msg.Event == config.EVENT_AVATAR_DOWNLOAD {
+		return b.cacheAvatar(&msg)
+	}
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return b.sendWebhook(msg)
+	}
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		return msg.ID, b.mc.DeleteMessage(msg.ID)
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.mc.PostMessage(b.mc.GetChannelId(rmsg.Channel, ""), rmsg.Username+rmsg.Text)
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&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 b.mc.EditMessage(msg.ID, msg.Text)
+	}
+
+	// Post normal message
+	return b.mc.PostMessage(b.mc.GetChannelId(msg.Channel, ""), msg.Text)
+}
+
+func (b *Bmattermost) handleMatter() {
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleMatterHook(messages)
+	} else {
+		if b.GetString("Token") != "" {
+			b.Log.Debugf("Choosing token based receiving")
+		} else {
+			b.Log.Debugf("Choosing login/password based receiving")
+		}
+		go b.handleMatterClient(messages)
+	}
+	var ok bool
+	for message := range messages {
+		message.Avatar = helper.GetAvatar(b.avatarMap, message.UserID, b.General)
+		message.Account = b.Account
+		message.Text, ok = b.replaceAction(message.Text)
+		if ok {
+			message.Event = config.EVENT_USER_ACTION
+		}
+		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 *Bmattermost) handleMatterClient(messages chan *config.Message) {
+	for message := range b.mc.MessageChan {
+		b.Log.Debugf("%#v", message.Raw.Data)
+
+		if b.skipMessage(message) {
+			b.Log.Debugf("Skipped message: %#v", message)
+			continue
+		}
+
+		// only download avatars if we have a place to upload them (configured mediaserver)
+		if b.General.MediaServerUpload != "" || b.General.MediaDownloadPath != "" {
+			b.handleDownloadAvatar(message.UserID, message.Channel)
+		}
+
+		b.Log.Debugf("== Receiving event %#v", message)
+
+		rmsg := &config.Message{Username: message.Username, UserID: message.UserID, Channel: message.Channel, Text: message.Text, ID: message.Post.Id, Extra: make(map[string][]interface{})}
+
+		// handle mattermost post properties (override username and attachments)
+		props := message.Post.Props
+		if props != nil {
+			if _, ok := props["override_username"].(string); ok {
+				rmsg.Username = props["override_username"].(string)
+			}
+			if _, ok := props["attachments"].([]interface{}); ok {
+				rmsg.Extra["attachments"] = props["attachments"].([]interface{})
+				if rmsg.Text == "" {
+					for _, attachment := range rmsg.Extra["attachments"] {
+						attach := attachment.(map[string]interface{})
+						if attach["text"].(string) != "" {
+							rmsg.Text += attach["text"].(string)
+							continue
+						}
+						if attach["fallback"].(string) != "" {
+							rmsg.Text += attach["fallback"].(string)
+						}
+					}
+				}
+			}
+		}
+
+		// create a text for bridges that don't support native editing
+		if message.Raw.Event == "post_edited" && !b.GetBool("EditDisable") {
+			rmsg.Text = message.Text + b.GetString("EditSuffix")
+		}
+
+		if message.Raw.Event == "post_deleted" {
+			rmsg.Event = config.EVENT_MSG_DELETE
+		}
+
+		if len(message.Post.FileIds) > 0 {
+			for _, id := range message.Post.FileIds {
+				err := b.handleDownloadFile(rmsg, id)
+				if err != nil {
+					b.Log.Errorf("download failed: %s", err)
+				}
+			}
+		}
+		// Use nickname instead of username if defined
+		if nick := b.mc.GetNickName(rmsg.UserID); nick != "" {
+			rmsg.Username = nick
+		}
+
+		messages <- rmsg
+	}
+}
+
+func (b *Bmattermost) handleMatterHook(messages chan *config.Message) {
+	for {
+		message := b.mh.Receive()
+		b.Log.Debugf("Receiving from matterhook %#v", message)
+		messages <- &config.Message{UserID: message.UserID, Username: message.UserName, Text: message.Text, Channel: message.ChannelName}
+	}
+}
+
+func (b *Bmattermost) apiLogin() error {
+	password := b.GetString("Password")
+	if b.GetString("Token") != "" {
+		password = "MMAUTHTOKEN=" + b.GetString("Token")
+	}
+
+	b.mc = matterclient.New(b.GetString("Login"), password, b.GetString("Team"), b.GetString("Server"))
+	if b.GetBool("debug") {
+		b.mc.SetLogLevel("debug")
+	}
+	b.mc.SkipTLSVerify = b.GetBool("SkipTLSVerify")
+	b.mc.NoTLS = b.GetBool("NoTLS")
+	b.Log.Infof("Connecting %s (team: %s) on %s", b.GetString("Login"), b.GetString("Team"), b.GetString("Server"))
+	err := b.mc.Login()
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	b.TeamID = b.mc.GetTeamId()
+	go b.mc.WsReceiver()
+	go b.mc.StatusLoop()
+	return nil
+}
+
+// replaceAction replace the message with the correct action (/me) code
+func (b *Bmattermost) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "*") && strings.HasSuffix(text, "*") {
+		return strings.Replace(text, "*", "", -1), true
+	}
+	return text, false
+}
+
+func (b *Bmattermost) cacheAvatar(msg *config.Message) (string, error) {
+	fi := msg.Extra["file"][0].(config.FileInfo)
+	/* if we have a sha we have successfully uploaded the file to the media server,
+	so we can now cache the sha */
+	if fi.SHA != "" {
+		b.Log.Debugf("Added %s to %s in avatarMap", fi.SHA, msg.UserID)
+		b.avatarMap[msg.UserID] = fi.SHA
+	}
+	return "", nil
+}
+
+// handleDownloadAvatar downloads the avatar of userid from channel
+// sends a EVENT_AVATAR_DOWNLOAD message to the gateway if successful.
+// logs an error message if it fails
+func (b *Bmattermost) handleDownloadAvatar(userid string, channel string) {
+	rmsg := config.Message{Username: "system", Text: "avatar", Channel: channel, Account: b.Account, UserID: userid, Event: config.EVENT_AVATAR_DOWNLOAD, Extra: make(map[string][]interface{})}
+	if _, ok := b.avatarMap[userid]; !ok {
+		data, resp := b.mc.Client.GetProfileImage(userid, "")
+		if resp.Error != nil {
+			b.Log.Errorf("ProfileImage download failed for %#v %s", userid, resp.Error)
+			return
+		}
+		err := helper.HandleDownloadSize(b.Log, &rmsg, userid+".png", int64(len(data)), b.General)
+		if err != nil {
+			b.Log.Error(err)
+			return
+		}
+		helper.HandleDownloadData(b.Log, &rmsg, userid+".png", rmsg.Text, "", &data, b.General)
+		b.Remote <- rmsg
+	}
+}
+
+// handleDownloadFile handles file download
+func (b *Bmattermost) handleDownloadFile(rmsg *config.Message, id string) error {
+	url, _ := b.mc.Client.GetFileLink(id)
+	finfo, resp := b.mc.Client.GetFileInfo(id)
+	if resp.Error != nil {
+		return resp.Error
+	}
+	err := helper.HandleDownloadSize(b.Log, rmsg, finfo.Name, finfo.Size, b.General)
+	if err != nil {
+		return err
+	}
+	data, resp := b.mc.Client.DownloadFile(id, true)
+	if resp.Error != nil {
+		return resp.Error
+	}
+	helper.HandleDownloadData(b.Log, rmsg, finfo.Name, rmsg.Text, url, &data, b.General)
+	return nil
+}
+
+// handleUploadFile handles native upload of files
+func (b *Bmattermost) handleUploadFile(msg *config.Message) (string, error) {
+	var err error
+	var res, id string
+	channelID := b.mc.GetChannelId(msg.Channel, "")
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		id, err = b.mc.UploadFile(*fi.Data, channelID, fi.Name)
+		if err != nil {
+			return "", err
+		}
+		msg.Text = fi.Comment
+		if b.GetBool("PrefixMessagesWithNick") {
+			msg.Text = msg.Username + msg.Text
+		}
+		res, err = b.mc.PostMessageWithFiles(channelID, msg.Text, []string{id})
+	}
+	return res, err
+}
+
+// sendWebhook uses the configured WebhookURL to send the message
+func (b *Bmattermost) sendWebhook(msg config.Message) (string, 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) {
+			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{})}
+			matterMessage.Props["matterbridge_"+b.uuid] = true
+			b.mh.Send(matterMessage)
+		}
+
+		// 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, Props: make(map[string]interface{})}
+	if msg.Avatar != "" {
+		matterMessage.IconURL = msg.Avatar
+	}
+	matterMessage.Props["matterbridge_"+b.uuid] = true
+	err := b.mh.Send(matterMessage)
+	if err != nil {
+		b.Log.Info(err)
+		return "", err
+	}
+	return "", nil
+}
+
+// skipMessages returns true if this message should not be handled
+func (b *Bmattermost) skipMessage(message *matterclient.Message) bool {
+	// Handle join/leave
+	if message.Type == "system_join_leave" ||
+		message.Type == "system_join_channel" ||
+		message.Type == "system_leave_channel" {
+		if b.GetBool("nosendjoinpart") {
+			return true
+		}
+		b.Log.Debugf("Sending JOIN_LEAVE event from %s to gateway", b.Account)
+		b.Remote <- config.Message{Username: "system", Text: message.Text, Channel: message.Channel, Account: b.Account, Event: config.EVENT_JOIN_LEAVE}
+		return true
+	}
+
+	// Handle edited messages
+	if (message.Raw.Event == "post_edited") && b.GetBool("EditDisable") {
+		return true
+	}
+
+	// Ignore messages sent from matterbridge
+	if message.Post.Props != nil {
+		if _, ok := message.Post.Props["matterbridge_"+b.uuid].(bool); ok {
+			b.Log.Debugf("sent by matterbridge, ignoring")
+			return true
+		}
+	}
+
+	// Ignore messages sent from a user logged in as the bot
+	if b.mc.User.Username == message.Username {
+		return true
+	}
+
+	// if the message has reactions don't repost it (for now, until we can correlate reaction with message)
+	if message.Post.HasReactions {
+		return true
+	}
+
+	// ignore messages from other teams than ours
+	if message.Raw.Data["team_id"].(string) != b.TeamID {
+		return true
+	}
+
+	// only handle posted, edited or deleted events
+	if !(message.Raw.Event == "posted" || message.Raw.Event == "post_edited" || message.Raw.Event == "post_deleted") {
+		return true
+	}
+	return false
+}

bridge/rocketchat/rocketchat.go

@@ -0,0 +1,95 @@
+package brocketchat
+
+import (
+	"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"
+)
+
+type MMhook struct {
+	mh *matterhook.Client
+	rh *rockethook.Client
+}
+
+type Brocketchat struct {
+	MMhook
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Brocketchat{Config: cfg}
+}
+
+func (b *Brocketchat) Command(cmd string) string {
+	return ""
+}
+
+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()
+	return nil
+}
+
+func (b *Brocketchat) Disconnect() error {
+	return nil
+
+}
+
+func (b *Brocketchat) JoinChannel(channel config.ChannelInfo) error {
+	return nil
+}
+
+func (b *Brocketchat) Send(msg config.Message) (string, error) {
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+	b.Log.Debugf("=> Receiving %#v", msg)
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			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
+				}
+			}
+		}
+	}
+
+	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)
+		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}
+	}
+}

bridge/slack/slack.go

@@ -0,0 +1,744 @@
+package bslack
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"html"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/matterhook"
+	"github.com/hashicorp/golang-lru"
+	"github.com/nlopes/slack"
+	"github.com/rs/xid"
+)
+
+type Bslack struct {
+	mh           *matterhook.Client
+	sc           *slack.Client
+	rtm          *slack.RTM
+	Users        []slack.User
+	Usergroups   []slack.UserGroup
+	si           *slack.Info
+	channels     []slack.Channel
+	cache        *lru.Cache
+	UseChannelID bool
+	uuid         string
+	*bridge.Config
+	sync.RWMutex
+}
+
+const messageDeleted = "message_deleted"
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bslack{Config: cfg, uuid: xid.New().String()}
+	b.cache, _ = lru.New(5000)
+	return b
+}
+
+func (b *Bslack) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bslack) Connect() error {
+	b.RLock()
+	defer b.RUnlock()
+	if b.GetString("WebhookBindAddress") != "" {
+		if 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"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		} else if b.GetString("Token") != "" {
+			b.Log.Info("Connecting using token (sending)")
+			b.sc = slack.New(b.GetString("Token"))
+			b.rtm = b.sc.NewRTM()
+			go b.rtm.ManageConnection()
+			b.Log.Info("Connecting using webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.GetString("WebhookURL"),
+				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		} else {
+			b.Log.Info("Connecting using webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.GetString("WebhookURL"),
+				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		}
+		go b.handleSlack()
+		return nil
+	}
+	if b.GetString("WebhookURL") != "" {
+		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("Token") != "" {
+			b.Log.Info("Connecting using token (receiving)")
+			b.sc = slack.New(b.GetString("Token"))
+			b.rtm = b.sc.NewRTM()
+			go b.rtm.ManageConnection()
+			go b.handleSlack()
+		}
+	} else if b.GetString("Token") != "" {
+		b.Log.Info("Connecting using token (sending and receiving)")
+		b.sc = slack.New(b.GetString("Token"))
+		b.rtm = b.sc.NewRTM()
+		go b.rtm.ManageConnection()
+		go b.handleSlack()
+	}
+	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" && b.GetString("Token") == "" {
+		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Token configured")
+	}
+	return nil
+}
+
+func (b *Bslack) Disconnect() error {
+	return b.rtm.Disconnect()
+}
+
+func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
+	// use ID:channelid and resolve it to the actual name
+	idcheck := strings.Split(channel.Name, "ID:")
+	if len(idcheck) > 1 {
+		b.UseChannelID = true
+		ch, err := b.sc.GetChannelInfo(idcheck[1])
+		if err != nil {
+			return err
+		}
+		channel.Name = ch.Name
+		if err != nil {
+			return err
+		}
+	}
+
+	// we can only join channels using the API
+	if b.sc != nil {
+		if strings.HasPrefix(b.GetString("Token"), "xoxb") {
+			// TODO check if bot has already joined channel
+			return nil
+		}
+		_, err := b.sc.JoinChannel(channel.Name)
+		if err != nil {
+			switch err.Error() {
+			case "name_taken", "restricted_action":
+			case "default":
+				{
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (b *Bslack) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
+	}
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return b.sendWebhook(msg)
+	}
+
+	channelID := b.getChannelID(msg.Channel)
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		// some protocols echo deletes, but with empty ID
+		if msg.ID == "" {
+			return "", nil
+		}
+		// we get a "slack <ID>", split it
+		ts := strings.Fields(msg.ID)
+		_, _, err := b.sc.DeleteMessage(channelID, ts[1])
+		if err != nil {
+			return msg.ID, err
+		}
+		return msg.ID, nil
+	}
+
+	// Prepend nick if configured
+	if b.GetBool("PrefixMessagesWithNick") {
+		msg.Text = msg.Username + msg.Text
+	}
+
+	// Edit message if we have an ID
+	if msg.ID != "" {
+		ts := strings.Fields(msg.ID)
+		_, _, _, err := b.sc.UpdateMessage(channelID, ts[1], msg.Text)
+		if err != nil {
+			return msg.ID, err
+		}
+		return msg.ID, nil
+	}
+
+	// create slack new post parameters
+	np := slack.NewPostMessageParameters()
+	if b.GetBool("PrefixMessagesWithNick") {
+		np.AsUser = true
+	}
+	np.Username = msg.Username
+	np.LinkNames = 1 // replace mentions
+	np.IconURL = config.GetIconURL(&msg, b.GetString("iconurl"))
+	if msg.Avatar != "" {
+		np.IconURL = msg.Avatar
+	}
+	// add a callback ID so we can see we created it
+	np.Attachments = append(np.Attachments, slack.Attachment{CallbackID: "matterbridge_" + b.uuid})
+	// add file attachments
+	np.Attachments = append(np.Attachments, b.createAttach(msg.Extra)...)
+	// add slack attachments (from another slack bridge)
+	if len(msg.Extra["slack_attachment"]) > 0 {
+		for _, attach := range msg.Extra["slack_attachment"] {
+			np.Attachments = append(np.Attachments, attach.([]slack.Attachment)...)
+		}
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.sc.PostMessage(channelID, rmsg.Username+rmsg.Text, np)
+		}
+		// check if we have files to upload (from slack, telegram or mattermost)
+		if len(msg.Extra["file"]) > 0 {
+			b.handleUploadFile(&msg, channelID)
+		}
+	}
+
+	// Post normal message
+	_, id, err := b.sc.PostMessage(channelID, msg.Text, np)
+	if err != nil {
+		return "", err
+	}
+	return "slack " + id, nil
+}
+
+func (b *Bslack) Reload(cfg *bridge.Config) (string, error) {
+	return "", nil
+}
+
+func (b *Bslack) getAvatar(userid string) string {
+	var avatar string
+	if b.Users != nil {
+		for _, u := range b.Users {
+			if userid == u.ID {
+				return u.Profile.Image48
+			}
+		}
+	}
+	return avatar
+}
+
+/*
+func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
+	if b.channels == nil {
+		return nil, fmt.Errorf("%s: channel %s not found (no channels found)", b.Account, name)
+	}
+	for _, channel := range b.channels {
+		if channel.Name == name {
+			return &channel, nil
+		}
+	}
+	return nil, fmt.Errorf("%s: channel %s not found", b.Account, name)
+}
+*/
+
+func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
+	if b.channels == nil {
+		return nil, fmt.Errorf("%s: channel %s not found (no channels found)", b.Account, ID)
+	}
+	for _, channel := range b.channels {
+		if channel.ID == ID {
+			return &channel, nil
+		}
+	}
+	return nil, fmt.Errorf("%s: channel %s not found", b.Account, ID)
+}
+
+func (b *Bslack) handleSlack() {
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleMatterHook(messages)
+	} else {
+		b.Log.Debugf("Choosing token based receiving")
+		go b.handleSlackClient(messages)
+	}
+	time.Sleep(time.Second)
+	b.Log.Debug("Start listening for Slack messages")
+	for message := range messages {
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
+
+		// cleanup the message
+		message.Text = b.replaceMention(message.Text)
+		message.Text = b.replaceVariable(message.Text)
+		message.Text = b.replaceChannel(message.Text)
+		message.Text = b.replaceURL(message.Text)
+		message.Text = html.UnescapeString(message.Text)
+
+		// Add the avatar
+		message.Avatar = b.getAvatar(message.UserID)
+
+		b.Log.Debugf("<= Message is %#v", message)
+		b.Remote <- *message
+	}
+}
+
+func (b *Bslack) handleSlackClient(messages chan *config.Message) {
+	for msg := range b.rtm.IncomingEvents {
+		if msg.Type != "user_typing" && msg.Type != "latency_report" {
+			b.Log.Debugf("== Receiving event %#v", msg.Data)
+		}
+		switch ev := msg.Data.(type) {
+		case *slack.MessageEvent:
+			if b.skipMessageEvent(ev) {
+				b.Log.Debugf("Skipped message: %#v", ev)
+				continue
+			}
+			rmsg, err := b.handleMessageEvent(ev)
+			if err != nil {
+				b.Log.Errorf("%#v", err)
+				continue
+			}
+			messages <- rmsg
+		case *slack.OutgoingErrorEvent:
+			b.Log.Debugf("%#v", ev.Error())
+		case *slack.ChannelJoinedEvent:
+			b.Users, _ = b.sc.GetUsers()
+			b.Usergroups, _ = b.sc.GetUserGroups()
+		case *slack.ConnectedEvent:
+			var err error
+			b.channels, _, err = b.sc.GetConversations(&slack.GetConversationsParameters{Limit: 1000, Types: []string{"public_channel,private_channel,mpim,im"}})
+			if err != nil {
+				b.Log.Errorf("Channel list failed: %#v", err)
+			}
+			b.si = ev.Info
+			b.Users, _ = b.sc.GetUsers()
+			b.Usergroups, _ = b.sc.GetUserGroups()
+		case *slack.InvalidAuthEvent:
+			b.Log.Fatalf("Invalid Token %#v", ev)
+		case *slack.ConnectionErrorEvent:
+			b.Log.Errorf("Connection failed %#v %#v", ev.Error(), ev.ErrorObj)
+		default:
+		}
+	}
+}
+
+func (b *Bslack) handleMatterHook(messages chan *config.Message) {
+	for {
+		message := b.mh.Receive()
+		b.Log.Debugf("receiving from matterhook (slack) %#v", message)
+		if message.UserName == "slackbot" {
+			continue
+		}
+		messages <- &config.Message{Username: message.UserName, Text: message.Text, Channel: message.ChannelName}
+	}
+}
+
+func (b *Bslack) userName(id string) string {
+	for _, u := range b.Users {
+		if u.ID == id {
+			if u.Profile.DisplayName != "" {
+				return u.Profile.DisplayName
+			}
+			return u.Name
+		}
+	}
+	return ""
+}
+
+/*
+func (b *Bslack) userGroupName(id string) string {
+	for _, u := range b.Usergroups {
+		if u.ID == id {
+			return u.Name
+		}
+	}
+	return ""
+}
+*/
+
+// @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
+func (b *Bslack) replaceMention(text string) string {
+	results := regexp.MustCompile(`<@([a-zA-Z0-9]+)>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		text = strings.Replace(text, "<@"+r[1]+">", "@"+b.userName(r[1]), -1)
+	}
+	return text
+}
+
+// @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
+func (b *Bslack) replaceChannel(text string) string {
+	results := regexp.MustCompile(`<#[a-zA-Z0-9]+\|(.+?)>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		text = strings.Replace(text, r[0], "#"+r[1], -1)
+	}
+	return text
+}
+
+// @see https://api.slack.com/docs/message-formatting#variables
+func (b *Bslack) replaceVariable(text string) string {
+	results := regexp.MustCompile(`<!((?:subteam\^)?[a-zA-Z0-9]+)(?:\|@?(.+?))?>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		if r[2] != "" {
+			text = strings.Replace(text, r[0], "@"+r[2], -1)
+		} else {
+			text = strings.Replace(text, r[0], "@"+r[1], -1)
+		}
+	}
+	return text
+}
+
+// @see https://api.slack.com/docs/message-formatting#linking_to_urls
+func (b *Bslack) replaceURL(text string) string {
+	results := regexp.MustCompile(`<(.*?)(\|.*?)?>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		if len(strings.TrimSpace(r[2])) == 1 { // A display text separator was found, but the text was blank
+			text = strings.Replace(text, r[0], "", -1)
+		} else {
+			text = strings.Replace(text, r[0], r[1], -1)
+		}
+	}
+	return text
+}
+
+func (b *Bslack) createAttach(extra map[string][]interface{}) []slack.Attachment {
+	var attachs []slack.Attachment
+	for _, v := range extra["attachments"] {
+		entry := v.(map[string]interface{})
+		s := slack.Attachment{}
+		s.Fallback = entry["fallback"].(string)
+		s.Color = entry["color"].(string)
+		s.Pretext = entry["pretext"].(string)
+		s.AuthorName = entry["author_name"].(string)
+		s.AuthorLink = entry["author_link"].(string)
+		s.AuthorIcon = entry["author_icon"].(string)
+		s.Title = entry["title"].(string)
+		s.TitleLink = entry["title_link"].(string)
+		s.Text = entry["text"].(string)
+		s.ImageURL = entry["image_url"].(string)
+		s.ThumbURL = entry["thumb_url"].(string)
+		s.Footer = entry["footer"].(string)
+		s.FooterIcon = entry["footer_icon"].(string)
+		attachs = append(attachs, s)
+	}
+	return attachs
+}
+
+// handleDownloadFile handles file download
+func (b *Bslack) handleDownloadFile(rmsg *config.Message, file *slack.File) error {
+	// if we have a file attached, download it (in memory) and put a pointer to it in msg.Extra
+	// limit to 1MB for now
+	comment := ""
+	results := regexp.MustCompile(`.*?commented: (.*)`).FindAllStringSubmatch(rmsg.Text, -1)
+	if len(results) > 0 {
+		comment = results[0][1]
+	}
+	err := helper.HandleDownloadSize(b.Log, rmsg, file.Name, int64(file.Size), b.General)
+	if err != nil {
+		return err
+	}
+	// actually download the file
+	data, err := helper.DownloadFileAuth(file.URLPrivateDownload, "Bearer "+b.GetString("Token"))
+	if err != nil {
+		return fmt.Errorf("download %s failed %#v", file.URLPrivateDownload, err)
+	}
+	// add the downloaded data to the message
+	helper.HandleDownloadData(b.Log, rmsg, file.Name, comment, file.URLPrivateDownload, data, b.General)
+	return nil
+}
+
+// handleUploadFile handles native upload of files
+func (b *Bslack) handleUploadFile(msg *config.Message, channelID string) (string, error) {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if msg.Text == fi.Comment {
+			msg.Text = ""
+		}
+		/* because the result of the UploadFile is slower than the MessageEvent from slack
+		we can't match on the file ID yet, so we have to match on the filename too
+		*/
+		b.Log.Debugf("Adding file %s to cache %s", fi.Name, time.Now().String())
+		b.cache.Add("filename"+fi.Name, time.Now())
+		res, err := b.sc.UploadFile(slack.FileUploadParameters{
+			Reader:         bytes.NewReader(*fi.Data),
+			Filename:       fi.Name,
+			Channels:       []string{channelID},
+			InitialComment: fi.Comment,
+		})
+		if res.ID != "" {
+			b.Log.Debugf("Adding fileid %s to cache %s", res.ID, time.Now().String())
+			b.cache.Add("file"+res.ID, time.Now())
+		}
+		if err != nil {
+			b.Log.Errorf("uploadfile %#v", err)
+		}
+	}
+	return "", nil
+}
+
+// handleMessageEvent handles the message events
+func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, error) {
+	// update the userlist on a channel_join
+	if ev.SubType == "channel_join" {
+		b.Users, _ = b.sc.GetUsers()
+	}
+
+	// Edit message
+	if !b.GetBool("EditDisable") && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
+		b.Log.Debugf("SubMessage %#v", ev.SubMessage)
+		ev.User = ev.SubMessage.User
+		ev.Text = ev.SubMessage.Text + b.GetString("EditSuffix")
+	}
+
+	// use our own func because rtm.GetChannelInfo doesn't work for private channels
+	channel, err := b.getChannelByID(ev.Channel)
+	if err != nil {
+		return nil, err
+	}
+
+	rmsg := config.Message{Text: ev.Text, Channel: channel.Name, Account: b.Account, ID: "slack " + ev.Timestamp, Extra: make(map[string][]interface{})}
+
+	if b.UseChannelID {
+		rmsg.Channel = "ID:" + channel.ID
+	}
+
+	// find the user id and name
+	if ev.User != "" && ev.SubType != messageDeleted && ev.SubType != "file_comment" {
+		user, err := b.rtm.GetUserInfo(ev.User)
+		if err != nil {
+			return nil, err
+		}
+		rmsg.UserID = user.ID
+		rmsg.Username = user.Name
+		if user.Profile.DisplayName != "" {
+			rmsg.Username = user.Profile.DisplayName
+		}
+	}
+
+	// See if we have some text in the attachments
+	if rmsg.Text == "" {
+		for _, attach := range ev.Attachments {
+			if attach.Text != "" {
+				if attach.Title != "" {
+					rmsg.Text = attach.Title + "\n"
+				}
+				rmsg.Text += attach.Text
+			} else {
+				rmsg.Text = attach.Fallback
+			}
+		}
+	}
+
+	// when using webhookURL we can't check if it's our webhook or not for now
+	if rmsg.Username == "" && ev.BotID != "" && b.GetString("WebhookURL") == "" {
+		bot, err := b.rtm.GetBotInfo(ev.BotID)
+		if err != nil {
+			return nil, err
+		}
+		if bot.Name != "" {
+			rmsg.Username = bot.Name
+			if ev.Username != "" {
+				rmsg.Username = ev.Username
+			}
+			rmsg.UserID = bot.ID
+		}
+
+		// fixes issues with matterircd users
+		if bot.Name == "Slack API Tester" {
+			user, err := b.rtm.GetUserInfo(ev.User)
+			if err != nil {
+				return nil, err
+			}
+			rmsg.UserID = user.ID
+			rmsg.Username = user.Name
+			if user.Profile.DisplayName != "" {
+				rmsg.Username = user.Profile.DisplayName
+			}
+		}
+	}
+
+	// file comments are set by the system (because there is no username given)
+	if ev.SubType == "file_comment" {
+		rmsg.Username = "system"
+	}
+
+	// do we have a /me action
+	if ev.SubType == "me_message" {
+		rmsg.Event = config.EVENT_USER_ACTION
+	}
+
+	// Handle join/leave
+	if ev.SubType == "channel_leave" || ev.SubType == "channel_join" {
+		rmsg.Username = "system"
+		rmsg.Event = config.EVENT_JOIN_LEAVE
+	}
+
+	// edited messages have a submessage, use this timestamp
+	if ev.SubMessage != nil {
+		rmsg.ID = "slack " + ev.SubMessage.Timestamp
+	}
+
+	// deleted message event
+	if ev.SubType == messageDeleted {
+		rmsg.Text = config.EVENT_MSG_DELETE
+		rmsg.Event = config.EVENT_MSG_DELETE
+		rmsg.ID = "slack " + ev.DeletedTimestamp
+	}
+
+	// topic change event
+	if ev.SubType == "channel_topic" || ev.SubType == "channel_purpose" {
+		rmsg.Event = config.EVENT_TOPIC_CHANGE
+	}
+
+	// Only deleted messages can have a empty username and text
+	if (rmsg.Text == "" || rmsg.Username == "") && ev.SubType != messageDeleted && len(ev.Files) == 0 {
+		// this is probably a webhook we couldn't resolve
+		if ev.BotID != "" {
+			return nil, fmt.Errorf("probably an incoming webhook we couldn't resolve (maybe ourselves)")
+		}
+		return nil, fmt.Errorf("empty message and not a deleted message")
+	}
+
+	// save the attachments, so that we can send them to other slack (compatible) bridges
+	if len(ev.Attachments) > 0 {
+		rmsg.Extra["slack_attachment"] = append(rmsg.Extra["slack_attachment"], ev.Attachments)
+	}
+
+	// if we have a file attached, download it (in memory) and put a pointer to it in msg.Extra
+	if len(ev.Files) > 0 {
+		for _, f := range ev.Files {
+			err := b.handleDownloadFile(&rmsg, &f)
+			if err != nil {
+				b.Log.Errorf("download failed: %s", err)
+			}
+		}
+	}
+
+	return &rmsg, nil
+}
+
+// sendWebhook uses the configured WebhookURL to send the message
+func (b *Bslack) sendWebhook(msg config.Message) (string, 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) {
+			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
+			matterMessage := matterhook.OMessage{IconURL: iconURL, Channel: msg.Channel, UserName: rmsg.Username, Text: rmsg.Text}
+			b.mh.Send(matterMessage)
+		}
+
+		// 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
+				}
+			}
+		}
+	}
+
+	// if we have native slack_attachments add them
+	var attachs []slack.Attachment
+	if len(msg.Extra["slack_attachment"]) > 0 {
+		for _, attach := range msg.Extra["slack_attachment"] {
+			attachs = append(attachs, attach.([]slack.Attachment)...)
+		}
+	}
+
+	iconURL := config.GetIconURL(&msg, b.GetString("iconurl"))
+	matterMessage := matterhook.OMessage{IconURL: iconURL, Attachments: attachs, 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.Error(err)
+		return "", err
+	}
+	return "", nil
+}
+
+// skipMessageEvent skips event that need to be skipped :-)
+func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
+	if ev.SubType == "channel_leave" || ev.SubType == "channel_join" {
+		return b.GetBool("nosendjoinpart")
+	}
+
+	// ignore pinned items
+	if ev.SubType == "pinned_item" || ev.SubType == "unpinned_item" {
+		return true
+	}
+
+	// do not send messages from ourself
+	if b.GetString("WebhookURL") == "" && b.GetString("WebhookBindAddress") == "" && ev.Username == b.si.User.Name {
+		return true
+	}
+
+	// skip messages we made ourselves
+	if len(ev.Attachments) > 0 {
+		if ev.Attachments[0].CallbackID == "matterbridge_"+b.uuid {
+			return true
+		}
+	}
+
+	if !b.GetBool("EditDisable") && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
+		// it seems ev.SubMessage.Edited == nil when slack unfurls
+		// do not forward these messages #266
+		if ev.SubMessage.Edited == nil {
+			return true
+		}
+	}
+
+	if len(ev.Files) > 0 {
+		for _, f := range ev.Files {
+			// if the file is in the cache and isn't older then a minute, skip it
+			if ts, ok := b.cache.Get("file" + f.ID); ok && time.Since(ts.(time.Time)) < time.Minute {
+				b.Log.Debugf("Not downloading file id %s which we uploaded", f.ID)
+				return true
+			} else {
+				if ts, ok := b.cache.Get("filename" + f.Name); ok && time.Since(ts.(time.Time)) < time.Second*10 {
+					b.Log.Debugf("Not downloading file name %s which we uploaded", f.Name)
+					return true
+				} else {
+					b.Log.Debugf("Not skipping %s %s", f.Name, time.Now().String())
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+func (b *Bslack) getChannelID(name string) string {
+	idcheck := strings.Split(name, "ID:")
+	if len(idcheck) > 1 {
+		return idcheck[1]
+	}
+	for _, channel := range b.channels {
+		if channel.Name == name {
+			return channel.ID
+		}
+	}
+	return ""
+}

bridge/sshchat/sshchat.go

@@ -0,0 +1,141 @@
+package bsshchat
+
+import (
+	"bufio"
+	"io"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/shazow/ssh-chat/sshd"
+	log "github.com/sirupsen/logrus"
+)
+
+type Bsshchat struct {
+	r *bufio.Scanner
+	w io.WriteCloser
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bsshchat{Config: cfg}
+}
+
+func (b *Bsshchat) Connect() error {
+	var err error
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	go func() {
+		err = sshd.ConnectShell(b.GetString("Server"), b.GetString("Nick"), func(r io.Reader, w io.WriteCloser) error {
+			b.r = bufio.NewScanner(r)
+			b.w = w
+			b.r.Scan()
+			w.Write([]byte("/theme mono\r\n"))
+			b.handleSshChat()
+			return nil
+		})
+	}()
+	if err != nil {
+		b.Log.Debugf("%#v", err)
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	return nil
+}
+
+func (b *Bsshchat) Disconnect() error {
+	return nil
+}
+
+func (b *Bsshchat) JoinChannel(channel config.ChannelInfo) error {
+	return nil
+}
+
+func (b *Bsshchat) Send(msg config.Message) (string, error) {
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+	b.Log.Debugf("=> Receiving %#v", msg)
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.w.Write([]byte(rmsg.Username + rmsg.Text + "\r\n"))
+		}
+		if len(msg.Extra["file"]) > 0 {
+			for _, f := range msg.Extra["file"] {
+				fi := f.(config.FileInfo)
+				if fi.Comment != "" {
+					msg.Text += fi.Comment + ": "
+				}
+				if fi.URL != "" {
+					msg.Text = fi.URL
+					if fi.Comment != "" {
+						msg.Text = fi.Comment + ": " + fi.URL
+					}
+				}
+				b.w.Write([]byte(msg.Username + msg.Text))
+			}
+			return "", nil
+		}
+	}
+	b.w.Write([]byte(msg.Username + msg.Text + "\r\n"))
+	return "", nil
+}
+
+/*
+func (b *Bsshchat) sshchatKeepAlive() chan bool {
+	done := make(chan bool)
+	go func() {
+		ticker := time.NewTicker(90 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				b.Log.Debugf("PING")
+				err := b.xc.PingC2S("", "")
+				if err != nil {
+					b.Log.Debugf("PING failed %#v", err)
+				}
+			case <-done:
+				return
+			}
+		}
+	}()
+	return done
+}
+*/
+
+func stripPrompt(s string) string {
+	pos := strings.LastIndex(s, "\033[K")
+	if pos < 0 {
+		return s
+	}
+	return s[pos+3:]
+}
+
+func (b *Bsshchat) handleSshChat() error {
+	/*
+		done := b.sshchatKeepAlive()
+		defer close(done)
+	*/
+	wait := true
+	for {
+		if b.r.Scan() {
+			// ignore messages from ourselves
+			if !strings.Contains(b.r.Text(), "\033[K") {
+				continue
+			}
+			res := strings.Split(stripPrompt(b.r.Text()), ":")
+			if res[0] == "-> Set theme" {
+				wait = false
+				log.Debugf("mono found, allowing")
+				continue
+			}
+			if !wait {
+				b.Log.Debugf("<= Message %#v", res)
+				rmsg := config.Message{Username: res[0], Text: strings.Join(res[1:], ":"), Channel: "sshchat", Account: b.Account, UserID: "nick"}
+				b.Remote <- rmsg
+			}
+		}
+	}
+}

bridge/steam/steam.go

@@ -0,0 +1,183 @@
+package bsteam
+
+import (
+	"fmt"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/Philipp15b/go-steam"
+	"github.com/Philipp15b/go-steam/protocol/steamlang"
+	"github.com/Philipp15b/go-steam/steamid"
+	//"io/ioutil"
+	"strconv"
+	"sync"
+	"time"
+)
+
+type Bsteam struct {
+	c         *steam.Client
+	connected chan struct{}
+	userMap   map[steamid.SteamId]string
+	sync.RWMutex
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bsteam{Config: cfg}
+	b.userMap = make(map[steamid.SteamId]string)
+	b.connected = make(chan struct{})
+	return b
+}
+
+func (b *Bsteam) Connect() error {
+	b.Log.Info("Connecting")
+	b.c = steam.NewClient()
+	go b.handleEvents()
+	go b.c.Connect()
+	select {
+	case <-b.connected:
+		b.Log.Info("Connection succeeded")
+	case <-time.After(time.Second * 30):
+		return fmt.Errorf("connection timed out")
+	}
+	return nil
+}
+
+func (b *Bsteam) Disconnect() error {
+	b.c.Disconnect()
+	return nil
+
+}
+
+func (b *Bsteam) JoinChannel(channel config.ChannelInfo) error {
+	id, err := steamid.NewId(channel.Name)
+	if err != nil {
+		return err
+	}
+	b.c.Social.JoinChat(id)
+	return nil
+}
+
+func (b *Bsteam) Send(msg config.Message) (string, error) {
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+	id, err := steamid.NewId(msg.Channel)
+	if err != nil {
+		return "", err
+	}
+
+	// Handle files
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.c.Social.SendMessage(id, steamlang.EChatEntryType_ChatMsg, rmsg.Username+rmsg.Text)
+		}
+		if len(msg.Extra["file"]) > 0 {
+			for _, f := range msg.Extra["file"] {
+				fi := f.(config.FileInfo)
+				if fi.Comment != "" {
+					msg.Text += fi.Comment + ": "
+				}
+				if fi.URL != "" {
+					msg.Text = fi.URL
+					if fi.Comment != "" {
+						msg.Text = fi.Comment + ": " + fi.URL
+					}
+				}
+				b.c.Social.SendMessage(id, steamlang.EChatEntryType_ChatMsg, msg.Username+msg.Text)
+			}
+			return "", nil
+		}
+	}
+
+	b.c.Social.SendMessage(id, steamlang.EChatEntryType_ChatMsg, msg.Username+msg.Text)
+	return "", nil
+}
+
+func (b *Bsteam) getNick(id steamid.SteamId) string {
+	b.RLock()
+	defer b.RUnlock()
+	if name, ok := b.userMap[id]; ok {
+		return name
+	}
+	return "unknown"
+}
+
+func (b *Bsteam) handleEvents() {
+	myLoginInfo := new(steam.LogOnDetails)
+	myLoginInfo.Username = b.GetString("Login")
+	myLoginInfo.Password = b.GetString("Password")
+	myLoginInfo.AuthCode = b.GetString("AuthCode")
+	// Attempt to read existing auth hash to avoid steam guard.
+	// Maybe works
+	//myLoginInfo.SentryFileHash, _ = ioutil.ReadFile("sentry")
+	for event := range b.c.Events() {
+		//b.Log.Info(event)
+		switch e := event.(type) {
+		case *steam.ChatMsgEvent:
+			b.Log.Debugf("Receiving ChatMsgEvent: %#v", e)
+			b.Log.Debugf("<= Sending message from %s on %s to gateway", b.getNick(e.ChatterId), b.Account)
+			var channel int64
+			if e.ChatRoomId == 0 {
+				channel = int64(e.ChatterId)
+			} else {
+				// for some reason we have to remove 0x18000000000000
+				channel = int64(e.ChatRoomId) - 0x18000000000000
+			}
+			msg := config.Message{Username: b.getNick(e.ChatterId), Text: e.Message, Channel: strconv.FormatInt(channel, 10), Account: b.Account, UserID: strconv.FormatInt(int64(e.ChatterId), 10)}
+			b.Remote <- msg
+		case *steam.PersonaStateEvent:
+			b.Log.Debugf("PersonaStateEvent: %#v\n", e)
+			b.Lock()
+			b.userMap[e.FriendId] = e.Name
+			b.Unlock()
+		case *steam.ConnectedEvent:
+			b.c.Auth.LogOn(myLoginInfo)
+		case *steam.MachineAuthUpdateEvent:
+			/*
+				b.Log.Info("authupdate", e)
+				b.Log.Info("hash", e.Hash)
+				ioutil.WriteFile("sentry", e.Hash, 0666)
+			*/
+		case *steam.LogOnFailedEvent:
+			b.Log.Info("Logon failed", e)
+			switch e.Result {
+			case steamlang.EResult_AccountLogonDeniedNeedTwoFactorCode:
+				{
+					b.Log.Info("Steam guard isn't letting me in! Enter 2FA code:")
+					var code string
+					fmt.Scanf("%s", &code)
+					myLoginInfo.TwoFactorCode = code
+				}
+			case steamlang.EResult_AccountLogonDenied:
+				{
+					b.Log.Info("Steam guard isn't letting me in! Enter auth code:")
+					var code string
+					fmt.Scanf("%s", &code)
+					myLoginInfo.AuthCode = code
+				}
+			default:
+				b.Log.Errorf("LogOnFailedEvent: %#v ", e.Result)
+				// TODO: Handle EResult_InvalidLoginAuthCode
+				return
+			}
+		case *steam.LoggedOnEvent:
+			b.Log.Debugf("LoggedOnEvent: %#v", e)
+			b.connected <- struct{}{}
+			b.Log.Debugf("setting online")
+			b.c.Social.SetPersonaState(steamlang.EPersonaState_Online)
+		case *steam.DisconnectedEvent:
+			b.Log.Info("Disconnected")
+			b.Log.Info("Attempting to reconnect...")
+			b.c.Connect()
+		case steam.FatalErrorEvent:
+			b.Log.Error(e)
+		case error:
+			b.Log.Error(e)
+		default:
+			b.Log.Debugf("unknown event %#v", e)
+		}
+	}
+}

bridge/telegram/html.go

@@ -0,0 +1,65 @@
+package btelegram
+
+import (
+	"bytes"
+	"html"
+
+	"github.com/russross/blackfriday"
+)
+
+type customHTML struct {
+	blackfriday.Renderer
+}
+
+func (options *customHTML) Paragraph(out *bytes.Buffer, text func() bool) {
+	marker := out.Len()
+
+	if !text() {
+		out.Truncate(marker)
+		return
+	}
+	out.WriteString("\n")
+}
+
+func (options *customHTML) BlockCode(out *bytes.Buffer, text []byte, lang string) {
+	out.WriteString("<pre>")
+
+	out.WriteString(html.EscapeString(string(text)))
+	out.WriteString("</pre>\n")
+}
+
+func (options *customHTML) Header(out *bytes.Buffer, text func() bool, level int, id string) {
+	options.Paragraph(out, text)
+}
+
+func (options *customHTML) HRule(out *bytes.Buffer) {
+	out.WriteByte('\n')
+}
+
+func (options *customHTML) BlockQuote(out *bytes.Buffer, text []byte) {
+	out.WriteString("> ")
+	out.Write(text)
+	out.WriteByte('\n')
+}
+
+func (options *customHTML) List(out *bytes.Buffer, text func() bool, flags int) {
+	options.Paragraph(out, text)
+}
+
+func (options *customHTML) ListItem(out *bytes.Buffer, text []byte, flags int) {
+	out.WriteString("- ")
+	out.Write(text)
+	out.WriteByte('\n')
+}
+
+func makeHTML(input string) string {
+	return string(blackfriday.Markdown([]byte(input),
+		&customHTML{blackfriday.HtmlRenderer(blackfriday.HTML_USE_XHTML|blackfriday.HTML_SKIP_IMAGES, "", "")},
+		blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
+			blackfriday.EXTENSION_FENCED_CODE|
+			blackfriday.EXTENSION_AUTOLINK|
+			blackfriday.EXTENSION_SPACE_HEADERS|
+			blackfriday.EXTENSION_HEADER_IDS|
+			blackfriday.EXTENSION_BACKSLASH_LINE_BREAK|
+			blackfriday.EXTENSION_DEFINITION_LISTS))
+}

bridge/telegram/telegram.go

@@ -0,0 +1,441 @@
+package btelegram
+
+import (
+	"html"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/go-telegram-bot-api/telegram-bot-api"
+)
+
+type Btelegram struct {
+	c *tgbotapi.BotAPI
+	*bridge.Config
+	avatarMap map[string]string // keep cache of userid and avatar sha
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Btelegram{Config: cfg, avatarMap: make(map[string]string)}
+}
+
+func (b *Btelegram) Connect() error {
+	var err error
+	b.Log.Info("Connecting")
+	b.c, err = tgbotapi.NewBotAPI(b.GetString("Token"))
+	if err != nil {
+		b.Log.Debugf("%#v", err)
+		return err
+	}
+	u := tgbotapi.NewUpdate(0)
+	u.Timeout = 60
+	updates, err := b.c.GetUpdatesChan(u)
+	if err != nil {
+		b.Log.Debugf("%#v", err)
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	go b.handleRecv(updates)
+	return nil
+}
+
+func (b *Btelegram) Disconnect() error {
+	return nil
+}
+
+func (b *Btelegram) JoinChannel(channel config.ChannelInfo) error {
+	return nil
+}
+
+func (b *Btelegram) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// get the chatid
+	chatid, err := strconv.ParseInt(msg.Channel, 10, 64)
+	if err != nil {
+		return "", err
+	}
+
+	// map the file SHA to our user (caches the avatar)
+	if msg.Event == config.EVENT_AVATAR_DOWNLOAD {
+		return b.cacheAvatar(&msg)
+	}
+
+	if b.GetString("MessageFormat") == "HTML" {
+		msg.Text = makeHTML(msg.Text)
+	}
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		msgid, err := strconv.Atoi(msg.ID)
+		if err != nil {
+			return "", err
+		}
+		_, err = b.c.DeleteMessage(tgbotapi.DeleteMessageConfig{ChatID: chatid, MessageID: msgid})
+		return "", err
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.sendMessage(chatid, rmsg.Username, rmsg.Text)
+		}
+		// check if we have files to upload (from slack, telegram or mattermost)
+		if len(msg.Extra["file"]) > 0 {
+			b.handleUploadFile(&msg, chatid)
+		}
+	}
+
+	// edit the message if we have a msg ID
+	if msg.ID != "" {
+		msgid, err := strconv.Atoi(msg.ID)
+		if err != nil {
+			return "", err
+		}
+		if strings.ToLower(b.GetString("MessageFormat")) == "htmlnick" {
+			b.Log.Debug("Using mode HTML - nick only")
+			msg.Text = html.EscapeString(msg.Text)
+		}
+		m := tgbotapi.NewEditMessageText(chatid, msgid, msg.Username+msg.Text)
+		if b.GetString("MessageFormat") == "HTML" {
+			b.Log.Debug("Using mode HTML")
+			m.ParseMode = tgbotapi.ModeHTML
+		}
+		if b.GetString("MessageFormat") == "Markdown" {
+			b.Log.Debug("Using mode markdown")
+			m.ParseMode = tgbotapi.ModeMarkdown
+		}
+		if strings.ToLower(b.GetString("MessageFormat")) == "htmlnick" {
+			b.Log.Debug("Using mode HTML - nick only")
+			m.ParseMode = tgbotapi.ModeHTML
+		}
+		_, err = b.c.Send(m)
+		if err != nil {
+			return "", err
+		}
+		return "", nil
+	}
+
+	// Post normal message
+	return b.sendMessage(chatid, msg.Username, msg.Text)
+}
+
+func (b *Btelegram) handleRecv(updates <-chan tgbotapi.Update) {
+	for update := range updates {
+		b.Log.Debugf("== Receiving event: %#v", update.Message)
+
+		if update.Message == nil && update.ChannelPost == nil && update.EditedMessage == nil && update.EditedChannelPost == nil {
+			b.Log.Error("Getting nil messages, this shouldn't happen.")
+			continue
+		}
+
+		var message *tgbotapi.Message
+
+		rmsg := config.Message{Account: b.Account, Extra: make(map[string][]interface{})}
+
+		// handle channels
+		if update.ChannelPost != nil {
+			message = update.ChannelPost
+			rmsg.Text = message.Text
+		}
+
+		// edited channel message
+		if update.EditedChannelPost != nil && !b.GetBool("EditDisable") {
+			message = update.EditedChannelPost
+			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
+		}
+
+		// handle groups
+		if update.Message != nil {
+			message = update.Message
+			rmsg.Text = message.Text
+		}
+
+		// edited group message
+		if update.EditedMessage != nil && !b.GetBool("EditDisable") {
+			message = update.EditedMessage
+			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
+		}
+
+		// set the ID's from the channel or group message
+		rmsg.ID = strconv.Itoa(message.MessageID)
+		rmsg.Channel = strconv.FormatInt(message.Chat.ID, 10)
+
+		// handle username
+		if message.From != nil {
+			rmsg.UserID = strconv.Itoa(message.From.ID)
+			if b.GetBool("UseFirstName") {
+				rmsg.Username = message.From.FirstName
+			}
+			if rmsg.Username == "" {
+				rmsg.Username = message.From.UserName
+				if rmsg.Username == "" {
+					rmsg.Username = message.From.FirstName
+				}
+			}
+			// only download avatars if we have a place to upload them (configured mediaserver)
+			if b.General.MediaServerUpload != "" {
+				b.handleDownloadAvatar(message.From.ID, rmsg.Channel)
+			}
+		}
+
+		// if we really didn't find a username, set it to unknown
+		if rmsg.Username == "" {
+			rmsg.Username = "unknown"
+		}
+
+		// handle any downloads
+		err := b.handleDownload(message, &rmsg)
+		if err != nil {
+			b.Log.Errorf("download failed: %s", err)
+		}
+
+		// handle forwarded messages
+		if message.ForwardFrom != nil {
+			usernameForward := ""
+			if b.GetBool("UseFirstName") {
+				usernameForward = message.ForwardFrom.FirstName
+			}
+			if usernameForward == "" {
+				usernameForward = message.ForwardFrom.UserName
+				if usernameForward == "" {
+					usernameForward = message.ForwardFrom.FirstName
+				}
+			}
+			if usernameForward == "" {
+				usernameForward = "unknown"
+			}
+			rmsg.Text = "Forwarded from " + usernameForward + ": " + rmsg.Text
+		}
+
+		// quote the previous message
+		if message.ReplyToMessage != nil {
+			usernameReply := ""
+			if message.ReplyToMessage.From != nil {
+				if b.GetBool("UseFirstName") {
+					usernameReply = message.ReplyToMessage.From.FirstName
+				}
+				if usernameReply == "" {
+					usernameReply = message.ReplyToMessage.From.UserName
+					if usernameReply == "" {
+						usernameReply = message.ReplyToMessage.From.FirstName
+					}
+				}
+			}
+			if usernameReply == "" {
+				usernameReply = "unknown"
+			}
+			if !b.GetBool("QuoteDisable") {
+				rmsg.Text = b.handleQuote(rmsg.Text, usernameReply, message.ReplyToMessage.Text)
+			}
+		}
+
+		if rmsg.Text != "" || len(rmsg.Extra) > 0 {
+			rmsg.Text = helper.RemoveEmptyNewLines(rmsg.Text)
+			// channels don't have (always?) user information. see #410
+			if message.From != nil {
+				rmsg.Avatar = helper.GetAvatar(b.avatarMap, strconv.Itoa(message.From.ID), b.General)
+			}
+
+			b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
+			b.Log.Debugf("<= Message is %#v", rmsg)
+			b.Remote <- rmsg
+		}
+	}
+}
+
+func (b *Btelegram) getFileDirectURL(id string) string {
+	res, err := b.c.GetFileDirectURL(id)
+	if err != nil {
+		return ""
+	}
+	return res
+}
+
+// handleDownloadAvatar downloads the avatar of userid from channel
+// sends a EVENT_AVATAR_DOWNLOAD message to the gateway if successful.
+// logs an error message if it fails
+func (b *Btelegram) handleDownloadAvatar(userid int, channel string) {
+	rmsg := config.Message{Username: "system", Text: "avatar", Channel: channel, Account: b.Account, UserID: strconv.Itoa(userid), Event: config.EVENT_AVATAR_DOWNLOAD, Extra: make(map[string][]interface{})}
+	if _, ok := b.avatarMap[strconv.Itoa(userid)]; !ok {
+		photos, err := b.c.GetUserProfilePhotos(tgbotapi.UserProfilePhotosConfig{UserID: userid, Limit: 1})
+		if err != nil {
+			b.Log.Errorf("Userprofile download failed for %#v %s", userid, err)
+		}
+
+		if len(photos.Photos) > 0 {
+			photo := photos.Photos[0][0]
+			url := b.getFileDirectURL(photo.FileID)
+			name := strconv.Itoa(userid) + ".png"
+			b.Log.Debugf("trying to download %#v fileid %#v with size %#v", name, photo.FileID, photo.FileSize)
+
+			err := helper.HandleDownloadSize(b.Log, &rmsg, name, int64(photo.FileSize), b.General)
+			if err != nil {
+				b.Log.Error(err)
+				return
+			}
+			data, err := helper.DownloadFile(url)
+			if err != nil {
+				b.Log.Errorf("download %s failed %#v", url, err)
+				return
+			}
+			helper.HandleDownloadData(b.Log, &rmsg, name, rmsg.Text, "", data, b.General)
+			b.Remote <- rmsg
+		}
+	}
+}
+
+// handleDownloadFile handles file download
+func (b *Btelegram) handleDownload(message *tgbotapi.Message, rmsg *config.Message) error {
+	size := 0
+	var url, name, text string
+
+	if message.Sticker != nil {
+		v := message.Sticker
+		size = v.FileSize
+		url = b.getFileDirectURL(v.FileID)
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+		if !strings.HasSuffix(name, ".webp") {
+			name = name + ".webp"
+		}
+		text = " " + url
+	}
+	if message.Video != nil {
+		v := message.Video
+		size = v.FileSize
+		url = b.getFileDirectURL(v.FileID)
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+		text = " " + url
+	}
+	if message.Photo != nil {
+		photos := *message.Photo
+		size = photos[len(photos)-1].FileSize
+		url = b.getFileDirectURL(photos[len(photos)-1].FileID)
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+		text = " " + url
+	}
+	if message.Document != nil {
+		v := message.Document
+		size = v.FileSize
+		url = b.getFileDirectURL(v.FileID)
+		name = v.FileName
+		text = " " + v.FileName + " : " + url
+	}
+	if message.Voice != nil {
+		v := message.Voice
+		size = v.FileSize
+		url = b.getFileDirectURL(v.FileID)
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+		text = " " + url
+		if !strings.HasSuffix(name, ".ogg") {
+			name = name + ".ogg"
+		}
+	}
+	if message.Audio != nil {
+		v := message.Audio
+		size = v.FileSize
+		url = b.getFileDirectURL(v.FileID)
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+		text = " " + url
+	}
+	// if name is empty we didn't match a thing to download
+	if name == "" {
+		return nil
+	}
+	// use the URL instead of native upload
+	if b.GetBool("UseInsecureURL") {
+		b.Log.Debugf("Setting message text to :%s", text)
+		rmsg.Text = rmsg.Text + text
+		return nil
+	}
+	// if we have a file attached, download it (in memory) and put a pointer to it in msg.Extra
+	err := helper.HandleDownloadSize(b.Log, rmsg, name, int64(size), b.General)
+	if err != nil {
+		return err
+	}
+	data, err := helper.DownloadFile(url)
+	if err != nil {
+		return err
+	}
+	helper.HandleDownloadData(b.Log, rmsg, name, message.Caption, "", data, b.General)
+	return nil
+}
+
+// handleUploadFile handles native upload of files
+func (b *Btelegram) handleUploadFile(msg *config.Message, chatid int64) (string, error) {
+	var c tgbotapi.Chattable
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		file := tgbotapi.FileBytes{fi.Name, *fi.Data}
+		re := regexp.MustCompile(".(jpg|png)$")
+		if re.MatchString(fi.Name) {
+			c = tgbotapi.NewPhotoUpload(chatid, file)
+		} else {
+			c = tgbotapi.NewDocumentUpload(chatid, file)
+		}
+		_, err := b.c.Send(c)
+		if err != nil {
+			b.Log.Errorf("file upload failed: %#v", err)
+		}
+		if fi.Comment != "" {
+			b.sendMessage(chatid, msg.Username, fi.Comment)
+		}
+	}
+	return "", nil
+}
+
+func (b *Btelegram) sendMessage(chatid int64, username, text string) (string, error) {
+	m := tgbotapi.NewMessage(chatid, "")
+	m.Text = username + text
+	if b.GetString("MessageFormat") == "HTML" {
+		b.Log.Debug("Using mode HTML")
+		m.ParseMode = tgbotapi.ModeHTML
+	}
+	if b.GetString("MessageFormat") == "Markdown" {
+		b.Log.Debug("Using mode markdown")
+		m.ParseMode = tgbotapi.ModeMarkdown
+	}
+	if strings.ToLower(b.GetString("MessageFormat")) == "htmlnick" {
+		b.Log.Debug("Using mode HTML - nick only")
+		m.Text = username + html.EscapeString(text)
+		m.ParseMode = tgbotapi.ModeHTML
+	}
+	res, err := b.c.Send(m)
+	if err != nil {
+		return "", err
+	}
+	return strconv.Itoa(res.MessageID), nil
+}
+
+func (b *Btelegram) cacheAvatar(msg *config.Message) (string, error) {
+	fi := msg.Extra["file"][0].(config.FileInfo)
+	/* if we have a sha we have successfully uploaded the file to the media server,
+	so we can now cache the sha */
+	if fi.SHA != "" {
+		b.Log.Debugf("Added %s to %s in avatarMap", fi.SHA, msg.UserID)
+		b.avatarMap[msg.UserID] = fi.SHA
+	}
+	return "", nil
+}
+
+func (b *Btelegram) handleQuote(message, quoteNick, quoteMessage string) string {
+	format := b.GetString("quoteformat")
+	if format == "" {
+		format = "{MESSAGE} (re @{QUOTENICK}: {QUOTEMESSAGE})"
+	}
+	format = strings.Replace(format, "{MESSAGE}", message, -1)
+	format = strings.Replace(format, "{QUOTENICK}", quoteNick, -1)
+	format = strings.Replace(format, "{QUOTEMESSAGE}", quoteMessage, -1)
+	return format
+}

bridge/xmpp/xmpp.go

@@ -0,0 +1,266 @@
+package bxmpp
+
+import (
+	"crypto/tls"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/jpillora/backoff"
+	"github.com/matterbridge/go-xmpp"
+	"github.com/rs/xid"
+)
+
+type Bxmpp struct {
+	xc      *xmpp.Client
+	xmppMap map[string]string
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bxmpp{Config: cfg}
+	b.xmppMap = make(map[string]string)
+	return b
+}
+
+func (b *Bxmpp) Connect() error {
+	var err error
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	b.xc, err = b.createXMPP()
+	if err != nil {
+		b.Log.Debugf("%#v", err)
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	go func() {
+		initial := true
+		bf := &backoff.Backoff{
+			Min:    time.Second,
+			Max:    5 * time.Minute,
+			Jitter: true,
+		}
+		for {
+			if initial {
+				b.handleXMPP()
+				initial = false
+			}
+			d := bf.Duration()
+			b.Log.Infof("Disconnected. Reconnecting in %s", d)
+			time.Sleep(d)
+			b.xc, err = b.createXMPP()
+			if err == nil {
+				b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: "", Account: b.Account, Event: config.EVENT_REJOIN_CHANNELS}
+				b.handleXMPP()
+				bf.Reset()
+			}
+		}
+	}()
+	return nil
+}
+
+func (b *Bxmpp) Disconnect() error {
+	return nil
+}
+
+func (b *Bxmpp) JoinChannel(channel config.ChannelInfo) error {
+	if channel.Options.Key != "" {
+		b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
+		b.xc.JoinProtectedMUC(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"), channel.Options.Key, xmpp.NoHistory, 0, nil)
+	} else {
+		b.xc.JoinMUCNoHistory(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"))
+	}
+	return nil
+}
+
+func (b *Bxmpp) Send(msg config.Message) (string, error) {
+	var msgid = ""
+	var msgreplaceid = ""
+	// ignore delete messages
+	if msg.Event == config.EVENT_MSG_DELETE {
+		return "", nil
+	}
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Upload a file (in xmpp case send the upload URL because xmpp has no native upload support)
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: rmsg.Channel + "@" + b.GetString("Muc"), Text: rmsg.Username + rmsg.Text})
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&msg)
+		}
+	}
+
+	msgid = xid.New().String()
+	if msg.ID != "" {
+		msgid = msg.ID
+		msgreplaceid = msg.ID
+	}
+	// Post normal message
+	_, err := b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Text: msg.Username + msg.Text, ID: msgid, ReplaceID: msgreplaceid})
+	if err != nil {
+		return "", err
+	}
+	return msgid, nil
+}
+
+func (b *Bxmpp) createXMPP() (*xmpp.Client, error) {
+	tc := new(tls.Config)
+	tc.InsecureSkipVerify = b.GetBool("SkipTLSVerify")
+	tc.ServerName = strings.Split(b.GetString("Server"), ":")[0]
+	options := xmpp.Options{
+		Host:                         b.GetString("Server"),
+		User:                         b.GetString("Jid"),
+		Password:                     b.GetString("Password"),
+		NoTLS:                        true,
+		StartTLS:                     true,
+		TLSConfig:                    tc,
+		Debug:                        b.GetBool("debug"),
+		Logger:                       b.Log.Writer(),
+		Session:                      true,
+		Status:                       "",
+		StatusMessage:                "",
+		Resource:                     "",
+		InsecureAllowUnencryptedAuth: false,
+	}
+	var err error
+	b.xc, err = options.NewClient()
+	return b.xc, err
+}
+
+func (b *Bxmpp) xmppKeepAlive() chan bool {
+	done := make(chan bool)
+	go func() {
+		ticker := time.NewTicker(90 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				b.Log.Debugf("PING")
+				err := b.xc.PingC2S("", "")
+				if err != nil {
+					b.Log.Debugf("PING failed %#v", err)
+				}
+			case <-done:
+				return
+			}
+		}
+	}()
+	return done
+}
+
+func (b *Bxmpp) handleXMPP() error {
+	var ok bool
+	var msgid string
+	done := b.xmppKeepAlive()
+	defer close(done)
+	for {
+		m, err := b.xc.Recv()
+		if err != nil {
+			return err
+		}
+		switch v := m.(type) {
+		case xmpp.Chat:
+			if v.Type == "groupchat" {
+				b.Log.Debugf("== Receiving %#v", v)
+				// skip invalid messages
+				if b.skipMessage(v) {
+					continue
+				}
+				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}
+
+				// check if we have an action event
+				rmsg.Text, ok = b.replaceAction(rmsg.Text)
+				if ok {
+					rmsg.Event = config.EVENT_USER_ACTION
+				}
+				b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
+				b.Log.Debugf("<= Message is %#v", rmsg)
+				b.Remote <- rmsg
+			}
+		case xmpp.Presence:
+			// do nothing
+		}
+	}
+}
+
+func (b *Bxmpp) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "/me ") {
+		return strings.Replace(text, "/me ", "", -1), true
+	}
+	return text, false
+}
+
+// handleUploadFile handles native upload of files
+func (b *Bxmpp) handleUploadFile(msg *config.Message) (string, error) {
+	var urldesc = ""
+
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if fi.Comment != "" {
+			msg.Text += fi.Comment + ": "
+		}
+		if fi.URL != "" {
+			msg.Text = fi.URL
+			if fi.Comment != "" {
+				msg.Text = fi.Comment + ": " + fi.URL
+				urldesc = fi.Comment
+			}
+		}
+		_, err := b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Text: msg.Username + msg.Text})
+		if err != nil {
+			return "", err
+		}
+		if fi.URL != "" {
+			b.xc.SendOOB(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Ooburl: fi.URL, Oobdesc: urldesc})
+		}
+	}
+	return "", nil
+}
+
+func (b *Bxmpp) parseNick(remote string) string {
+	s := strings.Split(remote, "@")
+	if len(s) > 0 {
+		s = strings.Split(s[1], "/")
+		if len(s) == 2 {
+			return s[1] // nick
+		}
+	}
+	return ""
+}
+
+func (b *Bxmpp) parseChannel(remote string) string {
+	s := strings.Split(remote, "@")
+	if len(s) >= 2 {
+		return s[0] // channel
+	}
+	return ""
+}
+
+// skipMessage skips messages that need to be skipped
+func (b *Bxmpp) skipMessage(message xmpp.Chat) bool {
+	// skip messages from ourselves
+	if b.parseNick(message.Remote) == b.GetString("Nick") {
+		return true
+	}
+
+	// skip empty messages
+	if message.Text == "" {
+		return true
+	}
+
+	// skip subject messages
+	if strings.Contains(message.Text, "</subject>") {
+		return true
+	}
+
+	// skip delayed messages
+	t := time.Time{}
+	return message.Stamp != t
+}

bridge/zulip/zulip.go

@@ -0,0 +1,170 @@
+package bzulip
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"strconv"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	gzb "github.com/matterbridge/gozulipbot"
+)
+
+type Bzulip struct {
+	q       *gzb.Queue
+	bot     *gzb.Bot
+	streams map[int]string
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bzulip{Config: cfg, streams: make(map[int]string)}
+}
+
+func (b *Bzulip) Connect() error {
+	bot := gzb.Bot{APIKey: b.GetString("token"), APIURL: b.GetString("server") + "/api/v1/", Email: b.GetString("login")}
+	bot.Init()
+	q, err := bot.RegisterAll()
+	b.q = q
+	b.bot = &bot
+	if err != nil {
+		b.Log.Errorf("Connect() %#v", err)
+		return err
+	}
+	// init stream
+	b.getChannel(0)
+	b.Log.Info("Connection succeeded")
+	go b.handleQueue()
+	return nil
+}
+
+func (b *Bzulip) Disconnect() error {
+	return nil
+}
+
+func (b *Bzulip) JoinChannel(channel config.ChannelInfo) error {
+	return nil
+}
+
+func (b *Bzulip) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		if msg.ID == "" {
+			return "", nil
+		}
+		_, err := b.bot.UpdateMessage(msg.ID, "")
+		return "", err
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.sendMessage(rmsg)
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&msg)
+		}
+	}
+
+	// edit the message if we have a msg ID
+	if msg.ID != "" {
+		_, err := b.bot.UpdateMessage(msg.ID, msg.Username+msg.Text)
+		return "", err
+	}
+
+	// Post normal message
+	return b.sendMessage(msg)
+}
+
+func (b *Bzulip) getChannel(id int) string {
+	if name, ok := b.streams[id]; ok {
+		return name
+	}
+	streams, err := b.bot.GetRawStreams()
+	if err != nil {
+		b.Log.Errorf("getChannel: %#v", err)
+		return ""
+	}
+	for _, stream := range streams.Streams {
+		b.streams[stream.StreamID] = stream.Name
+	}
+	if name, ok := b.streams[id]; ok {
+		return name
+	}
+	return ""
+}
+
+func (b *Bzulip) handleQueue() error {
+	for {
+		messages, _ := b.q.GetEvents()
+		for _, m := range messages {
+			b.Log.Debugf("== Receiving %#v", m)
+			// ignore our own messages
+			if m.SenderEmail == b.GetString("login") {
+				continue
+			}
+			rmsg := config.Message{Username: m.SenderFullName, Text: m.Content, Channel: b.getChannel(m.StreamID), Account: b.Account, UserID: strconv.Itoa(m.SenderID), Avatar: m.AvatarURL}
+			b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
+			b.Log.Debugf("<= Message is %#v", rmsg)
+			b.Remote <- rmsg
+			b.q.LastEventID = m.ID
+		}
+		time.Sleep(time.Second * 3)
+	}
+}
+
+func (b *Bzulip) sendMessage(msg config.Message) (string, error) {
+	topic := "matterbridge"
+	if b.GetString("topic") != "" {
+		topic = b.GetString("topic")
+	}
+	m := gzb.Message{
+		Stream:  msg.Channel,
+		Topic:   topic,
+		Content: msg.Username + msg.Text,
+	}
+	resp, err := b.bot.Message(m)
+	if err != nil {
+		return "", err
+	}
+	if resp != nil {
+		defer resp.Body.Close()
+		res, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return "", err
+		}
+		var jr struct {
+			ID int `json:"id"`
+		}
+		err = json.Unmarshal(res, &jr)
+		if err != nil {
+			return "", err
+		}
+		return strconv.Itoa(jr.ID), nil
+	}
+	return "", nil
+}
+
+func (b *Bzulip) handleUploadFile(msg *config.Message) (string, error) {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if fi.Comment != "" {
+			msg.Text += fi.Comment + ": "
+		}
+		if fi.URL != "" {
+			msg.Text = fi.URL
+			if fi.Comment != "" {
+				msg.Text = fi.Comment + ": " + fi.URL
+			}
+		}
+		_, err := b.sendMessage(*msg)
+		if err != nil {
+			return "", err
+		}
+	}
+	return "", nil
+}

changelog.md

@@ -0,0 +1,717 @@
+# v1.11.3
+
+## Bugfix
+* mattermost: fix panic when using webhooks #491
+* slack: fix issues regarding API changes and lots of channels #489
+* irc: fix rejoin on kick problem #488
+
+# v1.11.2
+
+## Bugfix
+* slack: fix slack API changes regarding to files/images
+
+# v1.11.1
+
+## New features
+* slack: Add support for slack channels by ID. Closes #436
+* discord: Clip too long messages sent to discord (discord). Closes #440
+
+## Bugfix
+* general: fix possible panic on downloads that are too big #448
+* general: Fix avatar uploads to work with MediaDownloadPath. Closes #454
+* discord: allow receiving of topic changes/channel leave/joins from other bridges through the webhook
+* discord: Add a space before url in file uploads (discord). Closes #461
+* discord:  Skip empty messages being sent with the webhook (discord). #469
+* mattermost: Use nickname instead of username if defined (mattermost). Closes #452
+* irc: Stop numbers being stripped after non-color control codes (irc) (#465)
+* slack: Use UserID to look for avatar instead of username (slack). Closes #472
+
+# v1.11.0
+
+## New features
+* general: Add config option MediaDownloadPath (#443). See `MediaDownloadPath` in matterbridge.toml.sample
+* general: Add MediaDownloadBlacklist option. Closes #442. See `MediaDownloadBlacklist` in matterbridge.toml.sample
+* xmpp: Add channel password support for XMPP (#451)
+* xmpp: Add message correction support for XMPP (#437)
+* telegram: Add support for MessageFormat=htmlnick (telegram). #444
+* mattermost: Add support for mattermost 5.x
+
+## Enhancements
+* slack: Add Title from attachment slack message (#446)
+* irc: Prevent white or black color codes (irc) (#434)
+
+## Bugfix
+* slack: Fix regexp in replaceMention (slack). (#435)
+* irc: Reconnect on quit. (irc) See #431 (#445)
+* sshchat: Ignore messages from ourself. (sshchat) Closes #439
+
+# v1.10.1
+## New features
+* irc: Colorize username sent to IRC using its crc32 IEEE checksum (#423). See `ColorNicks` in matterbridge.toml.sample
+* irc: Add support for CJK to/from utf-8 (irc). #400
+* telegram: Add QuoteFormat option (telegram). Closes #413. See `QuoteFormat` in matterbridge.toml.sample
+* xmpp: Send attached files to XMPP in different message with OOB data and without body (#421)
+
+## Bugfix
+* general: updated irc/xmpp/telegram libraries
+* mattermost/slack/rocketchat: Fix iconurl regression. Closes #430
+* mattermost/slack: Use uuid instead of userid. Fixes #429
+* slack: Avatar spoofing from Slack to Discord with uppercase in nick doesn't work (#433)
+* irc: Fix format string bug (irc) (#428)
+
+# v1.10.0
+## New features
+* general: Add support for reloading all settings automatically after changing config except connection and gateway configuration. Closes #373
+* zulip: New protocol support added (https://zulipchat.com)
+
+## Enhancements
+* general: Handle file comment better
+* steam: Handle file uploads to mediaserver (steam)
+* slack: Properly set Slack user who initiated slash command (#394)
+
+## Bugfix
+* general: Use only alphanumeric for file uploads to mediaserver. Closes #416
+* general: Fix crash on invalid filenames
+* general: Fix regression in ReplaceMessages and ReplaceNicks. Closes #407
+* telegram: Fix possible nil when using channels (telegram). #410
+* telegram: Fix panic (telegram). Closes #410
+* telegram: Handle channel posts correctly
+* mattermost: Update GetFileLinks to API_V4
+
+# v1.9.1
+## New features
+* telegram: Add QuoteDisable option (telegram). Closes #399. See QuoteDisable in matterbridge.toml.sample
+## Enhancements
+* discord: Send mediaserver link to Discord in Webhook mode (discord) (#405)
+* mattermost: Print list of valid team names when team not found (#390)
+* slack: Strip markdown URLs with blank text (slack) (#392)
+## Bugfix
+* slack/mattermost: Make our callbackid more unique. Fixes issue with running multiple matterbridge on the same channel (slack,mattermost)
+* telegram: fix newlines in multiline messages #399
+* telegram: Revert #378
+
+# v1.9.0 (the refactor release)
+## New features
+* general: better debug messages
+* general: better support for environment variables override
+* general: Ability to disable sending join/leave messages to other gateways. #382
+* slack: Allow Slack @usergroups to be parsed as human-friendly names #379
+* slack: Provide better context for shared posts from Slack<=>Slack enhancement #369
+* telegram: Convert nicks automatically into HTML when MessageFormat is set to HTML #378
+* irc: Add DebugLevel option 
+
+## Bugfix
+* slack: Ignore restricted_action on channel join (slack). Closes #387
+* slack: Add slack attachment support to matterhook
+* slack: Update userlist on join (slack). Closes #372
+
+# v1.8.0
+## New features
+* general: Send chat notification if media is too big to be re-uploaded to MediaServer. See #359
+* general: Download (and upload) avatar images from mattermost and telegram when mediaserver is configured. Closes #362
+* general: Add label support in RemoteNickFormat
+* general: Prettier info/debug log output
+* mattermost: Download files and reupload to supported bridges (mattermost). Closes #357
+* slack: Add ShowTopicChange option. Allow/disable topic change messages (currently only from slack). Closes #353
+* slack: Add support for file comments (slack). Closes #346
+* telegram: Add comment to file upload from telegram. Show comments on all bridges. Closes #358
+* telegram: Add markdown support (telegram). #355
+* api: Give api access to whole config.Message (and events). Closes #374
+
+## Bugfix
+* discord: Check for a valid WebhookURL (discord). Closes #367
+* discord: Fix role mention replace issues
+* irc: Truncate messages sent to IRC based on byte count (#368)
+* mattermost: Add file download urls also to mattermost webhooks #356
+* telegram: Fix panic on nil messages (telegram). Closes #366
+* telegram: Fix the UseInsecureURL text (telegram). Closes #184
+
+# v1.7.1
+## Bugfix
+* telegram: Enable Long Polling for Telegram. Reduces bandwidth consumption. (#350)
+
+# v1.7.0
+## New features
+* matrix: Add support for deleting messages from/to matrix (matrix). Closes #320
+* xmpp: Ignore <subject> messages (xmpp). #272
+* irc: Add twitch support (irc) to README / wiki
+
+## Bugfix
+* general: Change RemoteNickFormat replacement order. Closes #336
+* general: Make edits/delete work for bridges that gets reused. Closes #342
+* general: Lowercase irc channels in config. Closes #348
+* matrix: Fix possible panics (matrix). Closes #333
+* matrix: Add an extension to images without one (matrix). #331
+* api: Obey the Gateway value from the json (api). Closes #344
+* xmpp: Print only debug messages when specified (xmpp). Closes #345
+* xmpp: Allow xmpp to receive the extra messages (file uploads) when text is empty. #295
+
+# v1.6.3
+## Bugfix
+* slack: Fix connection issues
+* slack: Add more debug messages
+* irc: Convert received IRC channel names to lowercase. Fixes #329 (#330)
+
+# v1.6.2
+## Bugfix
+* mattermost: Crashes while connecting to Mattermost (regression). Closes #327
+
+# v1.6.1
+## Bugfix
+* general: Display of nicks not longer working (regression). Closes #323
+
+# v1.6.0
+## New features
+* sshchat: New protocol support added (https://github.com/shazow/ssh-chat)
+* general: Allow specifying maximum download size of media using MediaDownloadSize (slack,telegram,matrix)
+* api: Add (simple, one listener) long-polling support (api). Closes #307
+* telegram: Add support for forwarded messages. Closes #313
+* telegram: Add support for Audio/Voice files (telegram). Closes #314
+* irc: Add RejoinDelay option. Delay to rejoin after channel kick (irc). Closes #322
+
+## Bugfix
+* telegram: Also use HTML in edited messages (telegram). Closes #315
+* matrix: Fix panic (matrix). Closes #316
+
+# v1.5.1
+
+## Bugfix
+* irc: Fix irc ACTION regression (irc). Closes #306
+* irc: Split on UTF-8 for MessageSplit (irc). Closes #308
+
+# v1.5.0
+## New features
+* general: remote mediaserver support. See MediaServerDownload and MediaServerUpload in matterbridge.toml.sample
+  more information on https://github.com/42wim/matterbridge/wiki/Mediaserver-setup-%5Badvanced%5D
+* general: Add support for ReplaceNicks using regexp to replace nicks. Closes #269 (see matterbridge.toml.sample)
+* general: Add support for ReplaceMessages using regexp to replace messages. #269 (see matterbridge.toml.sample)
+* irc: Add MessageSplit option to split messages on MessageLength (irc). Closes #281
+* matrix: Add support for uploading images/video (matrix). Closes #302
+* matrix: Add support for uploaded images/video (matrix) 
+
+## Bugfix
+* telegram: Add webp extension to stickers if necessary (telegram)
+* mattermost: Break when re-login fails (mattermost)
+
+# v1.4.1
+## Bugfix
+* telegram: fix issue with uploading for images/documents/stickers
+* slack: remove double messages sent to other bridges when uploading files
+* irc: Fix strict user handling of girc (irc). Closes #298 
+
+# v1.4.0
+## Breaking changes
+* general: `[general]` settings don't override the specific bridge settings
+
+## New features
+* irc: Replace sorcix/irc and go-ircevent with girc, this should be give better reconnects
+* steam: Add support for bridging to individual steam chats. (steam) (#294)
+* telegram: Download files from telegram and reupload to supported bridges (telegram). #278
+* slack: Add support to upload files to slack, from bridges with private urls like slack/mattermost/telegram. (slack)
+* discord: Add support to upload files to discord, from bridges with private urls like slack/mattermost/telegram. (discord)
+* general: Add systemd service file (#291)
+* general: Add support for DEBUG=1 envvar to enable debug. Closes #283
+* general: Add StripNick option, only allow alphanumerical nicks. Closes #285
+
+## Bugfix
+* gitter: Use room.URI instead of room.Name. (gitter) (#293)
+* slack: Allow slack messages with variables (eg. @here) to be formatted correctly. (slack) (#288)
+* slack: Resolve slack channel to human-readable name. (slack) (#282)
+* slack: Use DisplayName instead of deprecated username (slack). Closes #276
+* slack: Allowed Slack bridge to extract simpler link format. (#287)
+* irc: Strip irc colors correct, strip also ctrl chars (irc)
+
+# v1.3.1
+## New features
+* Support mattermost 4.3.0 and every other 4.x as api4 should be stable (mattermost)
+## Bugfix
+* Use bot username if specified (slack). Closes #273
+
+# v1.3.0
+## New features
+* Relay slack_attachments from mattermost to slack (slack). Closes #260
+* Add support for quoting previous message when replying (telegram). #237
+* Add support for Quakenet auth (irc). Closes #263
+* Download files (max size 1MB) from slack and reupload to mattermost (slack/mattermost). Closes #255
+
+## Enhancements
+* Backoff for 60 seconds when reconnecting too fast (irc) #267
+* Use override username if specified (mattermost). #260
+
+## Bugfix
+* Try to not forward slack unfurls. Closes #266
+
+# v1.2.0
+## Breaking changes
+* If you're running a discord bridge, update to this release before 16 october otherwise
+it will stop working. (see https://discordapp.com/developers/docs/reference)
+
+## New features
+* general: Add delete support. (actually delete the messages on bridges that support it)
+    (mattermost,discord,gitter,slack,telegram)
+
+## Bugfix
+* Do not break messages on newline (slack). Closes #258 
+* Update telegram library
+* Update discord library (supports v6 API now). Old API is deprecated on 16 October
+
+# v1.1.2
+## New features
+* general: also build darwin binaries
+* mattermost: add support for mattermost 4.2.x
+
+## Bugfix 
+* mattermost: Send images when text is empty regression. (mattermost). Closes #254
+* slack: also send the first messsage after connect. #252
+
+# v1.1.1
+## Bugfix
+* mattermost: fix public links
+
+# v1.1.0
+## New features
+* general: Add better editing support. (actually edit the messages on bridges that support it)
+	(mattermost,discord,gitter,slack,telegram)
+* mattermost: use API v4 (removes support for mattermost < 3.8)
+* mattermost: add support for personal access tokens (since mattermost 4.1)
+	Use ```Token="yourtoken"``` in mattermost config
+	See https://docs.mattermost.com/developer/personal-access-tokens.html for more info
+* matrix: Relay notices (matrix). Closes #243
+* irc: Add a charset option. Closes #247
+
+## Bugfix
+* slack: Handle leave/join events (slack). Closes #246
+* slack: Replace mentions from other bridges. (slack). Closes #233
+* gitter: remove ZWSP after messages
+
+# v1.0.1
+## New features
+* mattermost: add support for mattermost 4.1.x
+* discord: allow a webhookURL per channel #239
+
+# v1.0.0
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+* discord: Shows the username instead of the server nickname #234
+
+# v1.0.0-rc1
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+
+## Bugfix
+* general: Handle same account in multiple gateways better
+* mattermost: ignore edited messages with reactions
+* mattermost: Fix double posting of edited messages by using lru cache
+* irc: update vendor
+
+# v0.16.3
+## Bugfix
+* general: Fix in/out logic. Closes #224 
+* general: Fix message modification
+* slack: Disable message from other bots when using webhooks (slack)
+* mattermost: Return better error messages on mattermost connect
+
+# v0.16.2
+## New features
+* general: binary builds against latest commit are now available on https://bintray.com/42wim/nightly/Matterbridge/_latestVersion
+
+## Bugfix
+* slack: fix loop introduced by relaying message of other bots #219
+* slack: Suppress parent message when child message is received #218
+* mattermost: fix regression when using webhookurl and webhookbindaddress #221
+
+# v0.16.1
+## New features
+* slack: also relay messages of other bots #213
+* mattermost: show also links if public links have not been enabled.
+
+## Bugfix
+* mattermost, slack: fix connecting logic #216
+
+# v0.16.0
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## New features
+* mattermost: add support for mattermost 4.0
+* steam: New protocol support added (http://store.steampowered.com/)
+* discord: Support for embedded messages (sent by other bots)
+  Shows title, description and URL of embedded messages (sent by other bots)
+  To enable add ```ShowEmbeds=true``` to your discord config 
+* discord: ```WebhookURL``` posting support added (thanks @saury07) #204
+  Discord API does not allow to change the name of the user posting, but webhooks does.
+
+## Changes
+* general: all :emoji: will be converted to unicode, providing consistent emojis across all bridges
+* telegram: Add ```UseInsecureURL``` option for telegram (default false)
+  WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+  Those URLs will contain your bot-token. This may not be what you want.
+  For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+
+## Bugfix
+* irc: detect charset and try to convert it to utf-8 before sending it to other bridges. #209 #210
+* slack: Remove label from URLs (slack). #205
+* slack: Relay <>& correctly to other bridges #215
+* steam: Fix channel id bug in steam (channels are off by 0x18000000000000)
+* general: various improvements
+* general: samechannelgateway now relays messages correct again #207
+
+
+# v0.16.0-rc2
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## Bugfix since rc1
+* steam: Fix channel id bug in steam (channels are off by 0x18000000000000)
+* telegram: Add UseInsecureURL option for telegram (default false)
+  WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+  Those URLs will contain your bot-token. This may not be what you want.
+  For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+* irc: detect charset and try to convert it to utf-8 before sending it to other bridges. #209 #210
+* general: various improvements
+
+
+# v0.16.0-rc1
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## New features
+* steam: New protocol support added (http://store.steampowered.com/)
+* discord: WebhookURL posting support added (thanks @saury07) #204
+  Discord API does not allow to change the name of the user posting, but webhooks does.
+
+## Bugfix
+* general: samechannelgateway now relays messages correct again #207
+* slack: Remove label from URLs (slack). #205
+
+# v0.15.0
+## New features
+* general: add option IgnoreMessages for all protocols (see mattebridge.toml.sample)
+  Messages matching these regexp will be ignored and not sent to other bridges
+  e.g. IgnoreMessages="^~~ badword"
+* telegram: add support for sticker/video/photo/document #184
+
+## Changes
+* api: add userid to each message #200
+
+## Bugfix
+* discord: fix crash in memberupdate #198
+* mattermost: Fix incorrect behaviour of EditDisable (mattermost). Fixes #197 
+* irc: Do not relay join/part of ourselves (irc). Closes #190 
+* irc: make reconnections more robust. #153
+* gitter: update library, fixes possible crash
+
+# v0.14.0
+## New features
+* api: add token authentication
+* mattermost: add support for mattermost 3.10.0
+
+## Changes
+* api: gateway name is added in JSON messages
+* api: lowercase JSON keys
+* api: channel name isn't needed in config #195
+
+## Bugfix
+* discord: Add hashtag to channelname (when translating from id) (discord)
+* mattermost: Fix a panic. #186
+* mattermost: use teamid cache if possible. Fixes a panic
+* api: post valid json. #185
+* api: allow reuse of api in different gateways. #189
+* general: Fix utf-8 issues for {NOPINGNICK}. #193
+
+# v0.13.0
+## New features
+* irc: Limit message length. ```MessageLength=400```
+  Maximum length of message sent to irc server. If it exceeds <message clipped> will be add to the message.
+* irc: Add NOPINGNICK option. 
+  The string "{NOPINGNICK}" (case sensitive) will be replaced by the actual nick / username, but with a ZWSP inside the nick, so the irc user with the same nick won't get pinged.   
+  See https://github.com/42wim/matterbridge/issues/175 for more information
+
+## Bugfix
+* slack: Fix sending to different channels on same account (slack). Closes #177
+* telegram: Fix incorrect usernames being sent. Closes #181
+
+
+# v0.12.1
+## New features
+* telegram: Add UseFirstName option (telegram). Closes #144
+* matrix: Add NoHomeServerSuffix. Option to disable homeserver on username (matrix). Closes #160.
+
+## Bugfix
+* xmpp: Add Compatibility for Cisco Jabber (xmpp) (#166)
+* irc: Fix JoinChannel argument to use IRC channel key (#172)
+* discord: Fix possible crash on nil (discord)
+* discord: Replace long ids in channel metions (discord). Fixes #174
+
+# v0.12.0
+## Changes
+* general: edited messages are now being sent by default on discord/mattermost/telegram/slack. See "New Features"
+
+## New features
+* general: add support for edited messages. 
+  Add new keyword EditDisable (false/true), default false. Which means by default edited messages will be sent to other bridges.
+  Add new keyword EditSuffix , default "". You can change this eg to "(edited)", this will be appended to every edit message.
+* mattermost: support mattermost v3.9.x
+* general: Add support for HTTP{S}_PROXY env variables (#162)
+* discord: Strip custom emoji metadata (discord). Closes #148
+
+## Bugfix
+* slack: Ignore error on private channel join (slack) Fixes #150 
+* mattermost: fix crash on reconnects when server is down. Closes #163
+* irc: Relay messages starting with ! (irc). Closes #164
+
+# v0.11.0
+## New features
+* general: reusing the same account on multiple gateways now also reuses the connection.
+  This is particuarly useful for irc. See #87
+* general: the Name is now REQUIRED and needs to be UNIQUE for each gateway configuration
+* telegram:  Support edited messages (telegram). See #141
+* mattermost: Add support for showing/hiding join/leave messages from mattermost. Closes #147
+* mattermost: Reconnect on session removal/timeout (mattermost)
+* mattermost: Support mattermost v3.8.x
+* irc:  Rejoin channel when kicked (irc).
+
+## Bugfix
+* mattermost: Remove space after nick (mattermost). Closes #142
+* mattermost: Modify iconurl correctly (mattermost).
+* irc: Fix join/leave regression (irc)
+
+# v0.10.3
+## Bugfix
+* slack: Allow bot tokens for now without warning (slack). Closes #140 (fixes user_is_bot message on channel join)
+
+# v0.10.2
+## New features
+* general: gops agent added. Allows for more debugging. See #134
+* general: toml inline table support added for config file
+
+## Bugfix
+* all: vendored libs updated
+
+## Changes
+* general: add more informative messages on startup
+
+# v0.10.1
+## Bugfix
+* gitter: Fix sending messages on new channel join.
+
+# v0.10.0
+## New features
+* matrix: New protocol support added (https://matrix.org)
+* mattermost: works with mattermost release v3.7.0
+* discord: Replace role ids in mentions to role names (discord). Closes #133
+
+## Bugfix
+* mattermost: Add ReadTimeout to close lingering connections (mattermost). See #125
+* gitter: Join rooms not already joined by the bot (gitter). See #135
+* general: Fail when bridge is unable to join a channel (general)
+
+## Changes
+* telegram: Do not use HTML parsemode by default. Set ```MessageFormat="HTML"``` to use it. Closes #126
+
+# v0.9.3
+## New features
+* API: rest interface to read / post messages (see API section in matterbridge.toml.sample)
+
+## Bugfix
+* slack: fix receiving messages from private channels #118
+* slack: fix echo when using webhooks #119
+* mattermost: reconnecting should work better now
+* irc: keeps reconnecting (every 60 seconds) now after ping timeout/disconnects.
+
+# v0.9.2
+## New features
+* slack: support private channels #118
+
+## Bugfix
+* general: make ignorenicks work again #115
+* telegram: fix receiving from channels and groups #112
+* telegram: use html for username
+* telegram: use ```unknown``` as username when username is not visible.
+* irc: update vendor (fixes some crashes) #117
+* xmpp: fix tls by setting ServerName #114
+
+# v0.9.1
+## New features
+* Rocket.Chat: New protocol support added (https://rocket.chat)
+* irc: add channel key support #27 (see matterbrige.toml.sample for example)
+* xmpp: add SkipTLSVerify #106
+
+## Bugfix
+* general: Exit when a bridge fails to start
+* mattermost: Check errors only on first connect. Keep retrying after first connection succeeds. #95
+* telegram: fix missing username #102
+* slack: do not use API functions in webhook (slack) #110
+
+# v0.9.0
+## New features
+* Telegram: New protocol support added (https://telegram.org)
+* Hipchat: Add sample config to connect to hipchat via xmpp
+* discord: add "Bot " tag to discord tokens automatically
+* slack: Add support for dynamic Iconurl #43
+* general: Add ```gateway.inout``` config option for bidirectional bridges #85
+* general: Add ```[general]``` section so that ```RemoteNickFormat``` can be set globally
+
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* general: fix ShowJoinPart for messages from irc bridge #72
+* gitter: fix high cpu usage #89
+* irc: fix !users command #78
+* xmpp: fix keepalive
+* xmpp: do not relay delayed/empty messages
+* slack: Replace id-mentions to usernames #86 
+* mattermost: fix public links not working (API changes)
+
+# v0.8.1
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* irc: fix !users command #78
+
+# v0.8.0
+Release because of breaking mattermost API changes
+## New features
+* Supports mattermost v3.5.0
+
+# v0.7.1
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* irc: fix !users command #78
+
+# v0.7.0
+## Breaking config changes from 0.6 to 0.7
+Matterbridge now uses TOML configuration (https://github.com/toml-lang/toml)
+See matterbridge.toml.sample for an example
+
+## New features
+### General
+* Allow for bridging the same type of bridge, which means you can eg bridge between multiple mattermosts.
+* The bridge is now actually a gateway which has support multiple in and out bridges. (and supports multiple gateways).
+* Discord support added. See matterbridge.toml.sample for more information.
+* Samechannelgateway support added, easier configuration for 1:1 mapping of protocols with same channel names. #35
+* Support for override from environment variables. #50
+* Better debugging output.
+* discord: New protocol support added. (http://www.discordapp.com)
+* mattermost: Support attachments.
+* irc: Strip colors. #33
+* irc: Anti-flooding support. #40
+* irc: Forward channel notices.
+
+## Bugfix
+* irc: Split newlines. #37
+* irc: Only respond to nick related notices from nickserv.
+* irc: Ignore queries send to the bot.
+* irc: Ignore messages from ourself.
+* irc: Only output the "users on irc information" when asked with "!users".
+* irc: Actually wait until connection is complete before saying it is.
+* mattermost: Fix mattermost channel joins.
+* mattermost: Drop messages not from our team.
+* slack: Do not panic on non-existing channels.
+* general: Exit when a bridge fails to start.
+
+# v0.6.1
+## New features
+* Slack support added.  See matterbridge.conf.sample for more information
+
+## Bugfix
+* Fix 100% CPU bug on incorrect closed connections
+
+# v0.6.0-beta2
+## New features
+* Gitter support added.  See matterbridge.conf.sample for more information
+
+# v0.6.0-beta1
+## Breaking changes from 0.5 to 0.6
+### commandline
+* -plus switch deprecated. Use ```Plus=true``` or ```Plus``` in ```[general]``` section
+
+### IRC section
+* ```Enabled``` added (default false)  
+Add ```Enabled=true``` or ```Enabled``` to the ```[IRC]``` section if you want to enable the IRC bridge
+
+### Mattermost section
+* ```Enabled``` added (default false)  
+Add ```Enabled=true``` or ```Enabled``` to the ```[mattermost]``` section if you want to enable the mattermost bridge
+
+### General section
+* Use ```Plus=true``` or ```Plus``` in ```[general]``` section to enable the API version of matterbridge
+
+## New features
+* Matterbridge now bridges between any specified protocol (not only mattermost anymore) 
+* XMPP support added.  See matterbridge.conf.sample for more information
+* RemoteNickFormat {BRIDGE} variable added  
+You can now add the originating bridge to ```RemoteNickFormat```  
+eg ```RemoteNickFormat="[{BRIDGE}] <{NICK}> "```
+
+
+# v0.5.0
+## Breaking changes from 0.4 to 0.5 for matterbridge (webhooks version)
+### IRC section
+#### Server
+Port removed, added to server
+```
+server="irc.freenode.net"
+port=6667
+```
+changed to
+```
+server="irc.freenode.net:6667"
+```
+#### Channel
+Removed see Channels section below
+
+#### UseSlackCircumfix=true
+Removed, can be done by using ```RemoteNickFormat="<{NICK}> "```
+
+### Mattermost section
+#### BindAddress
+Port removed, added to BindAddress
+
+```
+BindAddress="0.0.0.0"
+port=9999
+```
+
+changed to
+
+```
+BindAddress="0.0.0.0:9999"
+```
+
+#### Token
+Removed
+
+### Channels section
+```
+[Token "outgoingwebhooktoken1"] 
+IRCChannel="#off-topic"
+MMChannel="off-topic"
+```
+
+changed to
+
+```
+[Channel "channelnameofchoice"] 
+IRC="#off-topic"
+Mattermost="off-topic"
+```

ci/bintray.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+go version |grep go1.10 || exit
+VERSION=$(git describe --tags)
+mkdir ci/binaries
+GOOS=windows GOARCH=amd64 go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-windows-amd64.exe
+GOOS=linux GOARCH=amd64 go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-linux-amd64
+GOOS=linux GOARCH=arm go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-linux-arm
+GOOS=darwin GOARCH=amd64 go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-darwin-amd64
+cd ci
+cat > deploy.json <<EOF
+{
+    "package": {
+        "name": "Matterbridge",
+        "repo": "nightly",
+        "subject": "42wim"
+    },
+    "version": {
+        "name": "$VERSION"
+    },
+    "files":
+        [
+        {"includePattern": "ci/binaries/(.*)", "uploadPattern":"\$1"}
+        ],
+    "publish": true
+}
+EOF
+

config.go

@@ -1,50 +0,0 @@
-package main
-
-import (
-	"gopkg.in/gcfg.v1"
-	"io/ioutil"
-	"log"
-)
-
-type Config struct {
-	IRC struct {
-		UseTLS            bool
-		SkipTLSVerify     bool
-		Server            string
-		Port              int
-		Nick              string
-		Password          string
-		Channel           string
-		UseSlackCircumfix bool
-	}
-	Mattermost struct {
-		URL           string
-		Port          int
-		ShowJoinPart  bool
-		Token         string
-		IconURL       string
-		SkipTLSVerify bool
-		BindAddress   string
-		Channel       string
-	}
-	Token map[string]*struct {
-		IRCChannel string
-		MMChannel  string
-	}
-	General struct {
-		GiphyAPIKey string
-	}
-}
-
-func NewConfig(cfgfile string) *Config {
-	var cfg Config
-	content, err := ioutil.ReadFile(cfgfile)
-	if err != nil {
-		log.Fatal(err)
-	}
-	err = gcfg.ReadStringInto(&cfg, string(content))
-	if err != nil {
-		log.Fatal("Failed to parse "+cfgfile+":", err)
-	}
-	return &cfg
-}

contrib/matterbridge.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=matterbridge
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/matterbridge -conf /etc/matterbridge/bridge.toml
+User=matterbridge
+Group=matterbridge
+
+[Install]
+WantedBy=multi-user.target

docker/arm/Dockerfile

@@ -0,0 +1,11 @@
+FROM cmosh/alpine-arm:edge
+ENTRYPOINT ["/bin/matterbridge"]
+
+COPY . /go/src/github.com/42wim/matterbridge
+RUN apk update && apk add go git gcc musl-dev ca-certificates \
+        && cd /go/src/github.com/42wim/matterbridge \
+        && export GOPATH=/go \
+        && go get \
+        && go build -x -ldflags "-X main.githash=$(git log --pretty=format:'%h' -n 1)" -o /bin/matterbridge \
+        && rm -rf /go \
+        && apk del --purge git go gcc musl-dev

gateway/gateway.go

@@ -0,0 +1,508 @@
+package gateway
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/api"
+	"github.com/42wim/matterbridge/bridge/config"
+	bdiscord "github.com/42wim/matterbridge/bridge/discord"
+	bgitter "github.com/42wim/matterbridge/bridge/gitter"
+	birc "github.com/42wim/matterbridge/bridge/irc"
+	bmatrix "github.com/42wim/matterbridge/bridge/matrix"
+	bmattermost "github.com/42wim/matterbridge/bridge/mattermost"
+	brocketchat "github.com/42wim/matterbridge/bridge/rocketchat"
+	bslack "github.com/42wim/matterbridge/bridge/slack"
+	bsshchat "github.com/42wim/matterbridge/bridge/sshchat"
+	bsteam "github.com/42wim/matterbridge/bridge/steam"
+	btelegram "github.com/42wim/matterbridge/bridge/telegram"
+	bxmpp "github.com/42wim/matterbridge/bridge/xmpp"
+	bzulip "github.com/42wim/matterbridge/bridge/zulip"
+	"github.com/hashicorp/golang-lru"
+	log "github.com/sirupsen/logrus"
+	//	"github.com/davecgh/go-spew/spew"
+	"crypto/sha1"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/peterhellberg/emojilib"
+)
+
+type Gateway struct {
+	*config.Config
+	Router         *Router
+	MyConfig       *config.Gateway
+	Bridges        map[string]*bridge.Bridge
+	Channels       map[string]*config.ChannelInfo
+	ChannelOptions map[string]config.ChannelOptions
+	Message        chan config.Message
+	Name           string
+	Messages       *lru.Cache
+}
+
+type BrMsgID struct {
+	br        *bridge.Bridge
+	ID        string
+	ChannelID string
+}
+
+var flog *log.Entry
+
+var bridgeMap = map[string]bridge.Factory{
+	"api":        api.New,
+	"discord":    bdiscord.New,
+	"gitter":     bgitter.New,
+	"irc":        birc.New,
+	"mattermost": bmattermost.New,
+	"matrix":     bmatrix.New,
+	"rocketchat": brocketchat.New,
+	"slack":      bslack.New,
+	"sshchat":    bsshchat.New,
+	"steam":      bsteam.New,
+	"telegram":   btelegram.New,
+	"xmpp":       bxmpp.New,
+	"zulip":      bzulip.New,
+}
+
+func init() {
+	flog = log.WithFields(log.Fields{"prefix": "gateway"})
+}
+
+func New(cfg config.Gateway, r *Router) *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
+	gw.AddConfig(&cfg)
+	return gw
+}
+
+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.General
+		// set logging
+		br.Log = log.WithFields(log.Fields{"prefix": "bridge"})
+		brconfig := &bridge.Config{Remote: gw.Message, Log: log.WithFields(log.Fields{"prefix": br.Protocol}), Bridge: br}
+		// add the actual bridger for this protocol to this bridge using the bridgeMap
+		br.Bridger = bridgeMap[br.Protocol](brconfig)
+	}
+	gw.mapChannelsToBridge(br)
+	gw.Bridges[cfg.Account] = br
+	return nil
+}
+
+func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
+	gw.Name = cfg.Name
+	gw.MyConfig = cfg
+	gw.mapChannels()
+	for _, br := range append(gw.MyConfig.In, append(gw.MyConfig.InOut, gw.MyConfig.Out...)...) {
+		err := gw.AddBridge(&br)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
+	for ID, channel := range gw.Channels {
+		if br.Account == channel.Account {
+			br.Channels[ID] = *channel
+		}
+	}
+}
+
+func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
+	br.Disconnect()
+	time.Sleep(time.Second * 5)
+RECONNECT:
+	flog.Infof("Reconnecting %s", br.Account)
+	err := br.Connect()
+	if err != nil {
+		flog.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
+		time.Sleep(time.Second * 60)
+		goto RECONNECT
+	}
+	br.Joined = make(map[string]bool)
+	br.JoinChannels()
+}
+
+func (gw *Gateway) mapChannelConfig(cfg []config.Bridge, direction string) {
+	for _, br := range cfg {
+		if isApi(br.Account) {
+			br.Channel = "api"
+		}
+		// make sure to lowercase irc channels in config #348
+		if strings.HasPrefix(br.Account, "irc.") {
+			br.Channel = strings.ToLower(br.Channel)
+		}
+		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.SameChannel[gw.Name] = br.SameChannel
+			gw.Channels[channel.ID] = channel
+		} else {
+			// if we already have a key and it's not our current direction it means we have a bidirectional inout
+			if gw.Channels[ID].Direction != direction {
+				gw.Channels[ID].Direction = "inout"
+			}
+		}
+		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
+	}
+}
+
+func (gw *Gateway) mapChannels() error {
+	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
+	return nil
+}
+
+func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
+	var channels []config.ChannelInfo
+
+	// for messages received from the api check that the gateway is the specified one
+	if msg.Protocol == "api" && gw.Name != msg.Gateway {
+		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) {
+			// we only have destinations if the original message is from an "in" (sending) channel
+			if !strings.Contains(channel.Direction, "in") {
+				return channels
+			}
+			continue
+		}
+	}
+	for _, channel := range gw.Channels {
+		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
+			continue
+		}
+
+		// do samechannelgateway flogic
+		if channel.SameChannel[msg.Gateway] {
+			if msg.Channel == channel.Name && msg.Account != dest.Account {
+				channels = append(channels, *channel)
+			}
+			continue
+		}
+		if strings.Contains(channel.Direction, "out") && channel.Account == dest.Account && gw.validGatewayDest(msg, channel) {
+			channels = append(channels, *channel)
+		}
+	}
+	return channels
+}
+
+func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) []*BrMsgID {
+	var brMsgIDs []*BrMsgID
+
+	// if we have an attached file, or other info
+	if msg.Extra != nil {
+		if len(msg.Extra[config.EVENT_FILE_FAILURE_SIZE]) != 0 {
+			if msg.Text == "" {
+				return brMsgIDs
+			}
+		}
+	}
+
+	// Avatar downloads are only relevant for telegram and mattermost for now
+	if msg.Event == config.EVENT_AVATAR_DOWNLOAD {
+		if dest.Protocol != "mattermost" &&
+			dest.Protocol != "telegram" {
+			return brMsgIDs
+		}
+	}
+
+	// only relay join/part when configured
+	if msg.Event == config.EVENT_JOIN_LEAVE && !gw.Bridges[dest.Account].GetBool("ShowJoinPart") {
+		return brMsgIDs
+	}
+
+	// only relay topic change when configured
+	if msg.Event == config.EVENT_TOPIC_CHANGE && !gw.Bridges[dest.Account].GetBool("ShowTopicChange") {
+		return brMsgIDs
+	}
+
+	// broadcast to every out channel (irc QUIT)
+	if msg.Channel == "" && msg.Event != config.EVENT_JOIN_LEAVE {
+		flog.Debug("empty channel")
+		return brMsgIDs
+	}
+
+	originchannel := msg.Channel
+	origmsg := msg
+	channels := gw.getDestChannel(&msg, *dest)
+	for _, channel := range channels {
+		// Only send the avatar download event to ourselves.
+		if msg.Event == config.EVENT_AVATAR_DOWNLOAD {
+			if channel.ID != getChannelID(origmsg) {
+				continue
+			}
+		} else {
+			// do not send to ourself for any other event
+			if channel.ID == getChannelID(origmsg) {
+				continue
+			}
+		}
+		flog.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel.Name)
+		msg.Channel = channel.Name
+		msg.Avatar = gw.modifyAvatar(origmsg, dest)
+		msg.Username = gw.modifyUsername(origmsg, dest)
+		msg.ID = ""
+		if res, ok := gw.Messages.Get(origmsg.ID); ok {
+			IDs := res.([]*BrMsgID)
+			for _, id := range IDs {
+				// check protocol, bridge name and channelname
+				// for people that reuse the same bridge multiple times. see #342
+				if dest.Protocol == id.br.Protocol && dest.Name == id.br.Name && channel.ID == id.ChannelID {
+					msg.ID = id.ID
+				}
+			}
+		}
+		// for api we need originchannel as channel
+		if dest.Protocol == "api" {
+			msg.Channel = originchannel
+		}
+		mID, err := dest.Send(msg)
+		if err != nil {
+			flog.Error(err)
+		}
+		// append the message ID (mID) from this bridge (dest) to our brMsgIDs slice
+		if mID != "" {
+			flog.Debugf("mID %s: %s", dest.Account, mID)
+			brMsgIDs = append(brMsgIDs, &BrMsgID{dest, mID, channel.ID})
+		}
+	}
+	return brMsgIDs
+}
+
+func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
+	// if we don't have the bridge, ignore it
+	if _, ok := gw.Bridges[msg.Account]; !ok {
+		return true
+	}
+
+	// check if we need to ignore a empty message
+	if msg.Text == "" {
+		// we have an attachment or actual bytes, do not ignore
+		if msg.Extra != nil &&
+			(msg.Extra["attachments"] != nil ||
+				len(msg.Extra["file"]) > 0 ||
+				len(msg.Extra[config.EVENT_FILE_FAILURE_SIZE]) > 0) {
+			return false
+		}
+		flog.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
+		return true
+	}
+
+	// is the username in IgnoreNicks field
+	for _, entry := range strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreNicks")) {
+		if msg.Username == entry {
+			flog.Debugf("ignoring %s from %s", msg.Username, msg.Account)
+			return true
+		}
+	}
+
+	// does the message match regex in IgnoreMessages field
+	// TODO do not compile regexps everytime
+	for _, entry := range strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreMessages")) {
+		if entry != "" {
+			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
+}
+
+func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) string {
+	br := gw.Bridges[msg.Account]
+	msg.Protocol = br.Protocol
+	if gw.Config.General.StripNick || dest.GetBool("StripNick") {
+		re := regexp.MustCompile("[^a-zA-Z0-9]+")
+		msg.Username = re.ReplaceAllString(msg.Username, "")
+	}
+	nick := dest.GetString("RemoteNickFormat")
+	if nick == "" {
+		nick = gw.Config.General.RemoteNickFormat
+	}
+
+	// loop to replace nicks
+	for _, outer := range br.GetStringSlice2D("ReplaceNicks") {
+		search := outer[0]
+		replace := outer[1]
+		// 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)
+			break
+		}
+		msg.Username = re.ReplaceAllString(msg.Username, replace)
+	}
+
+	if len(msg.Username) > 0 {
+		// fix utf-8 issue #193
+		i := 0
+		for index := range msg.Username {
+			if i == 1 {
+				i = index
+				break
+			}
+			i++
+		}
+		nick = strings.Replace(nick, "{NOPINGNICK}", msg.Username[:i]+"​"+msg.Username[i:], -1)
+	}
+
+	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
+	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
+	nick = strings.Replace(nick, "{LABEL}", br.GetString("Label"), -1)
+	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
+	return nick
+}
+
+func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string {
+	iconurl := gw.Config.General.IconURL
+	if iconurl == "" {
+		iconurl = dest.GetString("IconURL")
+	}
+	iconurl = strings.Replace(iconurl, "{NICK}", msg.Username, -1)
+	if msg.Avatar == "" {
+		msg.Avatar = iconurl
+	}
+	return msg.Avatar
+}
+
+func (gw *Gateway) modifyMessage(msg *config.Message) {
+	// replace :emoji: to unicode
+	msg.Text = emojilib.Replace(msg.Text)
+
+	br := gw.Bridges[msg.Account]
+	// loop to replace messages
+	for _, outer := range br.GetStringSlice2D("ReplaceMessages") {
+		search := outer[0]
+		replace := outer[1]
+		// 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)
+			break
+		}
+		msg.Text = re.ReplaceAllString(msg.Text, replace)
+	}
+
+	// messages from api have Gateway specified, don't overwrite
+	if msg.Protocol != "api" {
+		msg.Gateway = gw.Name
+	}
+}
+
+// handleFiles uploads or places all files on the given msg to the MediaServer and
+// adds the new URL of the file on the MediaServer onto the given msg.
+func (gw *Gateway) handleFiles(msg *config.Message) {
+	reg := regexp.MustCompile("[^a-zA-Z0-9]+")
+
+	// If we don't have a attachfield or we don't have a mediaserver configured return
+	if msg.Extra == nil || (gw.Config.General.MediaServerUpload == "" && gw.Config.General.MediaDownloadPath == "") {
+		return
+	}
+
+	// If we don't have files, nothing to upload.
+	if len(msg.Extra["file"]) == 0 {
+		return
+	}
+
+	client := &http.Client{
+		Timeout: time.Second * 5,
+	}
+
+	for i, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		ext := filepath.Ext(fi.Name)
+		fi.Name = fi.Name[0 : len(fi.Name)-len(ext)]
+		fi.Name = reg.ReplaceAllString(fi.Name, "_")
+		fi.Name = fi.Name + ext
+
+		sha1sum := fmt.Sprintf("%x", sha1.Sum(*fi.Data))[:8]
+
+		if gw.Config.General.MediaServerUpload != "" {
+			// Use MediaServerUpload. Upload using a PUT HTTP request and basicauth.
+
+			url := gw.Config.General.MediaServerUpload + "/" + sha1sum + "/" + fi.Name
+
+			req, err := http.NewRequest("PUT", url, bytes.NewReader(*fi.Data))
+			if err != nil {
+				flog.Errorf("mediaserver upload failed, could not create request: %#v", err)
+				continue
+			}
+
+			flog.Debugf("mediaserver upload url: %s", url)
+
+			req.Header.Set("Content-Type", "binary/octet-stream")
+			_, err = client.Do(req)
+			if err != nil {
+				flog.Errorf("mediaserver upload failed, could not Do request: %#v", err)
+				continue
+			}
+		} else {
+			// Use MediaServerPath. Place the file on the current filesystem.
+
+			dir := gw.Config.General.MediaDownloadPath + "/" + sha1sum
+			err := os.Mkdir(dir, os.ModePerm)
+			if err != nil && !os.IsExist(err) {
+				flog.Errorf("mediaserver path failed, could not mkdir: %s %#v", err, err)
+				continue
+			}
+
+			path := dir + "/" + fi.Name
+			flog.Debugf("mediaserver path placing file: %s", path)
+
+			err = ioutil.WriteFile(path, *fi.Data, os.ModePerm)
+			if err != nil {
+				flog.Errorf("mediaserver path failed, could not writefile: %s %#v", err, err)
+				continue
+			}
+		}
+
+		// Download URL.
+		durl := gw.Config.General.MediaServerDownload + "/" + sha1sum + "/" + fi.Name
+
+		flog.Debugf("mediaserver download URL = %s", durl)
+
+		// We uploaded/placed the file successfully. Add the SHA and URL.
+		extra := msg.Extra["file"][i].(config.FileInfo)
+		extra.URL = durl
+		extra.SHA = sha1sum
+		msg.Extra["file"][i] = extra
+	}
+}
+
+func (gw *Gateway) validGatewayDest(msg *config.Message, channel *config.ChannelInfo) bool {
+	return msg.Gateway == gw.Name
+}
+
+func getChannelID(msg config.Message) string {
+	return msg.Channel + msg.Account
+}
+
+func isApi(account string) bool {
+	return strings.HasPrefix(account, "api.")
+}

gateway/gateway_test.go

@@ -0,0 +1,279 @@
+package gateway
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+var testconfig = []byte(`
+[irc.freenode]
+[mattermost.test]
+[gitter.42wim]
+[discord.test]
+[slack.test]
+
+[[gateway]]
+    name = "bridge1"
+    enable=true
+    
+    [[gateway.inout]]
+    account = "irc.freenode"
+    channel = "#wimtesting"
+    
+    [[gateway.inout]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+    #channel="matterbridge/Lobby"
+
+    [[gateway.inout]]
+    account = "discord.test"
+    channel = "general"
+    
+    [[gateway.inout]]
+    account="slack.test"
+    channel="testing"
+	`)
+
+var testconfig2 = []byte(`
+[irc.freenode]
+[mattermost.test]
+[gitter.42wim]
+[discord.test]
+[slack.test]
+
+[[gateway]]
+    name = "bridge1"
+    enable=true
+    
+    [[gateway.in]]
+    account = "irc.freenode"
+    channel = "#wimtesting"
+    
+    [[gateway.in]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+
+    [[gateway.inout]]
+    account = "discord.test"
+    channel = "general"
+    
+    [[gateway.out]]
+    account="slack.test"
+    channel="testing"
+[[gateway]]
+    name = "bridge2"
+    enable=true
+    
+    [[gateway.in]]
+    account = "irc.freenode"
+    channel = "#wimtesting2"
+    
+    [[gateway.out]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+
+    [[gateway.out]]
+    account = "discord.test"
+    channel = "general2"
+	`)
+
+var testconfig3 = []byte(`
+[irc.zzz]
+[telegram.zzz]
+[slack.zzz]
+[[gateway]]
+name="bridge"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main"		
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="-1111111111111"
+
+    [[gateway.inout]]
+    account="slack.zzz"
+    channel="irc"	
+	
+[[gateway]]
+name="announcements"
+enable=true
+	
+    [[gateway.in]]
+    account="telegram.zzz"
+    channel="-2222222222222"	
+	
+    [[gateway.out]]
+    account="irc.zzz"
+    channel="#main"		
+	
+    [[gateway.out]]
+    account="irc.zzz"
+    channel="#main-help"	
+
+    [[gateway.out]]
+    account="telegram.zzz"
+    channel="--333333333333"	
+
+    [[gateway.out]]
+    account="slack.zzz"
+    channel="general"		
+	
+[[gateway]]
+name="bridge2"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main-help"	
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="--444444444444"	
+
+	
+[[gateway]]
+name="bridge3"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main-telegram"	
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="--333333333333"
+`)
+
+func maketestRouter(input []byte) *Router {
+	cfg := config.NewConfigFromString(input)
+	r, err := NewRouter(cfg)
+	if err != nil {
+		fmt.Println(err)
+	}
+	return r
+}
+func TestNewRouter(t *testing.T) {
+	r := maketestRouter(testconfig)
+	assert.Equal(t, 1, len(r.Gateways))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Bridges))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Channels))
+
+	r = maketestRouter(testconfig2)
+	assert.Equal(t, 2, len(r.Gateways))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Bridges))
+	assert.Equal(t, 3, len(r.Gateways["bridge2"].Bridges))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Channels))
+	assert.Equal(t, 3, len(r.Gateways["bridge2"].Channels))
+	assert.Equal(t, &config.ChannelInfo{Name: "42wim/testroom", Direction: "out",
+		ID: "42wim/testroomgitter.42wim", Account: "gitter.42wim",
+		SameChannel: map[string]bool{"bridge2": false}},
+		r.Gateways["bridge2"].Channels["42wim/testroomgitter.42wim"])
+	assert.Equal(t, &config.ChannelInfo{Name: "42wim/testroom", Direction: "in",
+		ID: "42wim/testroomgitter.42wim", Account: "gitter.42wim",
+		SameChannel: map[string]bool{"bridge1": false}},
+		r.Gateways["bridge1"].Channels["42wim/testroomgitter.42wim"])
+	assert.Equal(t, &config.ChannelInfo{Name: "general", Direction: "inout",
+		ID: "generaldiscord.test", Account: "discord.test",
+		SameChannel: map[string]bool{"bridge1": false}},
+		r.Gateways["bridge1"].Channels["generaldiscord.test"])
+}
+
+func TestGetDestChannel(t *testing.T) {
+	r := maketestRouter(testconfig2)
+	msg := &config.Message{Text: "test", Channel: "general", Account: "discord.test", Gateway: "bridge1", Protocol: "discord", Username: "test"}
+	for _, br := range r.Gateways["bridge1"].Bridges {
+		switch br.Account {
+		case "discord.test":
+			assert.Equal(t, []config.ChannelInfo{{Name: "general", Account: "discord.test", Direction: "inout", ID: "generaldiscord.test", SameChannel: map[string]bool{"bridge1": false}, Options: config.ChannelOptions{Key: ""}}},
+				r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "slack.test":
+			assert.Equal(t, []config.ChannelInfo{{Name: "testing", Account: "slack.test", Direction: "out", ID: "testingslack.test", SameChannel: map[string]bool{"bridge1": false}, Options: config.ChannelOptions{Key: ""}}},
+				r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "gitter.42wim":
+			assert.Equal(t, []config.ChannelInfo(nil), r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "irc.freenode":
+			assert.Equal(t, []config.ChannelInfo(nil), r.Gateways["bridge1"].getDestChannel(msg, *br))
+		}
+	}
+}
+
+func TestGetDestChannelAdvanced(t *testing.T) {
+	r := maketestRouter(testconfig3)
+	var msgs []*config.Message
+	i := 0
+	for _, gw := range r.Gateways {
+		for _, channel := range gw.Channels {
+			msgs = append(msgs, &config.Message{Text: "text" + strconv.Itoa(i), Channel: channel.Name, Account: channel.Account, Gateway: gw.Name, Username: "user" + strconv.Itoa(i)})
+			i++
+		}
+	}
+	hits := make(map[string]int)
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			for _, msg := range msgs {
+				channels := gw.getDestChannel(msg, *br)
+				if gw.Name != msg.Gateway {
+					assert.Equal(t, []config.ChannelInfo(nil), channels)
+					continue
+				}
+				switch gw.Name {
+				case "bridge":
+					if (msg.Channel == "#main" || msg.Channel == "-1111111111111" || msg.Channel == "irc") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz" || msg.Account == "slack.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main", Account: "irc.zzz", Direction: "inout", ID: "#mainirc.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "-1111111111111", Account: "telegram.zzz", Direction: "inout", ID: "-1111111111111telegram.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "slack.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "irc", Account: "slack.zzz", Direction: "inout", ID: "ircslack.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "bridge2":
+					if (msg.Channel == "#main-help" || msg.Channel == "--444444444444") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main-help", Account: "irc.zzz", Direction: "inout", ID: "#main-helpirc.zzz", SameChannel: map[string]bool{"bridge2": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "--444444444444", Account: "telegram.zzz", Direction: "inout", ID: "--444444444444telegram.zzz", SameChannel: map[string]bool{"bridge2": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "bridge3":
+					if (msg.Channel == "#main-telegram" || msg.Channel == "--333333333333") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main-telegram", Account: "irc.zzz", Direction: "inout", ID: "#main-telegramirc.zzz", SameChannel: map[string]bool{"bridge3": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "--333333333333", Account: "telegram.zzz", Direction: "inout", ID: "--333333333333telegram.zzz", SameChannel: map[string]bool{"bridge3": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "announcements":
+					if msg.Channel != "-2222222222222" && msg.Account != "telegram" {
+						assert.Equal(t, []config.ChannelInfo(nil), channels)
+						continue
+					}
+					hits[gw.Name]++
+					switch br.Account {
+					case "irc.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "#main", Account: "irc.zzz", Direction: "out", ID: "#mainirc.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}, {Name: "#main-help", Account: "irc.zzz", Direction: "out", ID: "#main-helpirc.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					case "slack.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "general", Account: "slack.zzz", Direction: "out", ID: "generalslack.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					case "telegram.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "--333333333333", Account: "telegram.zzz", Direction: "out", ID: "--333333333333telegram.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					}
+				}
+			}
+		}
+	}
+	assert.Equal(t, map[string]int{"bridge3": 4, "bridge": 9, "announcements": 3, "bridge2": 4}, hits)
+}

gateway/router.go

@@ -0,0 +1,111 @@
+package gateway
+
+import (
+	"fmt"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	samechannelgateway "github.com/42wim/matterbridge/gateway/samechannel"
+	//	"github.com/davecgh/go-spew/spew"
+	"time"
+)
+
+type Router struct {
+	Gateways map[string]*Gateway
+	Message  chan config.Message
+	*config.Config
+}
+
+func NewRouter(cfg *config.Config) (*Router, error) {
+	r := &Router{Message: make(chan config.Message), Gateways: make(map[string]*Gateway), Config: cfg}
+	sgw := samechannelgateway.New(cfg)
+	gwconfigs := sgw.GetConfig()
+
+	for _, entry := range append(gwconfigs, cfg.Gateway...) {
+		if !entry.Enable {
+			continue
+		}
+		if entry.Name == "" {
+			return nil, fmt.Errorf("%s", "Gateway without name found")
+		}
+		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)
+	}
+	return r, nil
+}
+
+func (r *Router) Start() error {
+	m := make(map[string]*bridge.Bridge)
+	for _, gw := range r.Gateways {
+		flog.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)
+		err := br.Connect()
+		if err != nil {
+			return fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
+		}
+		err = br.JoinChannels()
+		if err != nil {
+			return fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
+		}
+	}
+	go r.handleReceive()
+	return nil
+}
+
+func (r *Router) getBridge(account string) *bridge.Bridge {
+	for _, gw := range r.Gateways {
+		if br, ok := gw.Bridges[account]; ok {
+			return br
+		}
+	}
+	return nil
+}
+
+func (r *Router) handleReceive() {
+	for msg := range r.Message {
+		if msg.Event == config.EVENT_FAILURE {
+		Loop:
+			for _, gw := range r.Gateways {
+				for _, br := range gw.Bridges {
+					if msg.Account == br.Account {
+						go gw.reconnectBridge(br)
+						break Loop
+					}
+				}
+			}
+		}
+		if msg.Event == config.EVENT_REJOIN_CHANNELS {
+			for _, gw := range r.Gateways {
+				for _, br := range gw.Bridges {
+					if msg.Account == br.Account {
+						br.Joined = make(map[string]bool)
+						br.JoinChannels()
+					}
+				}
+			}
+		}
+		for _, gw := range r.Gateways {
+			// record all the message ID's of the different bridges
+			var msgIDs []*BrMsgID
+			if !gw.ignoreMessage(&msg) {
+				msg.Timestamp = time.Now()
+				gw.modifyMessage(&msg)
+				gw.handleFiles(&msg)
+				for _, br := range gw.Bridges {
+					msgIDs = append(msgIDs, gw.handleMessage(msg, br)...)
+				}
+				// only add the message ID if it doesn't already exists
+				if _, ok := gw.Messages.Get(msg.ID); !ok && msg.ID != "" {
+					gw.Messages.Add(msg.ID, msgIDs)
+				}
+			}
+		}
+	}
+}

gateway/samechannel/samechannel.go

@@ -0,0 +1,28 @@
+package samechannelgateway
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+)
+
+type SameChannelGateway struct {
+	*config.Config
+}
+
+func New(cfg *config.Config) *SameChannelGateway {
+	return &SameChannelGateway{Config: cfg}
+}
+
+func (sgw *SameChannelGateway) GetConfig() []config.Gateway {
+	var gwconfigs []config.Gateway
+	cfg := sgw.Config
+	for _, gw := range cfg.SameChannelGateway {
+		gwconfig := config.Gateway{Name: gw.Name, Enable: gw.Enable}
+		for _, account := range gw.Accounts {
+			for _, channel := range gw.Channels {
+				gwconfig.InOut = append(gwconfig.InOut, config.Bridge{Account: account, Channel: channel, SameChannel: true})
+			}
+		}
+		gwconfigs = append(gwconfigs, gwconfig)
+	}
+	return gwconfigs
+}

gateway/samechannel/samechannel_test.go

@@ -0,0 +1,32 @@
+package samechannelgateway
+
+import (
+	"fmt"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/BurntSushi/toml"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+var testconfig = `
+[mattermost.test]
+[slack.test]
+
+[[samechannelgateway]]
+   enable = true
+   name = "blah"
+      accounts = [ "mattermost.test","slack.test" ]
+      channels = [ "testing","testing2","testing10"]
+`
+
+func TestGetConfig(t *testing.T) {
+	var cfg *config.Config
+	if _, err := toml.Decode(testconfig, &cfg); err != nil {
+		fmt.Println(err)
+	}
+	sgw := New(cfg)
+	configs := sgw.GetConfig()
+	assert.Equal(t, []config.Gateway{{Name: "blah", Enable: true, In: []config.Bridge(nil), Out: []config.Bridge(nil), InOut: []config.Bridge{{Account: "mattermost.test", Channel: "testing", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "mattermost.test", Channel: "testing2", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "mattermost.test", Channel: "testing10", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing2", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing10", Options: config.ChannelOptions{Key: ""}, SameChannel: true}}}}, configs)
+}

go.mod

@@ -0,0 +1,83 @@
+module github.com/42wim/matterbridge
+
+require (
+	github.com/42wim/go-gitter v0.0.0-20170828205020-017310c2d557
+	github.com/BurntSushi/toml v0.0.0-20170318202913-d94612f9fc14
+	github.com/Philipp15b/go-steam v0.0.0-20161020161927-e0f3bb9566e3
+	github.com/Sirupsen/logrus v1.0.6 // indirect
+	github.com/alecthomas/log4go v0.0.0-20160307011253-e5dc62318d9b // indirect
+	github.com/bwmarrin/discordgo v0.0.0-20180201002541-8d5ab59c63e5 // indirect
+	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/dfordsoft/golib v0.0.0-20180313113957-2ea3495aee1d
+	github.com/dgrijalva/jwt-go v0.0.0-20170508165458-6c8dedd55f8a // indirect
+	github.com/fsnotify/fsnotify v1.4.7
+	github.com/go-telegram-bot-api/telegram-bot-api v0.0.0-20180428185002-212b1541150c
+	github.com/golang/protobuf v0.0.0-20170613224224-e325f446bebc // indirect
+	github.com/google/gops v0.0.0-20170319002943-62f833fc9f6c
+	github.com/gopherjs/gopherjs v0.0.0-20180628210949-0892b62f0d9f // indirect
+	github.com/gorilla/schema v0.0.0-20170317173100-f3c80893412c
+	github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777
+	github.com/hashicorp/golang-lru v0.0.0-20160813221303-0a025b7e63ad
+	github.com/hashicorp/hcl v0.0.0-20171017181929-23c074d0eceb // indirect
+	github.com/hpcloud/tail v1.0.0 // indirect
+	github.com/jpillora/backoff v0.0.0-20170222002228-06c7a16c845d
+	github.com/jtolds/gls v4.2.1+incompatible // indirect
+	github.com/kardianos/osext v0.0.0-20170207191655-9b883c5eb462 // indirect
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/labstack/echo v0.0.0-20180219162101-7eec915044a1
+	github.com/labstack/gommon v0.2.1 // indirect
+	github.com/lrstanley/girc v0.0.0-20180427160007-102f17f86306
+	github.com/magiconair/properties v0.0.0-20180217134545-2c9e95027885 // indirect
+	github.com/matterbridge/discordgo v0.0.0-20180806170629-ef40ff5ba64f
+	github.com/matterbridge/go-xmpp v0.0.0-20180529212104-cd19799fba91
+	github.com/matterbridge/gomatrix v0.0.0-20171224233421-78ac6a1a0f5f
+	github.com/matterbridge/gozulipbot v0.0.0-20180507190239-b6bb12d33544
+	github.com/matterbridge/logrus-prefixed-formatter v0.0.0-20180806162718-01618749af61
+	github.com/mattermost/platform v4.6.2+incompatible
+	github.com/mattn/go-colorable v0.0.0-20170210172801-5411d3eea597 // indirect
+	github.com/mattn/go-isatty v0.0.0-20170216235908-dda3de49cbfc // indirect
+	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/mitchellh/mapstructure v0.0.0-20180220230111-00c29f56e238 // indirect
+	github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474 // indirect
+	github.com/mrexodia/wray v0.0.0-20160318003008-78a2c1f284ff // indirect
+	github.com/nicksnyder/go-i18n v1.4.0 // indirect
+	github.com/nlopes/slack v0.3.1-0.20180805133408-21749ab136a8
+	github.com/onsi/ginkgo v1.6.0 // indirect
+	github.com/onsi/gomega v1.4.1 // indirect
+	github.com/paulrosania/go-charset v0.0.0-20151028000031-621bb39fcc83
+	github.com/pborman/uuid v0.0.0-20160216163710-c55201b03606 // indirect
+	github.com/pelletier/go-toml v0.0.0-20180228233631-05bcc0fb0d3e // indirect
+	github.com/peterhellberg/emojilib v0.0.0-20170616163716-41920917e271
+	github.com/pkg/errors v0.8.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rs/xid v0.0.0-20180525034800-088c5cf1423a
+	github.com/russross/blackfriday v1.5.1
+	github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca
+	github.com/shazow/rateio v0.0.0-20150116013248-e8e00881e5c1 // indirect
+	github.com/shazow/ssh-chat v0.0.0-20171012174035-2078e1381991
+	github.com/sirupsen/logrus v0.0.0-20180213143110-8c0189d9f6bb
+	github.com/smartystreets/assertions v0.0.0-20180803164922-886ec427f6b9 // indirect
+	github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a // indirect
+	github.com/spf13/afero v0.0.0-20180211162714-bbf41cb36dff // indirect
+	github.com/spf13/cast v1.2.0 // indirect
+	github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec // indirect
+	github.com/spf13/pflag v0.0.0-20180220143236-ee5fd03fd6ac // indirect
+	github.com/spf13/viper v0.0.0-20171227194143-aafc9e6bc7b7
+	github.com/stretchr/testify v0.0.0-20170714215325-05e8a0eda380
+	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
+	github.com/valyala/bytebufferpool v0.0.0-20160817181652-e746df99fe4a // indirect
+	github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4 // indirect
+	github.com/x-cray/logrus-prefixed-formatter v0.5.2 // indirect
+	github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6
+	golang.org/x/crypto v0.0.0-20180228161326-91a49db82a88 // indirect
+	golang.org/x/net v0.0.0-20180108090419-434ec0c7fe37 // indirect
+	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f // indirect
+	golang.org/x/sys v0.0.0-20171130163741-8b4580aae2a0 // indirect
+	golang.org/x/text v0.0.0-20180511172408-5c1cf69b5978 // indirect
+	gopkg.in/airbrake/gobrake.v2 v2.0.9 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	gopkg.in/fsnotify.v1 v1.4.7 // indirect
+	gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.1 // indirect
+	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
+	gopkg.in/yaml.v2 v2.0.0-20160301204022-a83829b6f129 // indirect
+)

go.sum

@@ -0,0 +1,163 @@
+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/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/Philipp15b/go-steam v0.0.0-20161020161927-e0f3bb9566e3 h1:V4+1E1SRYUySqwOoI3ZphFADtabbF568zTHa5ix/zU0=
+github.com/Philipp15b/go-steam v0.0.0-20161020161927-e0f3bb9566e3/go.mod h1:HuVM+sZFzumUdKPWiz+IlCMb4RdsKdT3T+nQBKL+sYg=
+github.com/Sirupsen/logrus v1.0.6 h1:HCAGQRk48dRVPA5Y+Yh0qdCSTzPOyU1tBJ7Q9YzotII=
+github.com/Sirupsen/logrus v1.0.6/go.mod h1:rmk17hk6i8ZSAJkSDa7nOxamrG+SP4P0mm+DAvExv4U=
+github.com/alecthomas/log4go v0.0.0-20160307011253-e5dc62318d9b h1:1OpGXps6UOY5HtQaQcLowsV1qMWCNBzhFvK7q4fgXtc=
+github.com/alecthomas/log4go v0.0.0-20160307011253-e5dc62318d9b/go.mod h1:iCVmQ9g4TfaRX5m5jq5sXY7RXYWPv9/PynM/GocbG3w=
+github.com/bwmarrin/discordgo v0.0.0-20180201002541-8d5ab59c63e5 h1:M7u44DKGpA5goDIBf0zRMYhT1Sp2Rd7hiTzXfeuw1UY=
+github.com/bwmarrin/discordgo v0.0.0-20180201002541-8d5ab59c63e5/go.mod h1:5NIvFv5Z7HddYuXbuQegZ684DleQaCFqChP2iuBivJ8=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dfordsoft/golib v0.0.0-20180313113957-2ea3495aee1d h1:rONNnZDE5CYuaSFQk+gP4GEQTXEUcyQ5p6p/dgxIHas=
+github.com/dfordsoft/golib v0.0.0-20180313113957-2ea3495aee1d/go.mod h1:UGa5M2Sz/Uh13AMse4+RELKCDw7kqgqlTjeGae+7vUY=
+github.com/dgrijalva/jwt-go v0.0.0-20170508165458-6c8dedd55f8a h1:MuHMeSsXbNEeUyxjB7T9P8s1+5k8OLTC/M27qsVwixM=
+github.com/dgrijalva/jwt-go v0.0.0-20170508165458-6c8dedd55f8a/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+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 v0.0.0-20180428185002-212b1541150c h1:3gMh737vMGqAkkkSfNbwjO8VRHOSaCjYRG4y9xVMEIQ=
+github.com/go-telegram-bot-api/telegram-bot-api v0.0.0-20180428185002-212b1541150c/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/google/gops v0.0.0-20170319002943-62f833fc9f6c h1:MrMA1vhRTNidtgENqmsmLOIUS6ixMBOU/g10rm7IUe8=
+github.com/google/gops v0.0.0-20170319002943-62f833fc9f6c/go.mod h1:pMQgrscwEK/aUSW1IFSaBPbJX82FPHWaSoJw1axQfD0=
+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/schema v0.0.0-20170317173100-f3c80893412c h1:mORYpib1aLu3M2Oi50Z1pNTXuDJEHcoLb6oo6VdOutk=
+github.com/gorilla/schema v0.0.0-20170317173100-f3c80893412c/go.mod h1:kgLaKoK1FELgZqMAVxx/5cbj0kT+57qxUrAlIO2eleU=
+github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777 h1:JIM+OacoOJRU30xpjMf8sulYqjr0ViA3WDrTX6j/yDI=
+github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/hashicorp/golang-lru v0.0.0-20160813221303-0a025b7e63ad h1:eMxs9EL0PvIGS9TTtxg4R+JxuPGav82J8rA+GFnY7po=
+github.com/hashicorp/golang-lru v0.0.0-20160813221303-0a025b7e63ad/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/hcl v0.0.0-20171017181929-23c074d0eceb h1:1OvvPvZkn/yCQ3xBcM8y4020wdkMXPHLB4+NfoGWh4U=
+github.com/hashicorp/hcl v0.0.0-20171017181929-23c074d0eceb/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jpillora/backoff v0.0.0-20170222002228-06c7a16c845d h1:ETeT81zgLgSNc4BWdDO2Fg9ekVItYErbNtE8mKD2pJA=
+github.com/jpillora/backoff v0.0.0-20170222002228-06c7a16c845d/go.mod h1:2iMrUgbbvHEiQClaW2NsSzMyGHqN+rDFqY705q49KG0=
+github.com/jtolds/gls v4.2.1+incompatible h1:fSuqC+Gmlu6l/ZYAoZzx2pyucC8Xza35fpRVWLVmUEE=
+github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kardianos/osext v0.0.0-20170207191655-9b883c5eb462 h1:oSOOTPHkCzMeu1vJ0nHxg5+XZBdMMjNa+6NPnm8arok=
+github.com/kardianos/osext v0.0.0-20170207191655-9b883c5eb462/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/labstack/echo v0.0.0-20180219162101-7eec915044a1 h1:cOIt0LZKdfeirAfTP4VtIJuWbjVTGtd1suuPXp/J+dE=
+github.com/labstack/echo v0.0.0-20180219162101-7eec915044a1/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s=
+github.com/labstack/gommon v0.2.1 h1:C+I4NYknueQncqKYZQ34kHsLZJVeB5KwPUhnO0nmbpU=
+github.com/labstack/gommon v0.2.1/go.mod h1:/tj9csK2iPSBvn+3NLM9e52usepMtrd5ilFYA+wQNJ4=
+github.com/lrstanley/girc v0.0.0-20180427160007-102f17f86306 h1:IqN61cmi7LM/IaYaP9a/KXFtHRS2a3+WHu8GhAXJT7c=
+github.com/lrstanley/girc v0.0.0-20180427160007-102f17f86306/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk=
+github.com/magiconair/properties v0.0.0-20180217134545-2c9e95027885 h1:HWxJJvF+QceKcql4r9PC93NtMEgEBfBxlQrZPvbcQvs=
+github.com/magiconair/properties v0.0.0-20180217134545-2c9e95027885/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/matterbridge/discordgo v0.0.0-20180806170629-ef40ff5ba64f h1:9IIOO9Aznn8zJx3nokZ4U6nfuzWw5xAlygPvuRZMisQ=
+github.com/matterbridge/discordgo v0.0.0-20180806170629-ef40ff5ba64f/go.mod h1:5QtN542bJn9FunZqYlIbleNtToxfLCVV9pW7m7Q42Fc=
+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-20171224233421-78ac6a1a0f5f h1:2eKh6Qi/sJ8bXvYMoyVfQxHgR8UcCDWjOmhV1oCstMU=
+github.com/matterbridge/gomatrix v0.0.0-20171224233421-78ac6a1a0f5f/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/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/platform v4.6.2+incompatible h1:9WqKNuJFIp6SDYn5wl1RF5urdhEw8d7o5tAOwT1MW0A=
+github.com/mattermost/platform v4.6.2+incompatible/go.mod h1:HjGKtkQNu3HXTOykPMQckMnH11WHvNvQqDBNnVXVbfM=
+github.com/mattn/go-colorable v0.0.0-20170210172801-5411d3eea597 h1:hGizH4aMDFFt1iOA4HNKC13lqIBoCyxIjWcAnWIy7aU=
+github.com/mattn/go-colorable v0.0.0-20170210172801-5411d3eea597/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.0-20170216235908-dda3de49cbfc h1:pK7tzC30erKOTfEDCYGvPZQCkmM9X5iSmmAR5m9x3Yc=
+github.com/mattn/go-isatty v0.0.0-20170216235908-dda3de49cbfc/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+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 v0.0.0-20180220230111-00c29f56e238 h1:+MZW2uvHgN8kYvksEN3f7eFL2wpzk0GxmlFsMybWc7E=
+github.com/mitchellh/mapstructure v0.0.0-20180220230111-00c29f56e238/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474 h1:oKIteTqeSpenyTrOVj5zkiyCaflLa8B+CD0324otT+o=
+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/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.0.0-20180101221843-107290b5bbaf h1:M+xGhDxie/MqC+tzs+3ZHBSY4Wsv+fEkrpIMCKy8PTg=
+github.com/nlopes/slack v0.0.0-20180101221843-107290b5bbaf/go.mod h1:jVI4BBK3lSktibKahxBF74txcK2vyvkza1z/+rRnVAM=
+github.com/nlopes/slack v0.3.1-0.20180805133408-21749ab136a8 h1:PSy8NkmkyldLmPPnNNw7mwfQFOHDqOI6bINpJ+/KV7Y=
+github.com/nlopes/slack v0.3.1-0.20180805133408-21749ab136a8/go.mod h1:jVI4BBK3lSktibKahxBF74txcK2vyvkza1z/+rRnVAM=
+github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.1 h1:PZSj/UFNaVp3KxrzHOcS7oyuWA7LoOY/77yCTEFu21U=
+github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/paulrosania/go-charset v0.0.0-20151028000031-621bb39fcc83 h1:XQonH5Iv5rbyIkMJOQ4xKmKHQTh8viXtRSmep5Ca5I4=
+github.com/paulrosania/go-charset v0.0.0-20151028000031-621bb39fcc83/go.mod h1:YnNlZP7l4MhyGQ4CBRwv6ohZTPrUJJZtEv4ZgADkbs4=
+github.com/pborman/uuid v0.0.0-20160216163710-c55201b03606 h1:/CPgDYrfeK2LMK6xcUhvI17yO9SlpAdDIJGkhDEgO8A=
+github.com/pborman/uuid v0.0.0-20160216163710-c55201b03606/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34=
+github.com/pelletier/go-toml v0.0.0-20180228233631-05bcc0fb0d3e h1:ZW8599OjioQsmBbkGpyruHUlRVQceYFWnJsGr4NCkiA=
+github.com/pelletier/go-toml v0.0.0-20180228233631-05bcc0fb0d3e/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/peterhellberg/emojilib v0.0.0-20170616163716-41920917e271 h1:wQ9lVx75za6AT2kI0S9QID0uWuwTWnvcTfN+uw1F8vg=
+github.com/peterhellberg/emojilib v0.0.0-20170616163716-41920917e271/go.mod h1:G7LufuPajuIvdt9OitkNt2qh0mmvD4bfRgRM7bhDIOA=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rs/xid v0.0.0-20180525034800-088c5cf1423a h1:UWKek6MK3K6/TpbsFcv+8rrO6rSc6KKSp2FbMOHWsq4=
+github.com/rs/xid v0.0.0-20180525034800-088c5cf1423a/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
+github.com/russross/blackfriday v1.5.1 h1:B8ZN6pD4PVofmlDCDUdELeYrbsVIDM/bpjW3v3zgcRc=
+github.com/russross/blackfriday v1.5.1/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+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-20171012174035-2078e1381991 h1:PQiUTDzUC5EUh0vNurK7KQS22zlKqLLOFn+K9nJXDQQ=
+github.com/shazow/ssh-chat v0.0.0-20171012174035-2078e1381991/go.mod h1:KwtnpMClmrXsHCKTbRui5xBUNt17n1GGrGhdiw2KcoY=
+github.com/sirupsen/logrus v0.0.0-20180213143110-8c0189d9f6bb h1:eKjx20EiekBRT2tjZ0XEdKpftfPJQwiavtFshwTyqf0=
+github.com/sirupsen/logrus v0.0.0-20180213143110-8c0189d9f6bb/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
+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=
+github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/spf13/afero v0.0.0-20180211162714-bbf41cb36dff h1:HLvGWId7M56TfuxTeZ6aoiTAcrWO5Mnq/ArwVRgV62I=
+github.com/spf13/afero v0.0.0-20180211162714-bbf41cb36dff/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.2.0 h1:HHl1DSRbEQN2i8tJmtS6ViPyHx35+p51amrdsiTCrkg=
+github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
+github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec h1:2ZXvIUGghLpdTVHR1UfvfrzoVlZaE/yOWC5LueIHZig=
+github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v0.0.0-20180220143236-ee5fd03fd6ac h1:+uzyQ0TQ3aKorQxsOjcDDgE7CuUXwpkKnK19LULQALQ=
+github.com/spf13/pflag v0.0.0-20180220143236-ee5fd03fd6ac/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v0.0.0-20171227194143-aafc9e6bc7b7 h1:Wj4cg2M6Um7j1N7yD/mxsdy1/wrsdjzVha2eWdOhti8=
+github.com/spf13/viper v0.0.0-20171227194143-aafc9e6bc7b7/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
+github.com/stretchr/testify v0.0.0-20170714215325-05e8a0eda380 h1:MsolbevHkd4SpbeG4dHLHj6I9jzoohyNI6EK6JvR5hE=
+github.com/stretchr/testify v0.0.0-20170714215325-05e8a0eda380/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/technoweenie/multipartstreamer v1.0.1 h1:XRztA5MXiR1TIRHxH2uNxXxaIkKQDeX7m2XsSOlQEnM=
+github.com/technoweenie/multipartstreamer v1.0.1/go.mod h1:jNVxdtShOxzAsukZwTSw6MDx5eUJoiEBsSvzDU9uzog=
+github.com/valyala/bytebufferpool v0.0.0-20160817181652-e746df99fe4a h1:AOcehBWpFhYPYw0ioDTppQzgI8pAAahVCiMSKTp9rbo=
+github.com/valyala/bytebufferpool v0.0.0-20160817181652-e746df99fe4a/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4 h1:gKMu1Bf6QINDnvyZuTaACm9ofY+PRh+5vFz4oxBZeF8=
+github.com/valyala/fasttemplate v0.0.0-20170224212429-dcecefd839c4/go.mod h1:50wTf68f99/Zt14pr046Tgt3Lp2vLyFZKzbFXTOabXw=
+github.com/x-cray/logrus-prefixed-formatter v0.5.2 h1:00txxvfBM9muc0jiLIEAkAcIMJzfthRT6usrui8uGmg=
+github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE=
+github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6 h1:/WULP+6asFz569UbOwg87f3iDT7T+GF5/vjLmL51Pdk=
+github.com/zfjagann/golang-ring v0.0.0-20141111230621-17637388c9f6/go.mod h1:0MsIttMJIF/8Y7x0XjonJP7K99t3sR6bjj4m5S4JmqU=
+golang.org/x/crypto v0.0.0-20180228161326-91a49db82a88 h1:jLkAo/qlT9whgCLYC5GAJ9kcKrv3Wj8VCc4N+KJ4wpw=
+golang.org/x/crypto v0.0.0-20180228161326-91a49db82a88/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/sys v0.0.0-20171130163741-8b4580aae2a0 h1:x4M4WCms+ErQg/4VyECbP2kSNcDJ6nLwqEGov1QPtqk=
+golang.org/x/sys v0.0.0-20171130163741-8b4580aae2a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.0.0-20180511172408-5c1cf69b5978 h1:WNm0tmiuBMW4FJRuXKWOqaQfmKptHs0n8nTCyG0ayjc=
+golang.org/x/text v0.0.0-20180511172408-5c1cf69b5978/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/airbrake/gobrake.v2 v2.0.9 h1:7z2uVWwn7oVeeugY1DtlPAy5H+KYgB1KeKTnqjNatLo=
+gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.1 h1:4buh9nXkpqc7+GLzDFHei0jwoU9wCQYfVB5Kfo58Yz0=
+gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.1/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.0.0-20160301204022-a83829b6f129 h1:RBgb9aPUbZ9nu66ecQNIBNsA7j3mB5h8PNDIfhPjaJg=
+gopkg.in/yaml.v2 v2.0.0-20160301204022-a83829b6f129/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=

hook/rockethook/rockethook.go

@@ -0,0 +1,107 @@
+package rockethook
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+)
+
+// Message for rocketchat outgoing webhook.
+type Message struct {
+	Token       string `json:"token"`
+	ChannelID   string `json:"channel_id"`
+	ChannelName string `json:"channel_name"`
+	Timestamp   string `json:"timestamp"`
+	UserID      string `json:"user_id"`
+	UserName    string `json:"user_name"`
+	Text        string `json:"text"`
+}
+
+// Client for Rocketchat.
+type Client struct {
+	In         chan Message
+	httpclient *http.Client
+	Config
+}
+
+// Config for client.
+type Config struct {
+	BindAddress        string // Address to listen on
+	Token              string // Only allow this token from Rocketchat. (Allow everything when empty)
+	InsecureSkipVerify bool   // disable certificate checking
+}
+
+// New Rocketchat client.
+func New(url string, config Config) *Client {
+	c := &Client{In: make(chan Message), Config: config}
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: config.InsecureSkipVerify},
+	}
+	c.httpclient = &http.Client{Transport: tr}
+	_, _, err := net.SplitHostPort(c.BindAddress)
+	if err != nil {
+		log.Fatalf("incorrect bindaddress %s", c.BindAddress)
+	}
+	go c.StartServer()
+	return c
+}
+
+// StartServer starts a webserver listening for incoming mattermost POSTS.
+func (c *Client) StartServer() {
+	mux := http.NewServeMux()
+	mux.Handle("/", c)
+	log.Printf("Listening on http://%v...\n", c.BindAddress)
+	if err := http.ListenAndServe(c.BindAddress, mux); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// ServeHTTP implementation.
+func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		log.Println("invalid " + r.Method + " connection from " + r.RemoteAddr)
+		http.NotFound(w, r)
+		return
+	}
+	msg := Message{}
+	body, err := ioutil.ReadAll(r.Body)
+	log.Println(string(body))
+	if err != nil {
+		log.Println(err)
+		http.NotFound(w, r)
+		return
+	}
+	defer r.Body.Close()
+	err = json.Unmarshal(body, &msg)
+	if err != nil {
+		log.Println(err)
+		http.NotFound(w, r)
+		return
+	}
+	if msg.Token == "" {
+		log.Println("no token from " + r.RemoteAddr)
+		http.NotFound(w, r)
+		return
+	}
+	msg.ChannelName = "#" + msg.ChannelName
+	if c.Token != "" {
+		if msg.Token != c.Token {
+			log.Println("invalid token " + msg.Token + " from " + r.RemoteAddr)
+			http.NotFound(w, r)
+			return
+		}
+	}
+	c.In <- msg
+}
+
+// Receive returns an incoming message from mattermost outgoing webhooks URL.
+func (c *Client) Receive() Message {
+	var msg Message
+	for msg = range c.In {
+		return msg
+	}
+	return msg
+}

matterbridge.conf.sample

@@ -1,32 +0,0 @@
-[IRC]
-server="irc.freenode.net"
-port=6667
-UseTLS=false
-SkipTLSVerify=true
-nick="matterbot"
-channel="#matterbridge"
-UseSlackCircumfix=false
-
-[mattermost]
-url="http://yourdomain/hooks/yourhookkey"
-port=9999
-showjoinpart=true
-#remove token when using multiple channels!
-token=yourtokenfrommattermost
-IconURL="http://youricon.png"
-#SkipTLSVerify=true
-#BindAddress="0.0.0.0"
-
-[general]
-GiphyAPIKey=dc6zaTOxFJmzC
-
-#multiple channel config
-#token you can find in your outgoing webhook
-[Token "outgoingwebhooktoken1"] 
-IRCChannel="#off-topic"
-MMChannel="off-topic"
-
-[Token "outgoingwebhooktoken2"]
-IRCChannel="#testing"
-MMChannel="testing"
-

matterbridge.go

@@ -1,163 +1,58 @@
 package main
 
 import (
-	"crypto/tls"
 	"flag"
-	"github.com/42wim/matterbridge/matterhook"
-	"github.com/peterhellberg/giphy"
-	"github.com/thoj/go-ircevent"
-	"log"
-	"strconv"
+	"fmt"
+	"os"
 	"strings"
-	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway"
+	"github.com/google/gops/agent"
+	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/sirupsen/logrus"
 )
 
-type Bridge struct {
-	i    *irc.Connection
-	m    *matterhook.Client
-	cmap map[string]string
-	*Config
-}
-
-func NewBridge(name string, config *Config) *Bridge {
-	b := &Bridge{}
-	b.Config = config
-	b.cmap = make(map[string]string)
-	if len(b.Config.Token) > 0 {
-		for _, val := range b.Config.Token {
-			b.cmap[val.IRCChannel] = val.MMChannel
-		}
-	}
-	b.m = matterhook.New(b.Config.Mattermost.URL,
-		matterhook.Config{Port: b.Config.Mattermost.Port, Token: b.Config.Mattermost.Token,
-			InsecureSkipVerify: b.Config.Mattermost.SkipTLSVerify,
-			BindAddress:        b.Config.Mattermost.BindAddress})
-	b.i = b.createIRC(name)
-	go b.handleMatter()
-	return b
-}
-
-func (b *Bridge) createIRC(name string) *irc.Connection {
-	i := irc.IRC(b.Config.IRC.Nick, b.Config.IRC.Nick)
-	i.UseTLS = b.Config.IRC.UseTLS
-	i.TLSConfig = &tls.Config{InsecureSkipVerify: b.Config.IRC.SkipTLSVerify}
-	if b.Config.IRC.Password != "" {
-		i.Password = b.Config.IRC.Password
-	}
-	i.Connect(b.Config.IRC.Server + ":" + strconv.Itoa(b.Config.IRC.Port))
-	time.Sleep(time.Second)
-	log.Println("Joining", b.Config.IRC.Channel, "as", b.Config.IRC.Nick)
-	i.Join(b.Config.IRC.Channel)
-	for _, val := range b.Config.Token {
-		log.Println("Joining", val.IRCChannel, "as", b.Config.IRC.Nick)
-		i.Join(val.IRCChannel)
-	}
-	i.AddCallback("PRIVMSG", b.handlePrivMsg)
-	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
-	if b.Config.Mattermost.ShowJoinPart {
-		i.AddCallback("JOIN", b.handleJoinPart)
-		i.AddCallback("PART", b.handleJoinPart)
-	}
-	//i.AddCallback("353", b.handleOther)
-	return i
-}
-
-func (b *Bridge) handlePrivMsg(event *irc.Event) {
-	msg := ""
-	if event.Code == "CTCP_ACTION" {
-		msg = event.Nick + " "
-	}
-	msg += event.Message()
-	b.Send("irc-"+event.Nick, msg, b.getMMChannel(event.Arguments[0]))
-}
-
-func (b *Bridge) handleJoinPart(event *irc.Event) {
-	b.Send(b.Config.IRC.Nick, "irc-"+event.Nick+" "+strings.ToLower(event.Code)+"s "+event.Message(), b.getMMChannel(event.Arguments[0]))
-	//b.SendType(b.Config.IRC.Nick, "irc-"+event.Nick+" "+strings.ToLower(event.Code)+"s "+event.Message(), b.getMMChannel(event.Arguments[0]), "join_leave")
-}
-
-func (b *Bridge) handleOther(event *irc.Event) {
-	switch event.Code {
-	case "353":
-		log.Println("handleOther", b.getMMChannel(event.Arguments[0]))
-		b.Send(b.Config.IRC.Nick, event.Message()+" currently on IRC", b.getMMChannel(event.Arguments[0]))
-	}
-}
-
-func (b *Bridge) Send(nick string, message string, channel string) error {
-	return b.SendType(nick, message, channel, "")
-}
-
-func (b *Bridge) SendType(nick string, message string, channel string, mtype string) error {
-	matterMessage := matterhook.OMessage{IconURL: b.Config.Mattermost.IconURL}
-	matterMessage.Channel = channel
-	matterMessage.UserName = nick
-	matterMessage.Text = message
-	matterMessage.Type = mtype
-	err := b.m.Send(matterMessage)
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	return nil
-}
-
-func (b *Bridge) handleMatter() {
-	var username string
-	for {
-		message := b.m.Receive()
-		username = message.UserName + ": "
-		if b.Config.IRC.UseSlackCircumfix {
-			username = "<" + message.UserName + "> "
-		}
-		cmd := strings.Fields(message.Text)[0]
-		switch cmd {
-		case "!users":
-			log.Println("received !users from", message.UserName)
-			b.i.SendRaw("NAMES " + b.getIRCChannel(message.Token))
-		case "!gif":
-			message.Text = b.giphyRandom(strings.Fields(strings.Replace(message.Text, "!gif ", "", 1)))
-			b.Send(b.Config.IRC.Nick, message.Text, b.getIRCChannel(message.Token))
-		}
-		texts := strings.Split(message.Text, "\n")
-		for _, text := range texts {
-			b.i.Privmsg(b.getIRCChannel(message.Token), username+text)
-		}
-	}
-}
-
-func (b *Bridge) giphyRandom(query []string) string {
-	g := giphy.DefaultClient
-	if b.Config.General.GiphyAPIKey != "" {
-		g.APIKey = b.Config.General.GiphyAPIKey
-	}
-	res, err := g.Random(query)
-	if err != nil {
-		return "error"
-	}
-	return res.Data.FixedHeightDownsampledURL
-}
-
-func (b *Bridge) getMMChannel(ircChannel string) string {
-	mmchannel, ok := b.cmap[ircChannel]
-	if !ok {
-		mmchannel = b.Config.Mattermost.Channel
-	}
-	return mmchannel
-}
-
-func (b *Bridge) getIRCChannel(token string) string {
-	ircchannel := b.Config.IRC.Channel
-	_, ok := b.Config.Token[token]
-	if ok {
-		ircchannel = b.Config.Token[token].IRCChannel
-	}
-	return ircchannel
-}
+var (
+	version = "1.11.3"
+	githash string
+)
 
 func main() {
-	flagConfig := flag.String("conf", "matterbridge.conf", "config file")
+	log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: true})
+	flog := log.WithFields(log.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()
-	NewBridge("matterbot", NewConfig(*flagConfig))
+	if *flagGops {
+		agent.Listen(&agent.Options{})
+		defer agent.Close()
+	}
+	if *flagVersion {
+		fmt.Printf("version: %s %s\n", version, githash)
+		return
+	}
+	if *flagDebug || os.Getenv("DEBUG") == "1" {
+		log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false, ForceFormatting: true})
+		flog.Info("Enabling debug")
+		log.SetLevel(log.DebugLevel)
+	}
+	flog.Printf("Running version %s %s", version, githash)
+	if strings.Contains(version, "-dev") {
+		flog.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
+	}
+	cfg := config.NewConfig(*flagConfig)
+	cfg.General.Debug = *flagDebug
+	r, err := gateway.NewRouter(cfg)
+	if err != nil {
+		flog.Fatalf("Starting gateway failed: %s", err)
+	}
+	err = r.Start()
+	if err != nil {
+		flog.Fatalf("Starting gateway failed: %s", err)
+	}
+	flog.Printf("Gateway(s) started succesfully. Now relaying messages")
 	select {}
 }

matterbridge.toml.simple

@@ -0,0 +1,34 @@
+#WARNING: as this file contains credentials, be sure to set correct file permissions
+[irc]
+    [irc.freenode]
+    Server="irc.freenode.net:6667"
+    Nick="matterbot"
+
+[mattermost]
+    [mattermost.work]
+    #do not prefix it wit http:// or https://
+    Server="yourmattermostserver.domain" 
+    Team="yourteam"
+    Login="yourlogin"
+    Password="yourpass"
+    PrefixMessagesWithNick=true
+
+[[gateway]]
+name="gateway1"
+enable=true
+    [[gateway.inout]]
+    account="irc.freenode"
+    channel="#testing"
+
+    [[gateway.inout]]
+    account="mattermost.work"
+    channel="off-topic"
+    
+#simpler config possible since v0.10.2
+#[[gateway]]
+#name="gateway2"
+#enable=true
+#inout = [
+#    { account="irc.freenode", channel="#testing", options={key="channelkey"}},
+#    { account="mattermost.work", channel="off-topic" },
+#]

matterclient/matterclient.go

@@ -0,0 +1,952 @@
+package matterclient
+
+import (
+	"crypto/md5"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/sirupsen/logrus"
+
+	"github.com/gorilla/websocket"
+	"github.com/hashicorp/golang-lru"
+	"github.com/jpillora/backoff"
+	"github.com/mattermost/platform/model"
+)
+
+type Credentials struct {
+	Login         string
+	Team          string
+	Pass          string
+	Server        string
+	NoTLS         bool
+	SkipTLSVerify bool
+}
+
+type Message struct {
+	Raw      *model.WebSocketEvent
+	Post     *model.Post
+	Team     string
+	Channel  string
+	Username string
+	Text     string
+	Type     string
+	UserID   string
+}
+
+type Team struct {
+	Team         *model.Team
+	Id           string
+	Channels     []*model.Channel
+	MoreChannels []*model.Channel
+	Users        map[string]*model.User
+}
+
+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           *log.Entry
+	WsClient      *websocket.Conn
+	WsQuit        bool
+	WsAway        bool
+	WsConnected   bool
+	WsSequence    int64
+	WsPingChan    chan *model.WebSocketResponse
+	ServerVersion string
+	OnWsConnect   func()
+	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)}
+	log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true})
+	mmclient.log = log.WithFields(log.Fields{"prefix": "matterclient"})
+	mmclient.lruCache, _ = lru.New(500)
+	return mmclient
+}
+
+func (m *MMClient) SetDebugLog() {
+	log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false, ForceFormatting: true})
+}
+
+func (m *MMClient) SetLogLevel(level string) {
+	l, err := log.ParseLevel(level)
+	if err != nil {
+		log.SetLevel(log.InfoLevel)
+		return
+	}
+	log.SetLevel(l)
+}
+
+func (m *MMClient) Login() error {
+	// check if this is a first connect or a reconnection
+	firstConnection := true
+	if m.WsConnected {
+		firstConnection = false
+	}
+	m.WsConnected = false
+	if m.WsQuit {
+		return nil
+	}
+	b := &backoff.Backoff{
+		Min:    time.Second,
+		Max:    5 * time.Minute,
+		Jitter: true,
+	}
+	uriScheme := "https://"
+	if m.NoTLS {
+		uriScheme = "http://"
+	}
+	// login to mattermost
+	m.Client = model.NewAPIv4Client(uriScheme + m.Credentials.Server)
+	m.Client.HttpClient.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}, Proxy: http.ProxyFromEnvironment}
+	m.Client.HttpClient.Timeout = time.Second * 10
+
+	for {
+		d := b.Duration()
+		// bogus call to get the serverversion
+		_, resp := m.Client.Logout()
+		if resp.Error != nil {
+			return fmt.Errorf("%#v", resp.Error.Error())
+		}
+		if firstConnection && !supportedVersion(resp.ServerVersion) {
+			return fmt.Errorf("unsupported mattermost version: %s", resp.ServerVersion)
+		}
+		m.ServerVersion = resp.ServerVersion
+		if m.ServerVersion == "" {
+			m.log.Debugf("Server not up yet, reconnecting in %s", d)
+			time.Sleep(d)
+		} else {
+			m.log.Infof("Found version %s", m.ServerVersion)
+			break
+		}
+	}
+	b.Reset()
+
+	var resp *model.Response
+	//var myinfo *model.Result
+	var appErr *model.AppError
+	var logmsg = "trying login"
+	for {
+		m.log.Debugf("%s %s %s %s", logmsg, m.Credentials.Team, m.Credentials.Login, m.Credentials.Server)
+		if strings.Contains(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN) {
+			m.log.Debugf(logmsg + " with token")
+			token := strings.Split(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN+"=")
+			if len(token) != 2 {
+				return errors.New("incorrect MMAUTHTOKEN. valid input is MMAUTHTOKEN=yourtoken")
+			}
+			m.Client.HttpClient.Jar = m.createCookieJar(token[1])
+			m.Client.AuthToken = token[1]
+			m.Client.AuthType = model.HEADER_BEARER
+			m.User, resp = m.Client.GetMe("")
+			if resp.Error != nil {
+				return resp.Error
+			}
+			if m.User == nil {
+				m.log.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
+				return errors.New("invalid " + model.SESSION_COOKIE_TOKEN)
+			}
+		} else {
+			m.User, resp = m.Client.Login(m.Credentials.Login, m.Credentials.Pass)
+		}
+		appErr = resp.Error
+		if appErr != nil {
+			d := b.Duration()
+			m.log.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)
+			time.Sleep(d)
+			logmsg = "retrying login"
+			continue
+		}
+		break
+	}
+	// reset timer
+	b.Reset()
+
+	err := m.initUser()
+	if err != nil {
+		return err
+	}
+
+	if m.Team == nil {
+		validTeamNames := make([]string, len(m.OtherTeams))
+		for i, t := range m.OtherTeams {
+			validTeamNames[i] = t.Team.Name
+		}
+		return fmt.Errorf("Team '%s' not found in %v", m.Credentials.Team, validTeamNames)
+	}
+
+	m.wsConnect()
+
+	return nil
+}
+
+func (m *MMClient) wsConnect() {
+	b := &backoff.Backoff{
+		Min:    time.Second,
+		Max:    5 * time.Minute,
+		Jitter: true,
+	}
+
+	m.WsConnected = false
+	wsScheme := "wss://"
+	if m.NoTLS {
+		wsScheme = "ws://"
+	}
+
+	// setup websocket connection
+	wsurl := wsScheme + m.Credentials.Server + model.API_URL_SUFFIX_V4 + "/websocket"
+	header := http.Header{}
+	header.Set(model.HEADER_AUTH, "BEARER "+m.Client.AuthToken)
+
+	m.log.Debugf("WsClient: making connection: %s", wsurl)
+	for {
+		wsDialer := &websocket.Dialer{Proxy: http.ProxyFromEnvironment, TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
+		var err error
+		m.WsClient, _, err = wsDialer.Dial(wsurl, header)
+		if err != nil {
+			d := b.Duration()
+			m.log.Debugf("WSS: %s, reconnecting in %s", err, d)
+			time.Sleep(d)
+			continue
+		}
+		break
+	}
+
+	m.log.Debug("WsClient: connected")
+	m.WsSequence = 1
+	m.WsPingChan = make(chan *model.WebSocketResponse)
+	// only start to parse WS messages when login is completely done
+	m.WsConnected = true
+}
+
+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.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")
+		return nil
+	}
+	_, resp := m.Client.Logout()
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (m *MMClient) WsReceiver() {
+	for {
+		var rawMsg json.RawMessage
+		var err error
+
+		if m.WsQuit {
+			m.log.Debug("exiting WsReceiver")
+			return
+		}
+
+		if !m.WsConnected {
+			time.Sleep(time.Millisecond * 100)
+			continue
+		}
+
+		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
+			m.log.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)
+			msg := &Message{Raw: &event, Team: m.Credentials.Team}
+			m.parseMessage(msg)
+			// check if we didn't empty the message
+			if msg.Text != "" {
+				m.MessageChan <- msg
+				continue
+			}
+			// if we have file attached but the message is empty, also send it
+			if msg.Post != nil {
+				if msg.Text != "" || len(msg.Post.FileIds) > 0 || msg.Post.Type == "slack_attachment" {
+					m.MessageChan <- msg
+				}
+			}
+			continue
+		}
+
+		var response model.WebSocketResponse
+		if err := json.Unmarshal(rawMsg, &response); err == nil && response.IsValid() {
+			m.log.Debugf("WsReceiver response: %#v", response)
+			m.parseResponse(response)
+			continue
+		}
+	}
+}
+
+func (m *MMClient) parseMessage(rmsg *Message) {
+	switch rmsg.Raw.Event {
+	case model.WEBSOCKET_EVENT_POSTED, model.WEBSOCKET_EVENT_POST_EDITED, model.WEBSOCKET_EVENT_POST_DELETED:
+		m.parseActionPost(rmsg)
+	case "user_updated":
+		user := rmsg.Raw.Data["user"].(map[string]interface{})
+		if _, ok := user["id"].(string); ok {
+			m.UpdateUser(user["id"].(string))
+		}
+		/*
+			case model.ACTION_USER_REMOVED:
+				m.handleWsActionUserRemoved(&rmsg)
+			case model.ACTION_USER_ADDED:
+				m.handleWsActionUserAdded(&rmsg)
+		*/
+	}
+}
+
+func (m *MMClient) parseResponse(rmsg model.WebSocketResponse) {
+	if rmsg.Data != nil {
+		// ping reply
+		if rmsg.Data["text"].(string) == "pong" {
+			m.WsPingChan <- &rmsg
+		}
+	}
+}
+
+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))
+		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 %s is not known, ignoring message %s", data)
+		return
+	}
+	rmsg.Username = m.GetUserName(data.UserId)
+	rmsg.Channel = m.GetChannelName(data.ChannelId)
+	rmsg.UserID = data.UserId
+	rmsg.Type = data.Type
+	teamid, _ := rmsg.Raw.Data["team_id"].(string)
+	// edit messsages have no team_id for some reason
+	if teamid == "" {
+		// we can find the team_id from the channelid
+		teamid = m.GetChannelTeamId(data.ChannelId)
+		rmsg.Raw.Data["team_id"] = teamid
+	}
+	if teamid != "" {
+		rmsg.Team = m.GetTeamName(teamid)
+	}
+	// direct message
+	if rmsg.Raw.Data["channel_type"] == "D" {
+		rmsg.Channel = m.GetUser(data.UserId).Username
+	}
+	rmsg.Text = data.Message
+	rmsg.Post = data
+}
+
+func (m *MMClient) UpdateUsers() error {
+	mmusers, resp := m.Client.GetUsers(0, 50000, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
+	}
+	m.Lock()
+	for _, user := range mmusers {
+		m.Users[user.Id] = user
+	}
+	m.Unlock()
+	return nil
+}
+
+func (m *MMClient) UpdateChannels() error {
+	mmchannels, resp := m.Client.GetChannelsForTeamForUser(m.Team.Id, m.User.Id, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
+	}
+	m.Lock()
+	m.Team.Channels = mmchannels
+	m.Unlock()
+
+	mmchannels, resp = m.Client.GetPublicChannelsForTeam(m.Team.Id, 0, 5000, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
+	}
+
+	m.Lock()
+	m.Team.MoreChannels = mmchannels
+	m.Unlock()
+	return nil
+}
+
+func (m *MMClient) GetChannelName(channelId string) string {
+	m.RLock()
+	defer m.RUnlock()
+	for _, t := range m.OtherTeams {
+		if t == nil {
+			continue
+		}
+		if t.Channels != nil {
+			for _, channel := range t.Channels {
+				if channel.Id == channelId {
+					return channel.Name
+				}
+			}
+		}
+		if t.MoreChannels != nil {
+			for _, channel := range t.MoreChannels {
+				if channel.Id == channelId {
+					return channel.Name
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func (m *MMClient) GetChannelId(name string, teamId string) string {
+	m.RLock()
+	defer m.RUnlock()
+	if teamId == "" {
+		teamId = m.Team.Id
+	}
+	for _, t := range m.OtherTeams {
+		if t.Id == teamId {
+			for _, channel := range append(t.Channels, t.MoreChannels...) {
+				if channel.Name == name {
+					return channel.Id
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func (m *MMClient) GetChannelTeamId(id string) string {
+	m.RLock()
+	defer m.RUnlock()
+	for _, t := range append(m.OtherTeams, m.Team) {
+		for _, channel := range append(t.Channels, t.MoreChannels...) {
+			if channel.Id == id {
+				return channel.TeamId
+			}
+		}
+	}
+	return ""
+}
+
+func (m *MMClient) GetChannelHeader(channelId string) string {
+	m.RLock()
+	defer m.RUnlock()
+	for _, t := range m.OtherTeams {
+		for _, channel := range append(t.Channels, t.MoreChannels...) {
+			if channel.Id == channelId {
+				return channel.Header
+			}
+
+		}
+	}
+	return ""
+}
+
+func (m *MMClient) PostMessage(channelId string, text string) (string, error) {
+	post := &model.Post{ChannelId: channelId, Message: text}
+	res, resp := m.Client.CreatePost(post)
+	if resp.Error != nil {
+		return "", resp.Error
+	}
+	return res.Id, nil
+}
+
+func (m *MMClient) PostMessageWithFiles(channelId string, text string, fileIds []string) (string, error) {
+	post := &model.Post{ChannelId: channelId, Message: text, FileIds: fileIds}
+	res, resp := m.Client.CreatePost(post)
+	if resp.Error != nil {
+		return "", resp.Error
+	}
+	return res.Id, nil
+}
+
+func (m *MMClient) EditMessage(postId string, text string) (string, error) {
+	post := &model.Post{Message: text}
+	res, resp := m.Client.UpdatePost(postId, post)
+	if resp.Error != nil {
+		return "", resp.Error
+	}
+	return res.Id, nil
+}
+
+func (m *MMClient) DeleteMessage(postId string) error {
+	_, resp := m.Client.DeletePost(postId)
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (m *MMClient) JoinChannel(channelId string) error {
+	m.RLock()
+	defer m.RUnlock()
+	for _, c := range m.Team.Channels {
+		if c.Id == channelId {
+			m.log.Debug("Not joining ", channelId, " already joined.")
+			return nil
+		}
+	}
+	m.log.Debug("Joining ", channelId)
+	_, resp := m.Client.AddChannelMember(channelId, m.User.Id)
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (m *MMClient) GetPostsSince(channelId string, time int64) *model.PostList {
+	res, resp := m.Client.GetPostsSince(channelId, time)
+	if resp.Error != nil {
+		return nil
+	}
+	return res
+}
+
+func (m *MMClient) SearchPosts(query string) *model.PostList {
+	res, resp := m.Client.SearchPosts(m.Team.Id, query, false)
+	if resp.Error != nil {
+		return nil
+	}
+	return res
+}
+
+func (m *MMClient) GetPosts(channelId string, limit int) *model.PostList {
+	res, resp := m.Client.GetPostsForChannel(channelId, 0, limit, "")
+	if resp.Error != nil {
+		return nil
+	}
+	return res
+}
+
+func (m *MMClient) GetPublicLink(filename string) string {
+	res, resp := m.Client.GetFileLink(filename)
+	if resp.Error != nil {
+		return ""
+	}
+	return res
+}
+
+func (m *MMClient) GetPublicLinks(filenames []string) []string {
+	var output []string
+	for _, f := range filenames {
+		res, resp := m.Client.GetFileLink(f)
+		if resp.Error != nil {
+			continue
+		}
+		output = append(output, res)
+	}
+	return output
+}
+
+func (m *MMClient) GetFileLinks(filenames []string) []string {
+	uriScheme := "https://"
+	if m.NoTLS {
+		uriScheme = "http://"
+	}
+
+	var output []string
+	for _, f := range filenames {
+		res, resp := m.Client.GetFileLink(f)
+		if resp.Error != nil {
+			// public links is probably disabled, create the link ourselves
+			output = append(output, uriScheme+m.Credentials.Server+model.API_URL_SUFFIX_V4+"/files/"+f)
+			continue
+		}
+		output = append(output, res)
+	}
+	return output
+}
+
+func (m *MMClient) UpdateChannelHeader(channelId string, header string) {
+	channel := &model.Channel{Id: channelId, Header: header}
+	m.log.Debugf("updating channelheader %#v, %#v", channelId, header)
+	_, resp := m.Client.UpdateChannel(channel)
+	if resp.Error != nil {
+		log.Error(resp.Error)
+	}
+}
+
+func (m *MMClient) UpdateLastViewed(channelId string) {
+	m.log.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)
+	}
+}
+
+func (m *MMClient) UpdateUserNick(nick string) error {
+	user := m.User
+	user.Nickname = nick
+	_, resp := m.Client.UpdateUser(user)
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (m *MMClient) UsernamesInChannel(channelId string) []string {
+	res, resp := m.Client.GetChannelMembers(channelId, 0, 50000, "")
+	if resp.Error != nil {
+		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, resp.Error)
+		return []string{}
+	}
+	allusers := m.GetUsers()
+	result := []string{}
+	for _, member := range *res {
+		result = append(result, allusers[member.UserId].Nickname)
+	}
+	return result
+}
+
+func (m *MMClient) createCookieJar(token string) *cookiejar.Jar {
+	var cookies []*http.Cookie
+	jar, _ := cookiejar.New(nil)
+	firstCookie := &http.Cookie{
+		Name:   "MMAUTHTOKEN",
+		Value:  token,
+		Path:   "/",
+		Domain: m.Credentials.Server,
+	}
+	cookies = append(cookies, firstCookie)
+	cookieURL, _ := url.Parse("https://" + m.Credentials.Server)
+	jar.SetCookies(cookieURL, cookies)
+	return jar
+}
+
+// SendDirectMessage sends a direct message to specified user
+func (m *MMClient) SendDirectMessage(toUserId string, msg string) {
+	m.log.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)
+		return
+	}
+	channelName := model.GetDMNameFromIds(toUserId, m.User.Id)
+
+	// update our channels
+	m.UpdateChannels()
+
+	// build & send the message
+	msg = strings.Replace(msg, "\r", "", -1)
+	post := &model.Post{ChannelId: m.GetChannelId(channelName, ""), Message: msg}
+	m.Client.CreatePost(post)
+}
+
+// GetTeamName returns the name of the specified teamId
+func (m *MMClient) GetTeamName(teamId string) string {
+	m.RLock()
+	defer m.RUnlock()
+	for _, t := range m.OtherTeams {
+		if t.Id == teamId {
+			return t.Team.Name
+		}
+	}
+	return ""
+}
+
+// GetChannels returns all channels we're members off
+func (m *MMClient) GetChannels() []*model.Channel {
+	m.RLock()
+	defer m.RUnlock()
+	var channels []*model.Channel
+	// our primary team channels first
+	channels = append(channels, m.Team.Channels...)
+	for _, t := range m.OtherTeams {
+		if t.Id != m.Team.Id {
+			channels = append(channels, t.Channels...)
+		}
+	}
+	return channels
+}
+
+// GetMoreChannels returns existing channels where we're not a member off.
+func (m *MMClient) GetMoreChannels() []*model.Channel {
+	m.RLock()
+	defer m.RUnlock()
+	var channels []*model.Channel
+	for _, t := range m.OtherTeams {
+		channels = append(channels, t.MoreChannels...)
+	}
+	return channels
+}
+
+// GetTeamFromChannel returns teamId belonging to channel (DM channels have no teamId).
+func (m *MMClient) GetTeamFromChannel(channelId string) string {
+	m.RLock()
+	defer m.RUnlock()
+	var channels []*model.Channel
+	for _, t := range m.OtherTeams {
+		channels = append(channels, t.Channels...)
+		if t.MoreChannels != nil {
+			channels = append(channels, t.MoreChannels...)
+		}
+		for _, c := range channels {
+			if c.Id == channelId {
+				return t.Id
+			}
+		}
+	}
+	return ""
+}
+
+func (m *MMClient) GetLastViewedAt(channelId string) int64 {
+	m.RLock()
+	defer m.RUnlock()
+	res, resp := m.Client.GetChannelMember(channelId, m.User.Id, "")
+	if resp.Error != nil {
+		return model.GetMillis()
+	}
+	return res.LastViewedAt
+}
+
+func (m *MMClient) GetUsers() map[string]*model.User {
+	users := make(map[string]*model.User)
+	m.RLock()
+	defer m.RUnlock()
+	for k, v := range m.Users {
+		users[k] = v
+	}
+	return users
+}
+
+func (m *MMClient) GetUser(userId string) *model.User {
+	m.Lock()
+	defer m.Unlock()
+	_, ok := m.Users[userId]
+	if !ok {
+		res, resp := m.Client.GetUser(userId, "")
+		if resp.Error != nil {
+			return nil
+		}
+		m.Users[userId] = res
+	}
+	return m.Users[userId]
+}
+
+func (m *MMClient) UpdateUser(userId string) {
+	m.Lock()
+	defer m.Unlock()
+	res, resp := m.Client.GetUser(userId, "")
+	if resp.Error != nil {
+		return
+	}
+	m.Users[userId] = res
+}
+
+func (m *MMClient) GetUserName(userId string) string {
+	user := m.GetUser(userId)
+	if user != nil {
+		return user.Username
+	}
+	return ""
+}
+
+func (m *MMClient) GetNickName(userId string) string {
+	user := m.GetUser(userId)
+	if user != nil {
+		return user.Nickname
+	}
+	return ""
+}
+
+func (m *MMClient) GetStatus(userId string) string {
+	res, resp := m.Client.GetUserStatus(userId, "")
+	if resp.Error != nil {
+		return ""
+	}
+	if res.Status == model.STATUS_AWAY {
+		return "away"
+	}
+	if res.Status == model.STATUS_ONLINE {
+		return "online"
+	}
+	return "offline"
+}
+
+func (m *MMClient) UpdateStatus(userId string, status string) error {
+	_, resp := m.Client.UpdateUserStatus(userId, &model.Status{Status: status})
+	if resp.Error != nil {
+		return resp.Error
+	}
+	return nil
+}
+
+func (m *MMClient) GetStatuses() map[string]string {
+	var ids []string
+	statuses := make(map[string]string)
+	for id := range m.Users {
+		ids = append(ids, id)
+	}
+	res, resp := m.Client.GetUsersStatusesByIds(ids)
+	if resp.Error != nil {
+		return statuses
+	}
+	for _, status := range res {
+		statuses[status.UserId] = "offline"
+		if status.Status == model.STATUS_AWAY {
+			statuses[status.UserId] = "away"
+		}
+		if status.Status == model.STATUS_ONLINE {
+			statuses[status.UserId] = "online"
+		}
+	}
+	return statuses
+}
+
+func (m *MMClient) GetTeamId() string {
+	return m.Team.Id
+}
+
+func (m *MMClient) UploadFile(data []byte, channelId string, filename string) (string, error) {
+	f, resp := m.Client.UploadFile(data, channelId, filename)
+	if resp.Error != nil {
+		return "", resp.Error
+	}
+	return f.FileInfos[0].Id, nil
+}
+
+func (m *MMClient) StatusLoop() {
+	retries := 0
+	backoff := time.Second * 60
+	if m.OnWsConnect != nil {
+		m.OnWsConnect()
+	}
+	m.log.Debug("StatusLoop:", m.OnWsConnect)
+	for {
+		if m.WsQuit {
+			return
+		}
+		if m.WsConnected {
+			m.log.Debug("WS PING")
+			m.sendWSRequest("ping", nil)
+			select {
+			case <-m.WsPingChan:
+				m.log.Debug("WS PONG received")
+				backoff = time.Second * 60
+			case <-time.After(time.Second * 5):
+				if retries > 3 {
+					m.log.Debug("StatusLoop() timeout")
+					m.Logout()
+					m.WsQuit = false
+					err := m.Login()
+					if err != nil {
+						log.Errorf("Login failed: %#v", err)
+						break
+					}
+					if m.OnWsConnect != nil {
+						m.OnWsConnect()
+					}
+					go m.WsReceiver()
+				} else {
+					retries++
+					backoff = time.Second * 5
+				}
+			}
+		}
+		time.Sleep(backoff)
+	}
+}
+
+// initialize user and teams
+func (m *MMClient) initUser() error {
+	m.Lock()
+	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")
+	teams, resp := m.Client.GetTeamsForUser(m.User.Id, "")
+	if resp.Error != nil {
+		return resp.Error
+	}
+	for _, team := range teams {
+		mmusers, resp := m.Client.GetUsersInTeam(team.Id, 0, 50000, "")
+		if resp.Error != nil {
+			return errors.New(resp.Error.DetailedError)
+		}
+		usermap := make(map[string]*model.User)
+		for _, user := range mmusers {
+			usermap[user.Id] = user
+		}
+
+		t := &Team{Team: team, Users: usermap, Id: team.Id}
+
+		mmchannels, resp := m.Client.GetChannelsForTeamForUser(team.Id, m.User.Id, "")
+		if resp.Error != nil {
+			return resp.Error
+		}
+		t.Channels = mmchannels
+		mmchannels, resp = m.Client.GetPublicChannelsForTeam(team.Id, 0, 5000, "")
+		if resp.Error != nil {
+			return resp.Error
+		}
+		t.MoreChannels = mmchannels
+		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)
+		}
+		// add all users
+		for k, v := range t.Users {
+			m.Users[k] = v
+		}
+	}
+	return nil
+}
+
+func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) error {
+	req := &model.WebSocketRequest{}
+	req.Seq = m.WsSequence
+	req.Action = action
+	req.Data = data
+	m.WsSequence++
+	m.log.Debugf("sendWsRequest %#v", req)
+	m.WsClient.WriteJSON(req)
+	return nil
+}
+
+func supportedVersion(version string) bool {
+	if strings.HasPrefix(version, "3.8.0") ||
+		strings.HasPrefix(version, "3.9.0") ||
+		strings.HasPrefix(version, "3.10.0") ||
+		strings.HasPrefix(version, "4.") ||
+		strings.HasPrefix(version, "5.") {
+		return true
+	}
+	return false
+}
+
+func digestString(s string) string {
+	return fmt.Sprintf("%x", md5.Sum([]byte(s)))
+}

matterhook/matterhook.go

@@ -6,38 +6,47 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"github.com/gorilla/schema"
 	"io"
 	"io/ioutil"
 	"log"
+	"net"
 	"net/http"
-	"strconv"
+	"time"
+
+	"github.com/gorilla/schema"
+	"github.com/nlopes/slack"
 )
 
 // OMessage for mattermost incoming webhook. (send to mattermost)
 type OMessage struct {
-	Channel     string      `json:"channel,omitempty"`
-	IconURL     string      `json:"icon_url,omitempty"`
-	IconEmoji   string      `json:"icon_emoji,omitempty"`
-	UserName    string      `json:"username,omitempty"`
-	Text        string      `json:"text"`
-	Attachments interface{} `json:"attachments,omitempty"`
-	Type        string      `json:"type,omitempty"`
+	Channel     string                 `json:"channel,omitempty"`
+	IconURL     string                 `json:"icon_url,omitempty"`
+	IconEmoji   string                 `json:"icon_emoji,omitempty"`
+	UserName    string                 `json:"username,omitempty"`
+	Text        string                 `json:"text"`
+	Attachments []slack.Attachment     `json:"attachments,omitempty"`
+	Type        string                 `json:"type,omitempty"`
+	Props       map[string]interface{} `json:"props"`
 }
 
 // IMessage for mattermost outgoing webhook. (received from mattermost)
 type IMessage struct {
+	BotID       string `schema:"bot_id"`
+	BotName     string `schema:"bot_name"`
 	Token       string `schema:"token"`
 	TeamID      string `schema:"team_id"`
 	TeamDomain  string `schema:"team_domain"`
 	ChannelID   string `schema:"channel_id"`
-	ServiceID   string `schema:"service_id"`
 	ChannelName string `schema:"channel_name"`
 	Timestamp   string `schema:"timestamp"`
 	UserID      string `schema:"user_id"`
 	UserName    string `schema:"user_name"`
+	PostId      string `schema:"post_id"`
+	RawText     string `schema:"raw_text"`
+	ServiceId   string `schema:"service_id"`
 	Text        string `schema:"text"`
 	TriggerWord string `schema:"trigger_word"`
+	FileIDs     string `schema:"file_ids"`
 }
 
 // Client for Mattermost.
@@ -51,7 +60,6 @@ type Client struct {
 
 // Config for client.
 type Config struct {
-	Port               int    // Port to listen on.
 	BindAddress        string // Address to listen on
 	Token              string // Only allow this token from Mattermost. (Allow everything when empty)
 	InsecureSkipVerify bool   // disable certificate checking
@@ -61,15 +69,15 @@ type Config struct {
 // New Mattermost client.
 func New(url string, config Config) *Client {
 	c := &Client{Url: url, In: make(chan IMessage), Out: make(chan OMessage), Config: config}
-	if c.Port == 0 {
-		c.Port = 9999
-	}
-	c.BindAddress += ":"
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{InsecureSkipVerify: config.InsecureSkipVerify},
 	}
 	c.httpclient = &http.Client{Transport: tr}
 	if !c.DisableServer {
+		_, _, err := net.SplitHostPort(c.BindAddress)
+		if err != nil {
+			log.Fatalf("incorrect bindaddress %s", c.BindAddress)
+		}
 		go c.StartServer()
 	}
 	return c
@@ -79,8 +87,14 @@ func New(url string, config Config) *Client {
 func (c *Client) StartServer() {
 	mux := http.NewServeMux()
 	mux.Handle("/", c)
-	log.Printf("Listening on http://%v:%v...\n", c.BindAddress, c.Port)
-	if err := http.ListenAndServe((c.BindAddress + strconv.Itoa(c.Port)), mux); err != nil {
+	srv := &http.Server{
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 10 * time.Second,
+		Handler:      mux,
+		Addr:         c.BindAddress,
+	}
+	log.Printf("Listening on http://%v...\n", c.BindAddress)
+	if err := srv.ListenAndServe(); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -124,12 +138,11 @@ func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 // Receive returns an incoming message from mattermost outgoing webhooks URL.
 func (c *Client) Receive() IMessage {
-	for {
-		select {
-		case msg := <-c.In:
-			return msg
-		}
+	var msg IMessage
+	for msg := range c.In {
+		return msg
 	}
+	return msg
 }
 
 // Send sends a msg to mattermost incoming webhooks URL.

vendor/github.com/42wim/go-gitter/.gitignore

@@ -0,0 +1,3 @@
+.idea
+/test
+app.yaml

vendor/github.com/42wim/go-gitter/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/42wim/go-gitter/README.md

@@ -0,0 +1,154 @@
+# gitter
+Gitter API in Go
+https://developer.gitter.im
+
+#### Install
+
+`go get github.com/sromku/go-gitter`
+
+- [Initialize](#initialize)
+- [Users](#users)
+- [Rooms](#rooms)
+- [Messages](#messages)
+- [Stream](#stream)
+- [Faye (Experimental)](#faye-experimental)
+- [Debug](#debug)
+- [App Engine](#app-engine)
+
+##### Initialize
+``` Go
+api := gitter.New("YOUR_ACCESS_TOKEN")
+```
+
+##### Users
+
+- Get current user
+
+	``` Go
+	user, err := api.GetUser()
+	```
+
+##### Rooms
+
+- Get all rooms
+	``` Go
+	rooms, err := api.GetRooms()
+	```
+
+- Get room by id
+	``` Go
+	room, err := api.GetRoom("roomID")
+	```
+
+- Get rooms of some user
+	``` Go
+	rooms, err := api.GetRooms("userID")
+	```
+
+- Join room
+	``` Go
+	room, err := api.JoinRoom("roomID", "userID")
+	```
+	
+- Leave room
+	``` Go
+	room, err := api.LeaveRoom("roomID", "userID")
+	```
+
+- Get room id
+	``` Go
+	id, err := api.GetRoomId("room/uri")
+	```
+
+- Search gitter rooms
+	``` Go
+	rooms, err := api.SearchRooms("search/string")
+	```
+##### Messages
+
+- Get messages of room
+	``` Go
+	messages, err := api.GetMessages("roomID", nil)
+	```
+
+- Get one message
+	``` Go
+	message, err := api.GetMessage("roomID", "messageID")
+	```
+
+- Send message
+	``` Go
+	err := api.SendMessage("roomID", "free chat text")
+	```
+
+##### Stream
+
+Create stream to the room and start listening to incoming messages
+
+``` Go
+stream := api.Stream(room.Id)
+go api.Listen(stream)
+
+for {
+    event := <-stream.Event
+    switch ev := event.Data.(type) {
+    case *gitter.MessageReceived:
+        fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+    case *gitter.GitterConnectionClosed:
+        // connection was closed
+    }
+}
+```
+
+Close stream connection
+
+``` Go
+stream.Close()
+```
+
+##### Faye (Experimental)
+
+``` Go
+faye := api.Faye(room.ID)
+go faye.Listen()
+
+for {
+    event := <-faye.Event
+    switch ev := event.Data.(type) {
+    case *gitter.MessageReceived:
+        fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+    case *gitter.GitterConnectionClosed: //this one is never called in Faye
+        // connection was closed
+    }
+}
+```
+
+##### Debug
+
+You can print the internal errors by enabling debug to true
+
+``` Go
+api.SetDebug(true, nil)
+```
+
+You can also define your own `io.Writer` in case you want to persist the logs somewhere.
+For example keeping the errors on file
+
+``` Go
+logFile, err := os.Create("gitter.log")
+api.SetDebug(true, logFile)
+```
+
+##### App Engine
+
+Initialize app engine client and continue as usual
+
+``` Go
+c := appengine.NewContext(r)
+client := urlfetch.Client(c)
+
+api := gitter.New("YOUR_ACCESS_TOKEN")
+api.SetClient(client)
+```
+
+[Documentation](https://godoc.org/github.com/sromku/go-gitter)

vendor/github.com/42wim/go-gitter/faye.go

@@ -0,0 +1,70 @@
+package gitter
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/mrexodia/wray"
+)
+
+type Faye struct {
+	endpoint string
+	Event    chan Event
+	client   *wray.FayeClient
+	gitter   *Gitter
+}
+
+func (gitter *Gitter) Faye(roomID string) *Faye {
+	wray.RegisterTransports([]wray.Transport{
+		&wray.HttpTransport{
+			SendHook: func(data map[string]interface{}) {
+				if channel, ok := data["channel"]; ok && channel == "/meta/handshake" {
+					data["ext"] = map[string]interface{}{"token": gitter.config.token}
+				}
+			},
+		},
+	})
+	return &Faye{
+		endpoint: "/api/v1/rooms/" + roomID + "/chatMessages",
+		Event:    make(chan Event),
+		client:   wray.NewFayeClient(fayeBaseURL),
+		gitter:   gitter,
+	}
+}
+
+func (faye *Faye) Listen() {
+	defer faye.destroy()
+
+	faye.client.Subscribe(faye.endpoint, false, func(message wray.Message) {
+		dataBytes, err := json.Marshal(message.Data["model"])
+		if err != nil {
+			fmt.Printf("JSON Marshal error: %v\n", err)
+			return
+		}
+		var gitterMessage Message
+		err = json.Unmarshal(dataBytes, &gitterMessage)
+		if err != nil {
+			fmt.Printf("JSON Unmarshal error: %v\n", err)
+			return
+		}
+		faye.Event <- Event{
+			Data: &MessageReceived{
+				Message: gitterMessage,
+			},
+		}
+	})
+
+	//TODO: this might be needed in the future
+	/*go func() {
+		for {
+			faye.client.Publish("/api/v1/ping2", map[string]interface{}{"reason": "ping"})
+			time.Sleep(60 * time.Second)
+		}
+	}()*/
+
+	faye.client.Listen()
+}
+
+func (faye *Faye) destroy() {
+	close(faye.Event)
+}

vendor/github.com/42wim/go-gitter/gitter.go

@@ -0,0 +1,527 @@
+// Package gitter is a Go client library for the Gitter API.
+//
+// Author: sromku
+package gitter
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/mreiferson/go-httpclient"
+)
+
+var (
+	apiBaseURL    = "https://api.gitter.im/v1/"
+	streamBaseURL = "https://stream.gitter.im/v1/"
+	fayeBaseURL   = "https://ws.gitter.im/faye"
+)
+
+type Gitter struct {
+	config struct {
+		apiBaseURL    string
+		streamBaseURL string
+		token         string
+		client        *http.Client
+	}
+	debug     bool
+	logWriter io.Writer
+}
+
+// New initializes the Gitter API client
+//
+// For example:
+//  api := gitter.New("YOUR_ACCESS_TOKEN")
+func New(token string) *Gitter {
+
+	transport := &httpclient.Transport{
+		ConnectTimeout:   5 * time.Second,
+		ReadWriteTimeout: 40 * time.Second,
+	}
+	defer transport.Close()
+
+	s := &Gitter{}
+	s.config.apiBaseURL = apiBaseURL
+	s.config.streamBaseURL = streamBaseURL
+	s.config.token = token
+	s.config.client = &http.Client{
+		Transport: transport,
+	}
+	return s
+}
+
+// SetClient sets a custom http client. Can be useful in App Engine case.
+func (gitter *Gitter) SetClient(client *http.Client) {
+	gitter.config.client = client
+}
+
+// GetUser returns the current user
+func (gitter *Gitter) GetUser() (*User, error) {
+
+	var users []User
+	response, err := gitter.get(gitter.config.apiBaseURL + "user")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &users)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	if len(users) > 0 {
+		return &users[0], nil
+	}
+
+	err = APIError{What: "Failed to retrieve current user"}
+	gitter.log(err)
+	return nil, err
+}
+
+// GetUserRooms returns a list of Rooms the user is part of
+func (gitter *Gitter) GetUserRooms(userID string) ([]Room, error) {
+
+	var rooms []Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "user/" + userID + "/rooms")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &rooms)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+// GetRooms returns a list of rooms the current user is in
+func (gitter *Gitter) GetRooms() ([]Room, error) {
+
+	var rooms []Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &rooms)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+// GetUsersInRoom returns the users in the room with the passed id
+func (gitter *Gitter) GetUsersInRoom(roomID string) ([]User, error) {
+	var users []User
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/users")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &users)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	return users, nil
+}
+
+// GetRoom returns a room with the passed id
+func (gitter *Gitter) GetRoom(roomID string) (*Room, error) {
+
+	var room Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &room)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &room, nil
+}
+
+// GetMessages returns a list of messages in a room.
+// Pagination is optional. You can pass nil or specific pagination params.
+func (gitter *Gitter) GetMessages(roomID string, params *Pagination) ([]Message, error) {
+
+	var messages []Message
+	url := gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages"
+	if params != nil {
+		url += "?" + params.encode()
+	}
+	response, err := gitter.get(url)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &messages)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return messages, nil
+}
+
+// GetMessage returns a message in a room.
+func (gitter *Gitter) GetMessage(roomID, messageID string) (*Message, error) {
+
+	var message Message
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages/" + messageID)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &message)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &message, nil
+}
+
+// SendMessage sends a message to a room
+func (gitter *Gitter) SendMessage(roomID, text string) (*Message, error) {
+
+	message := Message{Text: text}
+	body, _ := json.Marshal(message)
+	response, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &message)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &message, nil
+}
+
+// UpdateMessage updates a message in a room
+func (gitter *Gitter) UpdateMessage(roomID, msgID, text string) (*Message, error) {
+
+	message := Message{Text: text}
+	body, _ := json.Marshal(message)
+	response, err := gitter.put(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages/"+msgID, body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &message)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &message, nil
+}
+
+// JoinRoom joins a room
+func (gitter *Gitter) JoinRoom(roomID, userID string) (*Room, error) {
+
+	message := Room{ID: roomID}
+	body, _ := json.Marshal(message)
+	response, err := gitter.post(gitter.config.apiBaseURL+"user/"+userID+"/rooms", body)
+
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	var room Room
+	err = json.Unmarshal(response, &room)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &room, nil
+}
+
+// LeaveRoom removes a user from the room
+func (gitter *Gitter) LeaveRoom(roomID, userID string) error {
+
+	_, err := gitter.delete(gitter.config.apiBaseURL + "rooms/" + roomID + "/users/" + userID)
+	if err != nil {
+		gitter.log(err)
+		return err
+	}
+
+	return nil
+}
+
+// SetDebug traces errors if it's set to true.
+func (gitter *Gitter) SetDebug(debug bool, logWriter io.Writer) {
+	gitter.debug = debug
+	gitter.logWriter = logWriter
+}
+
+// SearchRooms queries the Rooms resources of gitter API
+func (gitter *Gitter) SearchRooms(room string) ([]Room, error) {
+
+	var rooms struct {
+		Results []Room `json:"results"`
+	}
+
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms?q=" + room)
+
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &rooms)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	return rooms.Results, nil
+}
+
+// GetRoomId returns the room ID of a given URI
+func (gitter *Gitter) GetRoomId(uri string) (string, error) {
+
+	rooms, err := gitter.SearchRooms(uri)
+	if err != nil {
+		gitter.log(err)
+		return "", err
+	}
+
+	for _, element := range rooms {
+		if element.URI == uri {
+			return element.ID, nil
+		}
+	}
+	return "", APIError{What: "Room not found."}
+}
+
+// Pagination params
+type Pagination struct {
+
+	// Skip n messages
+	Skip int
+
+	// Get messages before beforeId
+	BeforeID string
+
+	// Get messages after afterId
+	AfterID string
+
+	// Maximum number of messages to return
+	Limit int
+
+	// Search query
+	Query string
+}
+
+func (messageParams *Pagination) encode() string {
+	values := url.Values{}
+
+	if messageParams.AfterID != "" {
+		values.Add("afterId", messageParams.AfterID)
+	}
+
+	if messageParams.BeforeID != "" {
+		values.Add("beforeId", messageParams.BeforeID)
+	}
+
+	if messageParams.Skip > 0 {
+		values.Add("skip", strconv.Itoa(messageParams.Skip))
+	}
+
+	if messageParams.Limit > 0 {
+		values.Add("limit", strconv.Itoa(messageParams.Limit))
+	}
+
+	return values.Encode()
+}
+
+func (gitter *Gitter) getResponse(url string, stream *Stream) (*http.Response, error) {
+	r, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+	if stream != nil {
+		stream.streamConnection.request = r
+	}
+	response, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	return response, nil
+}
+
+func (gitter *Gitter) get(url string) ([]byte, error) {
+	resp, err := gitter.getResponse(url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return body, nil
+}
+
+func (gitter *Gitter) post(url string, body []byte) ([]byte, error) {
+	r, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+
+	resp, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (gitter *Gitter) put(url string, body []byte) ([]byte, error) {
+	r, err := http.NewRequest("PUT", url, bytes.NewBuffer(body))
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+
+	resp, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (gitter *Gitter) delete(url string) ([]byte, error) {
+	r, err := http.NewRequest("delete", url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+
+	resp, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (gitter *Gitter) log(a interface{}) {
+	if gitter.debug {
+		log.Println(a)
+		if gitter.logWriter != nil {
+			timestamp := time.Now().Format(time.RFC3339)
+			msg := fmt.Sprintf("%v: %v", timestamp, a)
+			fmt.Fprintln(gitter.logWriter, msg)
+		}
+	}
+}
+
+// APIError holds data of errors returned from the API.
+type APIError struct {
+	What string
+}
+
+func (e APIError) Error() string {
+	return fmt.Sprintf("%v", e.What)
+}

vendor/github.com/42wim/go-gitter/model.go

@@ -0,0 +1,142 @@
+package gitter
+
+import "time"
+
+// A Room in Gitter can represent a GitHub Organization, a GitHub Repository, a Gitter Channel or a One-to-one conversation.
+// In the case of the Organizations and Repositories, the access control policies are inherited from GitHub.
+type Room struct {
+
+	// Room ID
+	ID string `json:"id"`
+
+	// Room name
+	Name string `json:"name"`
+
+	// Room topic. (default: GitHub repo description)
+	Topic string `json:"topic"`
+
+	// Room URI on Gitter
+	URI string `json:"uri"`
+
+	// Indicates if the room is a one-to-one chat
+	OneToOne bool `json:"oneToOne"`
+
+	// Count of users in the room
+	UserCount int `json:"userCount"`
+
+	// Number of unread messages for the current user
+	UnreadItems int `json:"unreadItems"`
+
+	// Number of unread mentions for the current user
+	Mentions int `json:"mentions"`
+
+	// Last time the current user accessed the room in ISO format
+	LastAccessTime time.Time `json:"lastAccessTime"`
+
+	// Indicates if the current user has disabled notifications
+	Lurk bool `json:"lurk"`
+
+	// Path to the room on gitter
+	URL string `json:"url"`
+
+	// Type of the room
+	// - ORG: A room that represents a GitHub Organization.
+	// - REPO: A room that represents a GitHub Repository.
+	// - ONETOONE: A one-to-one chat.
+	// - ORG_CHANNEL: A Gitter channel nested under a GitHub Organization.
+	// - REPO_CHANNEL A Gitter channel nested under a GitHub Repository.
+	// - USER_CHANNEL A Gitter channel nested under a GitHub User.
+	GithubType string `json:"githubType"`
+
+	// Tags that define the room
+	Tags []string `json:"tags"`
+
+	RoomMember bool `json:"roomMember"`
+
+	// Room version.
+	Version int `json:"v"`
+}
+
+type User struct {
+
+	// Gitter User ID
+	ID string `json:"id"`
+
+	// Gitter/GitHub username
+	Username string `json:"username"`
+
+	// Gitter/GitHub user real name
+	DisplayName string `json:"displayName"`
+
+	// Path to the user on Gitter
+	URL string `json:"url"`
+
+	// User avatar URI (small)
+	AvatarURLSmall string `json:"avatarUrlSmall"`
+
+	// User avatar URI (medium)
+	AvatarURLMedium string `json:"avatarUrlMedium"`
+}
+
+type Message struct {
+
+	// ID of the message
+	ID string `json:"id"`
+
+	// Original message in plain-text/markdown
+	Text string `json:"text"`
+
+	// HTML formatted message
+	HTML string `json:"html"`
+
+	// ISO formatted date of the message
+	Sent time.Time `json:"sent"`
+
+	// ISO formatted date of the message if edited
+	EditedAt time.Time `json:"editedAt"`
+
+	// User that sent the message
+	From User `json:"fromUser"`
+
+	// Boolean that indicates if the current user has read the message.
+	Unread bool `json:"unread"`
+
+	// Number of users that have read the message
+	ReadBy int `json:"readBy"`
+
+	// List of URLs present in the message
+	Urls []URL `json:"urls"`
+
+	// List of @Mentions in the message
+	Mentions []Mention `json:"mentions"`
+
+	// List of #Issues referenced in the message
+	Issues []Issue `json:"issues"`
+
+	// Version
+	Version int `json:"v"`
+}
+
+// Mention holds data about mentioned user in the message
+type Mention struct {
+
+	// User's username
+	ScreenName string `json:"screenName"`
+
+	// Gitter User ID
+	UserID string `json:"userID"`
+}
+
+// Issue references issue in the message
+type Issue struct {
+
+	// Issue number
+	Number string `json:"number"`
+}
+
+// URL presented in the message
+type URL struct {
+
+	// URL
+	URL string `json:"url"`
+}

vendor/github.com/42wim/go-gitter/stream.go

@@ -0,0 +1,217 @@
+package gitter
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/mreiferson/go-httpclient"
+)
+
+var defaultConnectionWaitTime time.Duration = 3000 // millis
+var defaultConnectionMaxRetries = 5
+
+// Stream initialize stream
+func (gitter *Gitter) Stream(roomID string) *Stream {
+	return &Stream{
+		url:    streamBaseURL + "rooms/" + roomID + "/chatMessages",
+		Event:  make(chan Event),
+		gitter: gitter,
+		streamConnection: gitter.newStreamConnection(
+			defaultConnectionWaitTime,
+			defaultConnectionMaxRetries),
+	}
+}
+
+// Implemented to conform with https://developer.gitter.im/docs/streaming-api
+func (gitter *Gitter) Listen(stream *Stream) {
+
+	defer stream.destroy()
+
+	var reader *bufio.Reader
+	var gitterMessage Message
+	lastKeepalive := time.Now().Unix()
+
+	// connect
+	stream.connect()
+
+Loop:
+	for {
+
+		// if closed then stop trying
+		if stream.isClosed() {
+			stream.Event <- Event{
+				Data: &GitterConnectionClosed{},
+			}
+			break Loop
+		}
+		
+		resp := stream.getResponse()
+		if resp.StatusCode != 200 {
+			gitter.log(fmt.Sprintf("Unexpected response code %v", resp.StatusCode))
+			continue
+		}
+		
+		//"The JSON stream returns messages as JSON objects that are delimited by carriage return (\r)" <- Not true crap it's (\n) only
+		reader = bufio.NewReader(resp.Body)
+		line, err := reader.ReadBytes('\n')
+		if err != nil {
+			gitter.log("ReadBytes error: " + err.Error())
+			stream.connect()
+			continue
+		}
+
+		//Check if the line only consists of whitespace
+		onlyWhitespace := true
+		for _, b := range line {
+			if b != ' ' && b != '\t' && b != '\r' && b != '\n' {
+				onlyWhitespace = false
+			}
+		}
+
+		if onlyWhitespace {
+			//"Parsers must be tolerant of occasional extra newline characters placed between messages."
+			currentKeepalive := time.Now().Unix() //interesting behavior of 100+ keepalives per seconds was observed
+			if currentKeepalive-lastKeepalive > 10 {
+				lastKeepalive = currentKeepalive
+				gitter.log("Keepalive was received")
+			}
+			continue
+		} else if stream.isClosed() {
+			gitter.log("Stream closed")
+			continue
+		}
+
+		// unmarshal the streamed data
+		err = json.Unmarshal(line, &gitterMessage)
+		if err != nil {
+			gitter.log("JSON Unmarshal error: " + err.Error())
+			continue
+		}
+
+		// we are here, then we got the good message. pipe it forward.
+		stream.Event <- Event{
+			Data: &MessageReceived{
+				Message: gitterMessage,
+			},
+		}
+	}
+
+	gitter.log("Listening was completed")
+}
+
+// Stream holds stream data.
+type Stream struct {
+	url              string
+	Event            chan Event
+	streamConnection *streamConnection
+	gitter           *Gitter
+}
+
+func (stream *Stream) destroy() {
+	close(stream.Event)
+	stream.streamConnection.currentRetries = 0
+}
+
+type Event struct {
+	Data interface{}
+}
+
+type GitterConnectionClosed struct {
+}
+
+type MessageReceived struct {
+	Message Message
+}
+
+// connect and try to reconnect with
+func (stream *Stream) connect() {
+
+	if stream.streamConnection.retries == stream.streamConnection.currentRetries {
+		stream.Close()
+		stream.gitter.log("Number of retries exceeded the max retries number, we are done here")
+		return
+	}
+
+	res, err := stream.gitter.getResponse(stream.url, stream)
+	if err != nil || res.StatusCode != 200 {
+		stream.gitter.log("Failed to get response, trying reconnect")
+		if res != nil {
+			stream.gitter.log(fmt.Sprintf("Status code: %v", res.StatusCode))
+		}
+		stream.gitter.log(err)
+
+		// sleep and wait
+		stream.streamConnection.currentRetries++
+		time.Sleep(time.Millisecond * stream.streamConnection.wait * time.Duration(stream.streamConnection.currentRetries))
+
+		// connect again
+		stream.Close()
+		stream.connect()
+	} else {
+		stream.gitter.log("Response was received")
+		stream.streamConnection.currentRetries = 0
+		stream.streamConnection.closed = false
+		stream.streamConnection.response = res
+	}
+}
+
+type streamConnection struct {
+
+	// connection was closed
+	closed bool
+
+	// wait time till next try
+	wait time.Duration
+
+	// max tries to recover
+	retries int
+
+	// current streamed response
+	response *http.Response
+
+	// current request
+	request *http.Request
+
+	// current status
+	currentRetries int
+}
+
+// Close the stream connection and stop receiving streamed data
+func (stream *Stream) Close() {
+	conn := stream.streamConnection
+	conn.closed = true
+	if conn.response != nil {
+		stream.gitter.log("Stream connection close response")
+		defer conn.response.Body.Close()
+	}
+	if conn.request != nil {
+		stream.gitter.log("Stream connection close request")
+		switch transport := stream.gitter.config.client.Transport.(type) {
+		case *httpclient.Transport:
+			transport.CancelRequest(conn.request)
+		default:
+		}
+	}
+}
+
+func (stream *Stream) isClosed() bool {
+	return stream.streamConnection.closed
+}
+
+func (stream *Stream) getResponse() *http.Response {
+	return stream.streamConnection.response
+}
+
+// Optional, set stream connection properties
+// wait - time in milliseconds of waiting between reconnections. Will grow exponentially.
+// retries - number of reconnections retries before dropping the stream.
+func (gitter *Gitter) newStreamConnection(wait time.Duration, retries int) *streamConnection {
+	return &streamConnection{
+		closed:  true,
+		wait:    wait,
+		retries: retries,
+	}
+}

vendor/github.com/42wim/go-gitter/test_utils.go

@@ -0,0 +1,30 @@
+package gitter
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+)
+
+var (
+	mux    *http.ServeMux
+	gitter *Gitter
+	server *httptest.Server
+)
+
+func setup() {
+	mux = http.NewServeMux()
+	server = httptest.NewServer(mux)
+
+	gitter = New("abc")
+
+	// Fake the API and Stream base URLs by using the test
+	// server URL instead.
+	url, _ := url.Parse(server.URL)
+	gitter.config.apiBaseURL = url.String() + "/"
+	gitter.config.streamBaseURL = url.String() + "/"
+}
+
+func teardown() {
+	server.Close()
+}

vendor/github.com/BurntSushi/toml/.gitignore

@@ -0,0 +1,5 @@
+TAGS
+tags
+.*.swp
+tomlcheck/tomlcheck
+toml.test

vendor/github.com/BurntSushi/toml/.travis.yml

@@ -0,0 +1,15 @@
+language: go
+go:
+  - 1.1
+  - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
+  - 1.6
+  - tip
+install:
+  - go install ./...
+  - go get github.com/BurntSushi/toml-test
+script:
+  - export PATH="$PATH:$HOME/gopath/bin"
+  - make test

vendor/github.com/BurntSushi/toml/COMPATIBLE

@@ -0,0 +1,3 @@
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md)
+

vendor/github.com/BurntSushi/toml/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

vendor/github.com/BurntSushi/toml/Makefile

@@ -0,0 +1,19 @@
+install:
+	go install ./...
+
+test: install
+	go test -v
+	toml-test toml-test-decoder
+	toml-test -encoder toml-test-encoder
+
+fmt:
+	gofmt -w *.go */*.go
+	colcheck *.go */*.go
+
+tags:
+	find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
+
+push:
+	git push origin master
+	git push github master
+

vendor/github.com/BurntSushi/toml/README.md

@@ -0,0 +1,218 @@
+## TOML parser and encoder for Go with reflection
+
+TOML stands for Tom's Obvious, Minimal Language. This Go package provides a
+reflection interface similar to Go's standard library `json` and `xml`
+packages. This package also supports the `encoding.TextUnmarshaler` and
+`encoding.TextMarshaler` interfaces so that you can define custom data
+representations. (There is an example of this below.)
+
+Spec: https://github.com/toml-lang/toml
+
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
+
+Documentation: https://godoc.org/github.com/BurntSushi/toml
+
+Installation:
+
+```bash
+go get github.com/BurntSushi/toml
+```
+
+Try the toml validator:
+
+```bash
+go get github.com/BurntSushi/toml/cmd/tomlv
+tomlv some-toml-file.toml
+```
+
+[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)
+
+### Testing
+
+This package passes all tests in
+[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder
+and the encoder.
+
+### Examples
+
+This package works similarly to how the Go standard library handles `XML`
+and `JSON`. Namely, data is loaded into Go values via reflection.
+
+For the simplest example, consider some TOML file as just a list of keys
+and values:
+
+```toml
+Age = 25
+Cats = [ "Cauchy", "Plato" ]
+Pi = 3.14
+Perfection = [ 6, 28, 496, 8128 ]
+DOB = 1987-07-05T05:45:00Z
+```
+
+Which could be defined in Go as:
+
+```go
+type Config struct {
+  Age int
+  Cats []string
+  Pi float64
+  Perfection []int
+  DOB time.Time // requires `import time`
+}
+```
+
+And then decoded with:
+
+```go
+var conf Config
+if _, err := toml.Decode(tomlData, &conf); err != nil {
+  // handle error
+}
+```
+
+You can also use struct tags if your struct field name doesn't map to a TOML
+key value directly:
+
+```toml
+some_key_NAME = "wat"
+```
+
+```go
+type TOML struct {
+  ObscureKey string `toml:"some_key_NAME"`
+}
+```
+
+### Using the `encoding.TextUnmarshaler` interface
+
+Here's an example that automatically parses duration strings into
+`time.Duration` values:
+
+```toml
+[[song]]
+name = "Thunder Road"
+duration = "4m49s"
+
+[[song]]
+name = "Stairway to Heaven"
+duration = "8m03s"
+```
+
+Which can be decoded with:
+
+```go
+type song struct {
+  Name     string
+  Duration duration
+}
+type songs struct {
+  Song []song
+}
+var favorites songs
+if _, err := toml.Decode(blob, &favorites); err != nil {
+  log.Fatal(err)
+}
+
+for _, s := range favorites.Song {
+  fmt.Printf("%s (%s)\n", s.Name, s.Duration)
+}
+```
+
+And you'll also need a `duration` type that satisfies the
+`encoding.TextUnmarshaler` interface:
+
+```go
+type duration struct {
+	time.Duration
+}
+
+func (d *duration) UnmarshalText(text []byte) error {
+	var err error
+	d.Duration, err = time.ParseDuration(string(text))
+	return err
+}
+```
+
+### More complex usage
+
+Here's an example of how to load the example from the official spec page:
+
+```toml
+# This is a TOML document. Boom.
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+organization = "GitHub"
+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+  # You can indent as you please. Tabs or spaces. TOML don't care.
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
+
+# Line breaks are OK when inside arrays
+hosts = [
+  "alpha",
+  "omega"
+]
+```
+
+And the corresponding Go types are:
+
+```go
+type tomlConfig struct {
+	Title string
+	Owner ownerInfo
+	DB database `toml:"database"`
+	Servers map[string]server
+	Clients clients
+}
+
+type ownerInfo struct {
+	Name string
+	Org string `toml:"organization"`
+	Bio string
+	DOB time.Time
+}
+
+type database struct {
+	Server string
+	Ports []int
+	ConnMax int `toml:"connection_max"`
+	Enabled bool
+}
+
+type server struct {
+	IP string
+	DC string
+}
+
+type clients struct {
+	Data [][]interface{}
+	Hosts []string
+}
+```
+
+Note that a case insensitive match will be tried if an exact match can't be
+found.
+
+A working example of the above can be found in `_examples/example.{go,toml}`.

vendor/github.com/BurntSushi/toml/decode.go

@@ -0,0 +1,509 @@
+package toml
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"reflect"
+	"strings"
+	"time"
+)
+
+func e(format string, args ...interface{}) error {
+	return fmt.Errorf("toml: "+format, args...)
+}
+
+// Unmarshaler is the interface implemented by objects that can unmarshal a
+// TOML description of themselves.
+type Unmarshaler interface {
+	UnmarshalTOML(interface{}) error
+}
+
+// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
+func Unmarshal(p []byte, v interface{}) error {
+	_, err := Decode(string(p), v)
+	return err
+}
+
+// Primitive is a TOML value that hasn't been decoded into a Go value.
+// When using the various `Decode*` functions, the type `Primitive` may
+// be given to any value, and its decoding will be delayed.
+//
+// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
+//
+// The underlying representation of a `Primitive` value is subject to change.
+// Do not rely on it.
+//
+// N.B. Primitive values are still parsed, so using them will only avoid
+// the overhead of reflection. They can be useful when you don't know the
+// exact type of TOML data until run time.
+type Primitive struct {
+	undecoded interface{}
+	context   Key
+}
+
+// DEPRECATED!
+//
+// Use MetaData.PrimitiveDecode instead.
+func PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md := MetaData{decoded: make(map[string]bool)}
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// PrimitiveDecode is just like the other `Decode*` functions, except it
+// decodes a TOML value that has already been parsed. Valid primitive values
+// can *only* be obtained from values filled by the decoder functions,
+// including this method. (i.e., `v` may contain more `Primitive`
+// values.)
+//
+// Meta data for primitive values is included in the meta data returned by
+// the `Decode*` functions with one exception: keys returned by the Undecoded
+// method will only reflect keys that were decoded. Namely, any keys hidden
+// behind a Primitive will be considered undecoded. Executing this method will
+// update the undecoded keys in the meta data. (See the example.)
+func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md.context = primValue.context
+	defer func() { md.context = nil }()
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// Decode will decode the contents of `data` in TOML format into a pointer
+// `v`.
+//
+// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
+// used interchangeably.)
+//
+// TOML arrays of tables correspond to either a slice of structs or a slice
+// of maps.
+//
+// TOML datetimes correspond to Go `time.Time` values.
+//
+// All other TOML types (float, string, int, bool and array) correspond
+// to the obvious Go types.
+//
+// An exception to the above rules is if a type implements the
+// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
+// (floats, strings, integers, booleans and datetimes) will be converted to
+// a byte string and given to the value's UnmarshalText method. See the
+// Unmarshaler example for a demonstration with time duration strings.
+//
+// Key mapping
+//
+// TOML keys can map to either keys in a Go map or field names in a Go
+// struct. The special `toml` struct tag may be used to map TOML keys to
+// struct fields that don't match the key name exactly. (See the example.)
+// A case insensitive match to struct names will be tried if an exact match
+// can't be found.
+//
+// The mapping between TOML values and Go values is loose. That is, there
+// may exist TOML values that cannot be placed into your representation, and
+// there may be parts of your representation that do not correspond to
+// TOML values. This loose mapping can be made stricter by using the IsDefined
+// and/or Undecoded methods on the MetaData returned.
+//
+// This decoder will not handle cyclic types. If a cyclic type is passed,
+// `Decode` will not terminate.
+func Decode(data string, v interface{}) (MetaData, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Ptr {
+		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
+	}
+	if rv.IsNil() {
+		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
+	}
+	p, err := parse(data)
+	if err != nil {
+		return MetaData{}, err
+	}
+	md := MetaData{
+		p.mapping, p.types, p.ordered,
+		make(map[string]bool, len(p.ordered)), nil,
+	}
+	return md, md.unify(p.mapping, indirect(rv))
+}
+
+// DecodeFile is just like Decode, except it will automatically read the
+// contents of the file at `fpath` and decode it for you.
+func DecodeFile(fpath string, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadFile(fpath)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// DecodeReader is just like Decode, except it will consume all bytes
+// from the reader and decode it for you.
+func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadAll(r)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// unify performs a sort of type unification based on the structure of `rv`,
+// which is the client representation.
+//
+// Any type mismatch produces an error. Finding a type that we don't know
+// how to handle produces an unsupported type error.
+func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
+
+	// Special case. Look for a `Primitive` value.
+	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
+		// Save the undecoded data and the key context into the primitive
+		// value.
+		context := make(Key, len(md.context))
+		copy(context, md.context)
+		rv.Set(reflect.ValueOf(Primitive{
+			undecoded: data,
+			context:   context,
+		}))
+		return nil
+	}
+
+	// Special case. Unmarshaler Interface support.
+	if rv.CanAddr() {
+		if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
+			return v.UnmarshalTOML(data)
+		}
+	}
+
+	// Special case. Handle time.Time values specifically.
+	// TODO: Remove this code when we decide to drop support for Go 1.1.
+	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
+	// interfaces.
+	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
+		return md.unifyDatetime(data, rv)
+	}
+
+	// Special case. Look for a value satisfying the TextUnmarshaler interface.
+	if v, ok := rv.Interface().(TextUnmarshaler); ok {
+		return md.unifyText(data, v)
+	}
+	// BUG(burntsushi)
+	// The behavior here is incorrect whenever a Go type satisfies the
+	// encoding.TextUnmarshaler interface but also corresponds to a TOML
+	// hash or array. In particular, the unmarshaler should only be applied
+	// to primitive TOML values. But at this point, it will be applied to
+	// all kinds of values and produce an incorrect error whenever those values
+	// are hashes or arrays (including arrays of tables).
+
+	k := rv.Kind()
+
+	// laziness
+	if k >= reflect.Int && k <= reflect.Uint64 {
+		return md.unifyInt(data, rv)
+	}
+	switch k {
+	case reflect.Ptr:
+		elem := reflect.New(rv.Type().Elem())
+		err := md.unify(data, reflect.Indirect(elem))
+		if err != nil {
+			return err
+		}
+		rv.Set(elem)
+		return nil
+	case reflect.Struct:
+		return md.unifyStruct(data, rv)
+	case reflect.Map:
+		return md.unifyMap(data, rv)
+	case reflect.Array:
+		return md.unifyArray(data, rv)
+	case reflect.Slice:
+		return md.unifySlice(data, rv)
+	case reflect.String:
+		return md.unifyString(data, rv)
+	case reflect.Bool:
+		return md.unifyBool(data, rv)
+	case reflect.Interface:
+		// we only support empty interfaces.
+		if rv.NumMethod() > 0 {
+			return e("unsupported type %s", rv.Type())
+		}
+		return md.unifyAnything(data, rv)
+	case reflect.Float32:
+		fallthrough
+	case reflect.Float64:
+		return md.unifyFloat64(data, rv)
+	}
+	return e("unsupported type %s", rv.Kind())
+}
+
+func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if mapping == nil {
+			return nil
+		}
+		return e("type mismatch for %s: expected table but found %T",
+			rv.Type().String(), mapping)
+	}
+
+	for key, datum := range tmap {
+		var f *field
+		fields := cachedTypeFields(rv.Type())
+		for i := range fields {
+			ff := &fields[i]
+			if ff.name == key {
+				f = ff
+				break
+			}
+			if f == nil && strings.EqualFold(ff.name, key) {
+				f = ff
+			}
+		}
+		if f != nil {
+			subv := rv
+			for _, i := range f.index {
+				subv = indirect(subv.Field(i))
+			}
+			if isUnifiable(subv) {
+				md.decoded[md.context.add(key).String()] = true
+				md.context = append(md.context, key)
+				if err := md.unify(datum, subv); err != nil {
+					return err
+				}
+				md.context = md.context[0 : len(md.context)-1]
+			} else if f.name != "" {
+				// Bad user! No soup for you!
+				return e("cannot write unexported field %s.%s",
+					rv.Type().String(), f.name)
+			}
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if tmap == nil {
+			return nil
+		}
+		return badtype("map", mapping)
+	}
+	if rv.IsNil() {
+		rv.Set(reflect.MakeMap(rv.Type()))
+	}
+	for k, v := range tmap {
+		md.decoded[md.context.add(k).String()] = true
+		md.context = append(md.context, k)
+
+		rvkey := indirect(reflect.New(rv.Type().Key()))
+		rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
+		if err := md.unify(v, rvval); err != nil {
+			return err
+		}
+		md.context = md.context[0 : len(md.context)-1]
+
+		rvkey.SetString(k)
+		rv.SetMapIndex(rvkey, rvval)
+	}
+	return nil
+}
+
+func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	sliceLen := datav.Len()
+	if sliceLen != rv.Len() {
+		return e("expected array length %d; got TOML array of length %d",
+			rv.Len(), sliceLen)
+	}
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	n := datav.Len()
+	if rv.IsNil() || rv.Cap() < n {
+		rv.Set(reflect.MakeSlice(rv.Type(), n, n))
+	}
+	rv.SetLen(n)
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
+	sliceLen := data.Len()
+	for i := 0; i < sliceLen; i++ {
+		v := data.Index(i).Interface()
+		sliceval := indirect(rv.Index(i))
+		if err := md.unify(v, sliceval); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
+	if _, ok := data.(time.Time); ok {
+		rv.Set(reflect.ValueOf(data))
+		return nil
+	}
+	return badtype("time.Time", data)
+}
+
+func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
+	if s, ok := data.(string); ok {
+		rv.SetString(s)
+		return nil
+	}
+	return badtype("string", data)
+}
+
+func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(float64); ok {
+		switch rv.Kind() {
+		case reflect.Float32:
+			fallthrough
+		case reflect.Float64:
+			rv.SetFloat(num)
+		default:
+			panic("bug")
+		}
+		return nil
+	}
+	return badtype("float", data)
+}
+
+func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(int64); ok {
+		if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
+			switch rv.Kind() {
+			case reflect.Int, reflect.Int64:
+				// No bounds checking necessary.
+			case reflect.Int8:
+				if num < math.MinInt8 || num > math.MaxInt8 {
+					return e("value %d is out of range for int8", num)
+				}
+			case reflect.Int16:
+				if num < math.MinInt16 || num > math.MaxInt16 {
+					return e("value %d is out of range for int16", num)
+				}
+			case reflect.Int32:
+				if num < math.MinInt32 || num > math.MaxInt32 {
+					return e("value %d is out of range for int32", num)
+				}
+			}
+			rv.SetInt(num)
+		} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
+			unum := uint64(num)
+			switch rv.Kind() {
+			case reflect.Uint, reflect.Uint64:
+				// No bounds checking necessary.
+			case reflect.Uint8:
+				if num < 0 || unum > math.MaxUint8 {
+					return e("value %d is out of range for uint8", num)
+				}
+			case reflect.Uint16:
+				if num < 0 || unum > math.MaxUint16 {
+					return e("value %d is out of range for uint16", num)
+				}
+			case reflect.Uint32:
+				if num < 0 || unum > math.MaxUint32 {
+					return e("value %d is out of range for uint32", num)
+				}
+			}
+			rv.SetUint(unum)
+		} else {
+			panic("unreachable")
+		}
+		return nil
+	}
+	return badtype("integer", data)
+}
+
+func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
+	if b, ok := data.(bool); ok {
+		rv.SetBool(b)
+		return nil
+	}
+	return badtype("boolean", data)
+}
+
+func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
+	rv.Set(reflect.ValueOf(data))
+	return nil
+}
+
+func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
+	var s string
+	switch sdata := data.(type) {
+	case TextMarshaler:
+		text, err := sdata.MarshalText()
+		if err != nil {
+			return err
+		}
+		s = string(text)
+	case fmt.Stringer:
+		s = sdata.String()
+	case string:
+		s = sdata
+	case bool:
+		s = fmt.Sprintf("%v", sdata)
+	case int64:
+		s = fmt.Sprintf("%d", sdata)
+	case float64:
+		s = fmt.Sprintf("%f", sdata)
+	default:
+		return badtype("primitive (string-like)", data)
+	}
+	if err := v.UnmarshalText([]byte(s)); err != nil {
+		return err
+	}
+	return nil
+}
+
+// rvalue returns a reflect.Value of `v`. All pointers are resolved.
+func rvalue(v interface{}) reflect.Value {
+	return indirect(reflect.ValueOf(v))
+}
+
+// indirect returns the value pointed to by a pointer.
+// Pointers are followed until the value is not a pointer.
+// New values are allocated for each nil pointer.
+//
+// An exception to this rule is if the value satisfies an interface of
+// interest to us (like encoding.TextUnmarshaler).
+func indirect(v reflect.Value) reflect.Value {
+	if v.Kind() != reflect.Ptr {
+		if v.CanSet() {
+			pv := v.Addr()
+			if _, ok := pv.Interface().(TextUnmarshaler); ok {
+				return pv
+			}
+		}
+		return v
+	}
+	if v.IsNil() {
+		v.Set(reflect.New(v.Type().Elem()))
+	}
+	return indirect(reflect.Indirect(v))
+}
+
+func isUnifiable(rv reflect.Value) bool {
+	if rv.CanSet() {
+		return true
+	}
+	if _, ok := rv.Interface().(TextUnmarshaler); ok {
+		return true
+	}
+	return false
+}
+
+func badtype(expected string, data interface{}) error {
+	return e("cannot load TOML value of type %T into a Go %s", data, expected)
+}

vendor/github.com/BurntSushi/toml/decode_meta.go

@@ -0,0 +1,121 @@
+package toml
+
+import "strings"
+
+// MetaData allows access to meta information about TOML data that may not
+// be inferrable via reflection. In particular, whether a key has been defined
+// and the TOML type of a key.
+type MetaData struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	keys    []Key
+	decoded map[string]bool
+	context Key // Used only during decoding.
+}
+
+// IsDefined returns true if the key given exists in the TOML data. The key
+// should be specified hierarchially. e.g.,
+//
+//	// access the TOML key 'a.b.c'
+//	IsDefined("a", "b", "c")
+//
+// IsDefined will return false if an empty key given. Keys are case sensitive.
+func (md *MetaData) IsDefined(key ...string) bool {
+	if len(key) == 0 {
+		return false
+	}
+
+	var hash map[string]interface{}
+	var ok bool
+	var hashOrVal interface{} = md.mapping
+	for _, k := range key {
+		if hash, ok = hashOrVal.(map[string]interface{}); !ok {
+			return false
+		}
+		if hashOrVal, ok = hash[k]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Type returns a string representation of the type of the key specified.
+//
+// Type will return the empty string if given an empty key or a key that
+// does not exist. Keys are case sensitive.
+func (md *MetaData) Type(key ...string) string {
+	fullkey := strings.Join(key, ".")
+	if typ, ok := md.types[fullkey]; ok {
+		return typ.typeString()
+	}
+	return ""
+}
+
+// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
+// to get values of this type.
+type Key []string
+
+func (k Key) String() string {
+	return strings.Join(k, ".")
+}
+
+func (k Key) maybeQuotedAll() string {
+	var ss []string
+	for i := range k {
+		ss = append(ss, k.maybeQuoted(i))
+	}
+	return strings.Join(ss, ".")
+}
+
+func (k Key) maybeQuoted(i int) string {
+	quote := false
+	for _, c := range k[i] {
+		if !isBareKeyChar(c) {
+			quote = true
+			break
+		}
+	}
+	if quote {
+		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
+	}
+	return k[i]
+}
+
+func (k Key) add(piece string) Key {
+	newKey := make(Key, len(k)+1)
+	copy(newKey, k)
+	newKey[len(k)] = piece
+	return newKey
+}
+
+// Keys returns a slice of every key in the TOML data, including key groups.
+// Each key is itself a slice, where the first element is the top of the
+// hierarchy and the last is the most specific.
+//
+// The list will have the same order as the keys appeared in the TOML data.
+//
+// All keys returned are non-empty.
+func (md *MetaData) Keys() []Key {
+	return md.keys
+}
+
+// Undecoded returns all keys that have not been decoded in the order in which
+// they appear in the original TOML document.
+//
+// This includes keys that haven't been decoded because of a Primitive value.
+// Once the Primitive value is decoded, the keys will be considered decoded.
+//
+// Also note that decoding into an empty interface will result in no decoding,
+// and so no keys will be considered decoded.
+//
+// In this sense, the Undecoded keys correspond to keys in the TOML document
+// that do not have a concrete type in your representation.
+func (md *MetaData) Undecoded() []Key {
+	undecoded := make([]Key, 0, len(md.keys))
+	for _, key := range md.keys {
+		if !md.decoded[key.String()] {
+			undecoded = append(undecoded, key)
+		}
+	}
+	return undecoded
+}

vendor/github.com/BurntSushi/toml/doc.go

@@ -0,0 +1,27 @@
+/*
+Package toml provides facilities for decoding and encoding TOML configuration
+files via reflection. There is also support for delaying decoding with
+the Primitive type, and querying the set of keys in a TOML document with the
+MetaData type.
+
+The specification implemented: https://github.com/toml-lang/toml
+
+The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
+whether a file is a valid TOML document. It can also be used to print the
+type of each key in a TOML document.
+
+Testing
+
+There are two important types of tests used for this package. The first is
+contained inside '*_test.go' files and uses the standard Go unit testing
+framework. These tests are primarily devoted to holistically testing the
+decoder and encoder.
+
+The second type of testing is used to verify the implementation's adherence
+to the TOML specification. These tests have been factored into their own
+project: https://github.com/BurntSushi/toml-test
+
+The reason the tests are in a separate project is so that they can be used by
+any implementation of TOML. Namely, it is language agnostic.
+*/
+package toml

vendor/github.com/BurntSushi/toml/encode.go

@@ -0,0 +1,568 @@
+package toml
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type tomlEncodeError struct{ error }
+
+var (
+	errArrayMixedElementTypes = errors.New(
+		"toml: cannot encode array with mixed element types")
+	errArrayNilElement = errors.New(
+		"toml: cannot encode array with nil element")
+	errNonString = errors.New(
+		"toml: cannot encode a map with non-string key type")
+	errAnonNonStruct = errors.New(
+		"toml: cannot encode an anonymous field that is not a struct")
+	errArrayNoTable = errors.New(
+		"toml: TOML array element cannot contain a table")
+	errNoKey = errors.New(
+		"toml: top-level values must be Go maps or structs")
+	errAnything = errors.New("") // used in testing
+)
+
+var quotedReplacer = strings.NewReplacer(
+	"\t", "\\t",
+	"\n", "\\n",
+	"\r", "\\r",
+	"\"", "\\\"",
+	"\\", "\\\\",
+)
+
+// Encoder controls the encoding of Go values to a TOML document to some
+// io.Writer.
+//
+// The indentation level can be controlled with the Indent field.
+type Encoder struct {
+	// A single indentation level. By default it is two spaces.
+	Indent string
+
+	// hasWritten is whether we have written any output to w yet.
+	hasWritten bool
+	w          *bufio.Writer
+}
+
+// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
+// given. By default, a single indentation level is 2 spaces.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w:      bufio.NewWriter(w),
+		Indent: "  ",
+	}
+}
+
+// Encode writes a TOML representation of the Go value to the underlying
+// io.Writer. If the value given cannot be encoded to a valid TOML document,
+// then an error is returned.
+//
+// The mapping between Go values and TOML values should be precisely the same
+// as for the Decode* functions. Similarly, the TextMarshaler interface is
+// supported by encoding the resulting bytes as strings. (If you want to write
+// arbitrary binary data then you will need to use something like base64 since
+// TOML does not have any binary types.)
+//
+// When encoding TOML hashes (i.e., Go maps or structs), keys without any
+// sub-hashes are encoded first.
+//
+// If a Go map is encoded, then its keys are sorted alphabetically for
+// deterministic output. More control over this behavior may be provided if
+// there is demand for it.
+//
+// Encoding Go values without a corresponding TOML representation---like map
+// types with non-string keys---will cause an error to be returned. Similarly
+// for mixed arrays/slices, arrays/slices with nil elements, embedded
+// non-struct types and nested slices containing maps or structs.
+// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
+// and so is []map[string][]string.)
+func (enc *Encoder) Encode(v interface{}) error {
+	rv := eindirect(reflect.ValueOf(v))
+	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
+		return err
+	}
+	return enc.w.Flush()
+}
+
+func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if terr, ok := r.(tomlEncodeError); ok {
+				err = terr.error
+				return
+			}
+			panic(r)
+		}
+	}()
+	enc.encode(key, rv)
+	return nil
+}
+
+func (enc *Encoder) encode(key Key, rv reflect.Value) {
+	// Special case. Time needs to be in ISO8601 format.
+	// Special case. If we can marshal the type to text, then we used that.
+	// Basically, this prevents the encoder for handling these types as
+	// generic structs (or whatever the underlying type of a TextMarshaler is).
+	switch rv.Interface().(type) {
+	case time.Time, TextMarshaler:
+		enc.keyEqElement(key, rv)
+		return
+	}
+
+	k := rv.Kind()
+	switch k {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64,
+		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
+		enc.keyEqElement(key, rv)
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
+			enc.eArrayOfTables(key, rv)
+		} else {
+			enc.keyEqElement(key, rv)
+		}
+	case reflect.Interface:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Map:
+		if rv.IsNil() {
+			return
+		}
+		enc.eTable(key, rv)
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Struct:
+		enc.eTable(key, rv)
+	default:
+		panic(e("unsupported type for key '%s': %s", key, k))
+	}
+}
+
+// eElement encodes any value that can be an array element (primitives and
+// arrays).
+func (enc *Encoder) eElement(rv reflect.Value) {
+	switch v := rv.Interface().(type) {
+	case time.Time:
+		// Special case time.Time as a primitive. Has to come before
+		// TextMarshaler below because time.Time implements
+		// encoding.TextMarshaler, but we need to always use UTC.
+		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
+		return
+	case TextMarshaler:
+		// Special case. Use text marshaler if it's available for this value.
+		if s, err := v.MarshalText(); err != nil {
+			encPanic(err)
+		} else {
+			enc.writeQuoted(string(s))
+		}
+		return
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		enc.wf(strconv.FormatBool(rv.Bool()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64:
+		enc.wf(strconv.FormatInt(rv.Int(), 10))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16,
+		reflect.Uint32, reflect.Uint64:
+		enc.wf(strconv.FormatUint(rv.Uint(), 10))
+	case reflect.Float32:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
+	case reflect.Float64:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
+	case reflect.Array, reflect.Slice:
+		enc.eArrayOrSliceElement(rv)
+	case reflect.Interface:
+		enc.eElement(rv.Elem())
+	case reflect.String:
+		enc.writeQuoted(rv.String())
+	default:
+		panic(e("unexpected primitive type: %s", rv.Kind()))
+	}
+}
+
+// By the TOML spec, all floats must have a decimal with at least one
+// number on either side.
+func floatAddDecimal(fstr string) string {
+	if !strings.Contains(fstr, ".") {
+		return fstr + ".0"
+	}
+	return fstr
+}
+
+func (enc *Encoder) writeQuoted(s string) {
+	enc.wf("\"%s\"", quotedReplacer.Replace(s))
+}
+
+func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
+	length := rv.Len()
+	enc.wf("[")
+	for i := 0; i < length; i++ {
+		elem := rv.Index(i)
+		enc.eElement(elem)
+		if i != length-1 {
+			enc.wf(", ")
+		}
+	}
+	enc.wf("]")
+}
+
+func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	for i := 0; i < rv.Len(); i++ {
+		trv := rv.Index(i)
+		if isNil(trv) {
+			continue
+		}
+		panicIfInvalidKey(key)
+		enc.newline()
+		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+		enc.eMapOrStruct(key, trv)
+	}
+}
+
+func (enc *Encoder) eTable(key Key, rv reflect.Value) {
+	panicIfInvalidKey(key)
+	if len(key) == 1 {
+		// Output an extra newline between top-level tables.
+		// (The newline isn't written if nothing else has been written though.)
+		enc.newline()
+	}
+	if len(key) > 0 {
+		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+	}
+	enc.eMapOrStruct(key, rv)
+}
+
+func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
+	switch rv := eindirect(rv); rv.Kind() {
+	case reflect.Map:
+		enc.eMap(key, rv)
+	case reflect.Struct:
+		enc.eStruct(key, rv)
+	default:
+		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
+	}
+}
+
+func (enc *Encoder) eMap(key Key, rv reflect.Value) {
+	rt := rv.Type()
+	if rt.Key().Kind() != reflect.String {
+		encPanic(errNonString)
+	}
+
+	// Sort keys so that we have deterministic output. And write keys directly
+	// underneath this key first, before writing sub-structs or sub-maps.
+	var mapKeysDirect, mapKeysSub []string
+	for _, mapKey := range rv.MapKeys() {
+		k := mapKey.String()
+		if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
+			mapKeysSub = append(mapKeysSub, k)
+		} else {
+			mapKeysDirect = append(mapKeysDirect, k)
+		}
+	}
+
+	var writeMapKeys = func(mapKeys []string) {
+		sort.Strings(mapKeys)
+		for _, mapKey := range mapKeys {
+			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
+			if isNil(mrv) {
+				// Don't write anything for nil fields.
+				continue
+			}
+			enc.encode(key.add(mapKey), mrv)
+		}
+	}
+	writeMapKeys(mapKeysDirect)
+	writeMapKeys(mapKeysSub)
+}
+
+func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
+	// Write keys for fields directly under this key first, because if we write
+	// a field that creates a new table, then all keys under it will be in that
+	// table (not the one we're writing here).
+	rt := rv.Type()
+	var fieldsDirect, fieldsSub [][]int
+	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
+	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
+		for i := 0; i < rt.NumField(); i++ {
+			f := rt.Field(i)
+			// skip unexported fields
+			if f.PkgPath != "" && !f.Anonymous {
+				continue
+			}
+			frv := rv.Field(i)
+			if f.Anonymous {
+				t := f.Type
+				switch t.Kind() {
+				case reflect.Struct:
+					// Treat anonymous struct fields with
+					// tag names as though they are not
+					// anonymous, like encoding/json does.
+					if getOptions(f.Tag).name == "" {
+						addFields(t, frv, f.Index)
+						continue
+					}
+				case reflect.Ptr:
+					if t.Elem().Kind() == reflect.Struct &&
+						getOptions(f.Tag).name == "" {
+						if !frv.IsNil() {
+							addFields(t.Elem(), frv.Elem(), f.Index)
+						}
+						continue
+					}
+					// Fall through to the normal field encoding logic below
+					// for non-struct anonymous fields.
+				}
+			}
+
+			if typeIsHash(tomlTypeOfGo(frv)) {
+				fieldsSub = append(fieldsSub, append(start, f.Index...))
+			} else {
+				fieldsDirect = append(fieldsDirect, append(start, f.Index...))
+			}
+		}
+	}
+	addFields(rt, rv, nil)
+
+	var writeFields = func(fields [][]int) {
+		for _, fieldIndex := range fields {
+			sft := rt.FieldByIndex(fieldIndex)
+			sf := rv.FieldByIndex(fieldIndex)
+			if isNil(sf) {
+				// Don't write anything for nil fields.
+				continue
+			}
+
+			opts := getOptions(sft.Tag)
+			if opts.skip {
+				continue
+			}
+			keyName := sft.Name
+			if opts.name != "" {
+				keyName = opts.name
+			}
+			if opts.omitempty && isEmpty(sf) {
+				continue
+			}
+			if opts.omitzero && isZero(sf) {
+				continue
+			}
+
+			enc.encode(key.add(keyName), sf)
+		}
+	}
+	writeFields(fieldsDirect)
+	writeFields(fieldsSub)
+}
+
+// tomlTypeName returns the TOML type name of the Go value's type. It is
+// used to determine whether the types of array elements are mixed (which is
+// forbidden). If the Go value is nil, then it is illegal for it to be an array
+// element, and valueIsNil is returned as true.
+
+// Returns the TOML type of a Go value. The type may be `nil`, which means
+// no concrete TOML type could be found.
+func tomlTypeOfGo(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() {
+		return nil
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		return tomlBool
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64:
+		return tomlInteger
+	case reflect.Float32, reflect.Float64:
+		return tomlFloat
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlHash, tomlArrayType(rv)) {
+			return tomlArrayHash
+		}
+		return tomlArray
+	case reflect.Ptr, reflect.Interface:
+		return tomlTypeOfGo(rv.Elem())
+	case reflect.String:
+		return tomlString
+	case reflect.Map:
+		return tomlHash
+	case reflect.Struct:
+		switch rv.Interface().(type) {
+		case time.Time:
+			return tomlDatetime
+		case TextMarshaler:
+			return tomlString
+		default:
+			return tomlHash
+		}
+	default:
+		panic("unexpected reflect.Kind: " + rv.Kind().String())
+	}
+}
+
+// tomlArrayType returns the element type of a TOML array. The type returned
+// may be nil if it cannot be determined (e.g., a nil slice or a zero length
+// slize). This function may also panic if it finds a type that cannot be
+// expressed in TOML (such as nil elements, heterogeneous arrays or directly
+// nested arrays of tables).
+func tomlArrayType(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
+		return nil
+	}
+	firstType := tomlTypeOfGo(rv.Index(0))
+	if firstType == nil {
+		encPanic(errArrayNilElement)
+	}
+
+	rvlen := rv.Len()
+	for i := 1; i < rvlen; i++ {
+		elem := rv.Index(i)
+		switch elemType := tomlTypeOfGo(elem); {
+		case elemType == nil:
+			encPanic(errArrayNilElement)
+		case !typeEqual(firstType, elemType):
+			encPanic(errArrayMixedElementTypes)
+		}
+	}
+	// If we have a nested array, then we must make sure that the nested
+	// array contains ONLY primitives.
+	// This checks arbitrarily nested arrays.
+	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
+		nest := tomlArrayType(eindirect(rv.Index(0)))
+		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
+			encPanic(errArrayNoTable)
+		}
+	}
+	return firstType
+}
+
+type tagOptions struct {
+	skip      bool // "-"
+	name      string
+	omitempty bool
+	omitzero  bool
+}
+
+func getOptions(tag reflect.StructTag) tagOptions {
+	t := tag.Get("toml")
+	if t == "-" {
+		return tagOptions{skip: true}
+	}
+	var opts tagOptions
+	parts := strings.Split(t, ",")
+	opts.name = parts[0]
+	for _, s := range parts[1:] {
+		switch s {
+		case "omitempty":
+			opts.omitempty = true
+		case "omitzero":
+			opts.omitzero = true
+		}
+	}
+	return opts
+}
+
+func isZero(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return rv.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return rv.Float() == 0.0
+	}
+	return false
+}
+
+func isEmpty(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+		return rv.Len() == 0
+	case reflect.Bool:
+		return !rv.Bool()
+	}
+	return false
+}
+
+func (enc *Encoder) newline() {
+	if enc.hasWritten {
+		enc.wf("\n")
+	}
+}
+
+func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	panicIfInvalidKey(key)
+	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
+	enc.eElement(val)
+	enc.newline()
+}
+
+func (enc *Encoder) wf(format string, v ...interface{}) {
+	if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
+		encPanic(err)
+	}
+	enc.hasWritten = true
+}
+
+func (enc *Encoder) indentStr(key Key) string {
+	return strings.Repeat(enc.Indent, len(key)-1)
+}
+
+func encPanic(err error) {
+	panic(tomlEncodeError{err})
+}
+
+func eindirect(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Interface:
+		return eindirect(v.Elem())
+	default:
+		return v
+	}
+}
+
+func isNil(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func panicIfInvalidKey(key Key) {
+	for _, k := range key {
+		if len(k) == 0 {
+			encPanic(e("Key '%s' is not a valid table name. Key names "+
+				"cannot be empty.", key.maybeQuotedAll()))
+		}
+	}
+}
+
+func isValidKeyName(s string) bool {
+	return len(s) != 0
+}

vendor/github.com/BurntSushi/toml/encoding_types.go

@@ -0,0 +1,19 @@
+// +build go1.2
+
+package toml
+
+// In order to support Go 1.1, we define our own TextMarshaler and
+// TextUnmarshaler types. For Go 1.2+, we just alias them with the
+// standard library interfaces.
+
+import (
+	"encoding"
+)
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler encoding.TextMarshaler
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler encoding.TextUnmarshaler

vendor/github.com/BurntSushi/toml/encoding_types_1.1.go

@@ -0,0 +1,18 @@
+// +build !go1.2
+
+package toml
+
+// These interfaces were introduced in Go 1.2, so we add them manually when
+// compiling for Go 1.1.
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler interface {
+	MarshalText() (text []byte, err error)
+}
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler interface {
+	UnmarshalText(text []byte) error
+}

vendor/github.com/BurntSushi/toml/lex.go

@@ -0,0 +1,953 @@
+package toml
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+type itemType int
+
+const (
+	itemError itemType = iota
+	itemNIL            // used in the parser to indicate no type
+	itemEOF
+	itemText
+	itemString
+	itemRawString
+	itemMultilineString
+	itemRawMultilineString
+	itemBool
+	itemInteger
+	itemFloat
+	itemDatetime
+	itemArray // the start of an array
+	itemArrayEnd
+	itemTableStart
+	itemTableEnd
+	itemArrayTableStart
+	itemArrayTableEnd
+	itemKeyStart
+	itemCommentStart
+	itemInlineTableStart
+	itemInlineTableEnd
+)
+
+const (
+	eof              = 0
+	comma            = ','
+	tableStart       = '['
+	tableEnd         = ']'
+	arrayTableStart  = '['
+	arrayTableEnd    = ']'
+	tableSep         = '.'
+	keySep           = '='
+	arrayStart       = '['
+	arrayEnd         = ']'
+	commentStart     = '#'
+	stringStart      = '"'
+	stringEnd        = '"'
+	rawStringStart   = '\''
+	rawStringEnd     = '\''
+	inlineTableStart = '{'
+	inlineTableEnd   = '}'
+)
+
+type stateFn func(lx *lexer) stateFn
+
+type lexer struct {
+	input string
+	start int
+	pos   int
+	line  int
+	state stateFn
+	items chan item
+
+	// Allow for backing up up to three runes.
+	// This is necessary because TOML contains 3-rune tokens (""" and ''').
+	prevWidths [3]int
+	nprev      int // how many of prevWidths are in use
+	// If we emit an eof, we can still back up, but it is not OK to call
+	// next again.
+	atEOF bool
+
+	// A stack of state functions used to maintain context.
+	// The idea is to reuse parts of the state machine in various places.
+	// For example, values can appear at the top level or within arbitrarily
+	// nested arrays. The last state on the stack is used after a value has
+	// been lexed. Similarly for comments.
+	stack []stateFn
+}
+
+type item struct {
+	typ  itemType
+	val  string
+	line int
+}
+
+func (lx *lexer) nextItem() item {
+	for {
+		select {
+		case item := <-lx.items:
+			return item
+		default:
+			lx.state = lx.state(lx)
+		}
+	}
+}
+
+func lex(input string) *lexer {
+	lx := &lexer{
+		input: input,
+		state: lexTop,
+		line:  1,
+		items: make(chan item, 10),
+		stack: make([]stateFn, 0, 10),
+	}
+	return lx
+}
+
+func (lx *lexer) push(state stateFn) {
+	lx.stack = append(lx.stack, state)
+}
+
+func (lx *lexer) pop() stateFn {
+	if len(lx.stack) == 0 {
+		return lx.errorf("BUG in lexer: no states to pop")
+	}
+	last := lx.stack[len(lx.stack)-1]
+	lx.stack = lx.stack[0 : len(lx.stack)-1]
+	return last
+}
+
+func (lx *lexer) current() string {
+	return lx.input[lx.start:lx.pos]
+}
+
+func (lx *lexer) emit(typ itemType) {
+	lx.items <- item{typ, lx.current(), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) emitTrim(typ itemType) {
+	lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) next() (r rune) {
+	if lx.atEOF {
+		panic("next called after EOF")
+	}
+	if lx.pos >= len(lx.input) {
+		lx.atEOF = true
+		return eof
+	}
+
+	if lx.input[lx.pos] == '\n' {
+		lx.line++
+	}
+	lx.prevWidths[2] = lx.prevWidths[1]
+	lx.prevWidths[1] = lx.prevWidths[0]
+	if lx.nprev < 3 {
+		lx.nprev++
+	}
+	r, w := utf8.DecodeRuneInString(lx.input[lx.pos:])
+	lx.prevWidths[0] = w
+	lx.pos += w
+	return r
+}
+
+// ignore skips over the pending input before this point.
+func (lx *lexer) ignore() {
+	lx.start = lx.pos
+}
+
+// backup steps back one rune. Can be called only twice between calls to next.
+func (lx *lexer) backup() {
+	if lx.atEOF {
+		lx.atEOF = false
+		return
+	}
+	if lx.nprev < 1 {
+		panic("backed up too far")
+	}
+	w := lx.prevWidths[0]
+	lx.prevWidths[0] = lx.prevWidths[1]
+	lx.prevWidths[1] = lx.prevWidths[2]
+	lx.nprev--
+	lx.pos -= w
+	if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {
+		lx.line--
+	}
+}
+
+// accept consumes the next rune if it's equal to `valid`.
+func (lx *lexer) accept(valid rune) bool {
+	if lx.next() == valid {
+		return true
+	}
+	lx.backup()
+	return false
+}
+
+// peek returns but does not consume the next rune in the input.
+func (lx *lexer) peek() rune {
+	r := lx.next()
+	lx.backup()
+	return r
+}
+
+// skip ignores all input that matches the given predicate.
+func (lx *lexer) skip(pred func(rune) bool) {
+	for {
+		r := lx.next()
+		if pred(r) {
+			continue
+		}
+		lx.backup()
+		lx.ignore()
+		return
+	}
+}
+
+// errorf stops all lexing by emitting an error and returning `nil`.
+// Note that any value that is a character is escaped if it's a special
+// character (newlines, tabs, etc.).
+func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
+	lx.items <- item{
+		itemError,
+		fmt.Sprintf(format, values...),
+		lx.line,
+	}
+	return nil
+}
+
+// lexTop consumes elements at the top level of TOML data.
+func lexTop(lx *lexer) stateFn {
+	r := lx.next()
+	if isWhitespace(r) || isNL(r) {
+		return lexSkip(lx, lexTop)
+	}
+	switch r {
+	case commentStart:
+		lx.push(lexTop)
+		return lexCommentStart
+	case tableStart:
+		return lexTableStart
+	case eof:
+		if lx.pos > lx.start {
+			return lx.errorf("unexpected EOF")
+		}
+		lx.emit(itemEOF)
+		return nil
+	}
+
+	// At this point, the only valid item can be a key, so we back up
+	// and let the key lexer do the rest.
+	lx.backup()
+	lx.push(lexTopEnd)
+	return lexKeyStart
+}
+
+// lexTopEnd is entered whenever a top-level item has been consumed. (A value
+// or a table.) It must see only whitespace, and will turn back to lexTop
+// upon a newline. If it sees EOF, it will quit the lexer successfully.
+func lexTopEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == commentStart:
+		// a comment will read to a newline for us.
+		lx.push(lexTop)
+		return lexCommentStart
+	case isWhitespace(r):
+		return lexTopEnd
+	case isNL(r):
+		lx.ignore()
+		return lexTop
+	case r == eof:
+		lx.emit(itemEOF)
+		return nil
+	}
+	return lx.errorf("expected a top-level item to end with a newline, "+
+		"comment, or EOF, but got %q instead", r)
+}
+
+// lexTable lexes the beginning of a table. Namely, it makes sure that
+// it starts with a character other than '.' and ']'.
+// It assumes that '[' has already been consumed.
+// It also handles the case that this is an item in an array of tables.
+// e.g., '[[name]]'.
+func lexTableStart(lx *lexer) stateFn {
+	if lx.peek() == arrayTableStart {
+		lx.next()
+		lx.emit(itemArrayTableStart)
+		lx.push(lexArrayTableEnd)
+	} else {
+		lx.emit(itemTableStart)
+		lx.push(lexTableEnd)
+	}
+	return lexTableNameStart
+}
+
+func lexTableEnd(lx *lexer) stateFn {
+	lx.emit(itemTableEnd)
+	return lexTopEnd
+}
+
+func lexArrayTableEnd(lx *lexer) stateFn {
+	if r := lx.next(); r != arrayTableEnd {
+		return lx.errorf("expected end of table array name delimiter %q, "+
+			"but got %q instead", arrayTableEnd, r)
+	}
+	lx.emit(itemArrayTableEnd)
+	return lexTopEnd
+}
+
+func lexTableNameStart(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.peek(); {
+	case r == tableEnd || r == eof:
+		return lx.errorf("unexpected end of table name " +
+			"(table names cannot be empty)")
+	case r == tableSep:
+		return lx.errorf("unexpected table separator " +
+			"(table names cannot be empty)")
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.push(lexTableNameEnd)
+		return lexValue // reuse string lexing
+	default:
+		return lexBareTableName
+	}
+}
+
+// lexBareTableName lexes the name of a table. It assumes that at least one
+// valid character for the table has already been read.
+func lexBareTableName(lx *lexer) stateFn {
+	r := lx.next()
+	if isBareKeyChar(r) {
+		return lexBareTableName
+	}
+	lx.backup()
+	lx.emit(itemText)
+	return lexTableNameEnd
+}
+
+// lexTableNameEnd reads the end of a piece of a table name, optionally
+// consuming whitespace.
+func lexTableNameEnd(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.next(); {
+	case isWhitespace(r):
+		return lexTableNameEnd
+	case r == tableSep:
+		lx.ignore()
+		return lexTableNameStart
+	case r == tableEnd:
+		return lx.pop()
+	default:
+		return lx.errorf("expected '.' or ']' to end table name, "+
+			"but got %q instead", r)
+	}
+}
+
+// lexKeyStart consumes a key name up until the first non-whitespace character.
+// lexKeyStart will ignore whitespace.
+func lexKeyStart(lx *lexer) stateFn {
+	r := lx.peek()
+	switch {
+	case r == keySep:
+		return lx.errorf("unexpected key separator %q", keySep)
+	case isWhitespace(r) || isNL(r):
+		lx.next()
+		return lexSkip(lx, lexKeyStart)
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		lx.push(lexKeyEnd)
+		return lexValue // reuse string lexing
+	default:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		return lexBareKey
+	}
+}
+
+// lexBareKey consumes the text of a bare key. Assumes that the first character
+// (which is not whitespace) has not yet been consumed.
+func lexBareKey(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case isBareKeyChar(r):
+		return lexBareKey
+	case isWhitespace(r):
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	case r == keySep:
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	default:
+		return lx.errorf("bare keys cannot contain %q", r)
+	}
+}
+
+// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
+// separator).
+func lexKeyEnd(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case r == keySep:
+		return lexSkip(lx, lexValue)
+	case isWhitespace(r):
+		return lexSkip(lx, lexKeyEnd)
+	default:
+		return lx.errorf("expected key separator %q, but got %q instead",
+			keySep, r)
+	}
+}
+
+// lexValue starts the consumption of a value anywhere a value is expected.
+// lexValue will ignore whitespace.
+// After a value is lexed, the last state on the next is popped and returned.
+func lexValue(lx *lexer) stateFn {
+	// We allow whitespace to precede a value, but NOT newlines.
+	// In array syntax, the array states are responsible for ignoring newlines.
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexValue)
+	case isDigit(r):
+		lx.backup() // avoid an extra state and use the same as above
+		return lexNumberOrDateStart
+	}
+	switch r {
+	case arrayStart:
+		lx.ignore()
+		lx.emit(itemArray)
+		return lexArrayValue
+	case inlineTableStart:
+		lx.ignore()
+		lx.emit(itemInlineTableStart)
+		return lexInlineTableValue
+	case stringStart:
+		if lx.accept(stringStart) {
+			if lx.accept(stringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the '"'
+		return lexString
+	case rawStringStart:
+		if lx.accept(rawStringStart) {
+			if lx.accept(rawStringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineRawString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the "'"
+		return lexRawString
+	case '+', '-':
+		return lexNumberStart
+	case '.': // special error case, be kind to users
+		return lx.errorf("floats must start with a digit, not '.'")
+	}
+	if unicode.IsLetter(r) {
+		// Be permissive here; lexBool will give a nice error if the
+		// user wrote something like
+		//   x = foo
+		// (i.e. not 'true' or 'false' but is something else word-like.)
+		lx.backup()
+		return lexBool
+	}
+	return lx.errorf("expected value but found %q instead", r)
+}
+
+// lexArrayValue consumes one value in an array. It assumes that '[' or ','
+// have already been consumed. All whitespace and newlines are ignored.
+func lexArrayValue(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValue)
+	case r == commentStart:
+		lx.push(lexArrayValue)
+		return lexCommentStart
+	case r == comma:
+		return lx.errorf("unexpected comma")
+	case r == arrayEnd:
+		// NOTE(caleb): The spec isn't clear about whether you can have
+		// a trailing comma or not, so we'll allow it.
+		return lexArrayEnd
+	}
+
+	lx.backup()
+	lx.push(lexArrayValueEnd)
+	return lexValue
+}
+
+// lexArrayValueEnd consumes everything between the end of an array value and
+// the next value (or the end of the array): it ignores whitespace and newlines
+// and expects either a ',' or a ']'.
+func lexArrayValueEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValueEnd)
+	case r == commentStart:
+		lx.push(lexArrayValueEnd)
+		return lexCommentStart
+	case r == comma:
+		lx.ignore()
+		return lexArrayValue // move on to the next value
+	case r == arrayEnd:
+		return lexArrayEnd
+	}
+	return lx.errorf(
+		"expected a comma or array terminator %q, but got %q instead",
+		arrayEnd, r,
+	)
+}
+
+// lexArrayEnd finishes the lexing of an array.
+// It assumes that a ']' has just been consumed.
+func lexArrayEnd(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemArrayEnd)
+	return lx.pop()
+}
+
+// lexInlineTableValue consumes one key/value pair in an inline table.
+// It assumes that '{' or ',' have already been consumed. Whitespace is ignored.
+func lexInlineTableValue(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexInlineTableValue)
+	case isNL(r):
+		return lx.errorf("newlines not allowed within inline tables")
+	case r == commentStart:
+		lx.push(lexInlineTableValue)
+		return lexCommentStart
+	case r == comma:
+		return lx.errorf("unexpected comma")
+	case r == inlineTableEnd:
+		return lexInlineTableEnd
+	}
+	lx.backup()
+	lx.push(lexInlineTableValueEnd)
+	return lexKeyStart
+}
+
+// lexInlineTableValueEnd consumes everything between the end of an inline table
+// key/value pair and the next pair (or the end of the table):
+// it ignores whitespace and expects either a ',' or a '}'.
+func lexInlineTableValueEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexInlineTableValueEnd)
+	case isNL(r):
+		return lx.errorf("newlines not allowed within inline tables")
+	case r == commentStart:
+		lx.push(lexInlineTableValueEnd)
+		return lexCommentStart
+	case r == comma:
+		lx.ignore()
+		return lexInlineTableValue
+	case r == inlineTableEnd:
+		return lexInlineTableEnd
+	}
+	return lx.errorf("expected a comma or an inline table terminator %q, "+
+		"but got %q instead", inlineTableEnd, r)
+}
+
+// lexInlineTableEnd finishes the lexing of an inline table.
+// It assumes that a '}' has just been consumed.
+func lexInlineTableEnd(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemInlineTableEnd)
+	return lx.pop()
+}
+
+// lexString consumes the inner contents of a string. It assumes that the
+// beginning '"' has already been consumed and ignored.
+func lexString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == eof:
+		return lx.errorf("unexpected EOF")
+	case isNL(r):
+		return lx.errorf("strings cannot contain newlines")
+	case r == '\\':
+		lx.push(lexString)
+		return lexStringEscape
+	case r == stringEnd:
+		lx.backup()
+		lx.emit(itemString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexString
+}
+
+// lexMultilineString consumes the inner contents of a string. It assumes that
+// the beginning '"""' has already been consumed and ignored.
+func lexMultilineString(lx *lexer) stateFn {
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case '\\':
+		return lexMultilineStringEscape
+	case stringEnd:
+		if lx.accept(stringEnd) {
+			if lx.accept(stringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineString
+}
+
+// lexRawString consumes a raw string. Nothing can be escaped in such a string.
+// It assumes that the beginning "'" has already been consumed and ignored.
+func lexRawString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == eof:
+		return lx.errorf("unexpected EOF")
+	case isNL(r):
+		return lx.errorf("strings cannot contain newlines")
+	case r == rawStringEnd:
+		lx.backup()
+		lx.emit(itemRawString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexRawString
+}
+
+// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
+// a string. It assumes that the beginning "'''" has already been consumed and
+// ignored.
+func lexMultilineRawString(lx *lexer) stateFn {
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case rawStringEnd:
+		if lx.accept(rawStringEnd) {
+			if lx.accept(rawStringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemRawMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineRawString
+}
+
+// lexMultilineStringEscape consumes an escaped character. It assumes that the
+// preceding '\\' has already been consumed.
+func lexMultilineStringEscape(lx *lexer) stateFn {
+	// Handle the special case first:
+	if isNL(lx.next()) {
+		return lexMultilineString
+	}
+	lx.backup()
+	lx.push(lexMultilineString)
+	return lexStringEscape(lx)
+}
+
+func lexStringEscape(lx *lexer) stateFn {
+	r := lx.next()
+	switch r {
+	case 'b':
+		fallthrough
+	case 't':
+		fallthrough
+	case 'n':
+		fallthrough
+	case 'f':
+		fallthrough
+	case 'r':
+		fallthrough
+	case '"':
+		fallthrough
+	case '\\':
+		return lx.pop()
+	case 'u':
+		return lexShortUnicodeEscape
+	case 'U':
+		return lexLongUnicodeEscape
+	}
+	return lx.errorf("invalid escape character %q; only the following "+
+		"escape characters are allowed: "+
+		`\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r)
+}
+
+func lexShortUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 4; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf(`expected four hexadecimal digits after '\u', `+
+				"but got %q instead", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+func lexLongUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 8; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf(`expected eight hexadecimal digits after '\U', `+
+				"but got %q instead", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+// lexNumberOrDateStart consumes either an integer, a float, or datetime.
+func lexNumberOrDateStart(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case 'e', 'E':
+		return lexFloat
+	case '.':
+		return lx.errorf("floats must start with a digit, not '.'")
+	}
+	return lx.errorf("expected a digit but got %q", r)
+}
+
+// lexNumberOrDate consumes either an integer, float or datetime.
+func lexNumberOrDate(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '-':
+		return lexDatetime
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexDatetime consumes a Datetime, to a first approximation.
+// The parser validates that it matches one of the accepted formats.
+func lexDatetime(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexDatetime
+	}
+	switch r {
+	case '-', 'T', ':', '.', 'Z':
+		return lexDatetime
+	}
+
+	lx.backup()
+	lx.emit(itemDatetime)
+	return lx.pop()
+}
+
+// lexNumberStart consumes either an integer or a float. It assumes that a sign
+// has already been read, but that *no* digits have been consumed.
+// lexNumberStart will move to the appropriate integer or float states.
+func lexNumberStart(lx *lexer) stateFn {
+	// We MUST see a digit. Even floats have to start with a digit.
+	r := lx.next()
+	if !isDigit(r) {
+		if r == '.' {
+			return lx.errorf("floats must start with a digit, not '.'")
+		}
+		return lx.errorf("expected a digit but got %q", r)
+	}
+	return lexNumber
+}
+
+// lexNumber consumes an integer or a float after seeing the first digit.
+func lexNumber(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumber
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexFloat consumes the elements of a float. It allows any sequence of
+// float-like characters, so floats emitted by the lexer are only a first
+// approximation and must be validated by the parser.
+func lexFloat(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexFloat
+	}
+	switch r {
+	case '_', '.', '-', '+', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemFloat)
+	return lx.pop()
+}
+
+// lexBool consumes a bool string: 'true' or 'false.
+func lexBool(lx *lexer) stateFn {
+	var rs []rune
+	for {
+		r := lx.next()
+		if r == eof || isWhitespace(r) || isNL(r) {
+			lx.backup()
+			break
+		}
+		rs = append(rs, r)
+	}
+	s := string(rs)
+	switch s {
+	case "true", "false":
+		lx.emit(itemBool)
+		return lx.pop()
+	}
+	return lx.errorf("expected value but found %q instead", s)
+}
+
+// lexCommentStart begins the lexing of a comment. It will emit
+// itemCommentStart and consume no characters, passing control to lexComment.
+func lexCommentStart(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemCommentStart)
+	return lexComment
+}
+
+// lexComment lexes an entire comment. It assumes that '#' has been consumed.
+// It will consume *up to* the first newline character, and pass control
+// back to the last state on the stack.
+func lexComment(lx *lexer) stateFn {
+	r := lx.peek()
+	if isNL(r) || r == eof {
+		lx.emit(itemText)
+		return lx.pop()
+	}
+	lx.next()
+	return lexComment
+}
+
+// lexSkip ignores all slurped input and moves on to the next state.
+func lexSkip(lx *lexer, nextState stateFn) stateFn {
+	return func(lx *lexer) stateFn {
+		lx.ignore()
+		return nextState
+	}
+}
+
+// isWhitespace returns true if `r` is a whitespace character according
+// to the spec.
+func isWhitespace(r rune) bool {
+	return r == '\t' || r == ' '
+}
+
+func isNL(r rune) bool {
+	return r == '\n' || r == '\r'
+}
+
+func isDigit(r rune) bool {
+	return r >= '0' && r <= '9'
+}
+
+func isHexadecimal(r rune) bool {
+	return (r >= '0' && r <= '9') ||
+		(r >= 'a' && r <= 'f') ||
+		(r >= 'A' && r <= 'F')
+}
+
+func isBareKeyChar(r rune) bool {
+	return (r >= 'A' && r <= 'Z') ||
+		(r >= 'a' && r <= 'z') ||
+		(r >= '0' && r <= '9') ||
+		r == '_' ||
+		r == '-'
+}
+
+func (itype itemType) String() string {
+	switch itype {
+	case itemError:
+		return "Error"
+	case itemNIL:
+		return "NIL"
+	case itemEOF:
+		return "EOF"
+	case itemText:
+		return "Text"
+	case itemString, itemRawString, itemMultilineString, itemRawMultilineString:
+		return "String"
+	case itemBool:
+		return "Bool"
+	case itemInteger:
+		return "Integer"
+	case itemFloat:
+		return "Float"
+	case itemDatetime:
+		return "DateTime"
+	case itemTableStart:
+		return "TableStart"
+	case itemTableEnd:
+		return "TableEnd"
+	case itemKeyStart:
+		return "KeyStart"
+	case itemArray:
+		return "Array"
+	case itemArrayEnd:
+		return "ArrayEnd"
+	case itemCommentStart:
+		return "CommentStart"
+	}
+	panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype)))
+}
+
+func (item item) String() string {
+	return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val)
+}

vendor/github.com/BurntSushi/toml/parse.go

@@ -0,0 +1,592 @@
+package toml
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+type parser struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	lx      *lexer
+
+	// A list of keys in the order that they appear in the TOML data.
+	ordered []Key
+
+	// the full key for the current hash in scope
+	context Key
+
+	// the base key name for everything except hashes
+	currentKey string
+
+	// rough approximation of line number
+	approxLine int
+
+	// A map of 'key.group.names' to whether they were created implicitly.
+	implicits map[string]bool
+}
+
+type parseError string
+
+func (pe parseError) Error() string {
+	return string(pe)
+}
+
+func parse(data string) (p *parser, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			if err, ok = r.(parseError); ok {
+				return
+			}
+			panic(r)
+		}
+	}()
+
+	p = &parser{
+		mapping:   make(map[string]interface{}),
+		types:     make(map[string]tomlType),
+		lx:        lex(data),
+		ordered:   make([]Key, 0),
+		implicits: make(map[string]bool),
+	}
+	for {
+		item := p.next()
+		if item.typ == itemEOF {
+			break
+		}
+		p.topLevel(item)
+	}
+
+	return p, nil
+}
+
+func (p *parser) panicf(format string, v ...interface{}) {
+	msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s",
+		p.approxLine, p.current(), fmt.Sprintf(format, v...))
+	panic(parseError(msg))
+}
+
+func (p *parser) next() item {
+	it := p.lx.nextItem()
+	if it.typ == itemError {
+		p.panicf("%s", it.val)
+	}
+	return it
+}
+
+func (p *parser) bug(format string, v ...interface{}) {
+	panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
+}
+
+func (p *parser) expect(typ itemType) item {
+	it := p.next()
+	p.assertEqual(typ, it.typ)
+	return it
+}
+
+func (p *parser) assertEqual(expected, got itemType) {
+	if expected != got {
+		p.bug("Expected '%s' but got '%s'.", expected, got)
+	}
+}
+
+func (p *parser) topLevel(item item) {
+	switch item.typ {
+	case itemCommentStart:
+		p.approxLine = item.line
+		p.expect(itemText)
+	case itemTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemTableEnd, kg.typ)
+
+		p.establishContext(key, false)
+		p.setType("", tomlHash)
+		p.ordered = append(p.ordered, key)
+	case itemArrayTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemArrayTableEnd, kg.typ)
+
+		p.establishContext(key, true)
+		p.setType("", tomlArrayHash)
+		p.ordered = append(p.ordered, key)
+	case itemKeyStart:
+		kname := p.next()
+		p.approxLine = kname.line
+		p.currentKey = p.keyString(kname)
+
+		val, typ := p.value(p.next())
+		p.setValue(p.currentKey, val)
+		p.setType(p.currentKey, typ)
+		p.ordered = append(p.ordered, p.context.add(p.currentKey))
+		p.currentKey = ""
+	default:
+		p.bug("Unexpected type at top level: %s", item.typ)
+	}
+}
+
+// Gets a string for a key (or part of a key in a table name).
+func (p *parser) keyString(it item) string {
+	switch it.typ {
+	case itemText:
+		return it.val
+	case itemString, itemMultilineString,
+		itemRawString, itemRawMultilineString:
+		s, _ := p.value(it)
+		return s.(string)
+	default:
+		p.bug("Unexpected key type: %s", it.typ)
+		panic("unreachable")
+	}
+}
+
+// value translates an expected value from the lexer into a Go value wrapped
+// as an empty interface.
+func (p *parser) value(it item) (interface{}, tomlType) {
+	switch it.typ {
+	case itemString:
+		return p.replaceEscapes(it.val), p.typeOfPrimitive(it)
+	case itemMultilineString:
+		trimmed := stripFirstNewline(stripEscapedWhitespace(it.val))
+		return p.replaceEscapes(trimmed), p.typeOfPrimitive(it)
+	case itemRawString:
+		return it.val, p.typeOfPrimitive(it)
+	case itemRawMultilineString:
+		return stripFirstNewline(it.val), p.typeOfPrimitive(it)
+	case itemBool:
+		switch it.val {
+		case "true":
+			return true, p.typeOfPrimitive(it)
+		case "false":
+			return false, p.typeOfPrimitive(it)
+		}
+		p.bug("Expected boolean value, but got '%s'.", it.val)
+	case itemInteger:
+		if !numUnderscoresOK(it.val) {
+			p.panicf("Invalid integer %q: underscores must be surrounded by digits",
+				it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseInt(val, 10, 64)
+		if err != nil {
+			// Distinguish integer values. Normally, it'd be a bug if the lexer
+			// provides an invalid integer, but it's possible that the number is
+			// out of range of valid values (which the lexer cannot determine).
+			// So mark the former as a bug but the latter as a legitimate user
+			// error.
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Integer '%s' is out of the range of 64-bit "+
+					"signed integers.", it.val)
+			} else {
+				p.bug("Expected integer value, but got '%s'.", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemFloat:
+		parts := strings.FieldsFunc(it.val, func(r rune) bool {
+			switch r {
+			case '.', 'e', 'E':
+				return true
+			}
+			return false
+		})
+		for _, part := range parts {
+			if !numUnderscoresOK(part) {
+				p.panicf("Invalid float %q: underscores must be "+
+					"surrounded by digits", it.val)
+			}
+		}
+		if !numPeriodsOK(it.val) {
+			// As a special case, numbers like '123.' or '1.e2',
+			// which are valid as far as Go/strconv are concerned,
+			// must be rejected because TOML says that a fractional
+			// part consists of '.' followed by 1+ digits.
+			p.panicf("Invalid float %q: '.' must be followed "+
+				"by one or more digits", it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseFloat(val, 64)
+		if err != nil {
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Float '%s' is out of the range of 64-bit "+
+					"IEEE-754 floating-point numbers.", it.val)
+			} else {
+				p.panicf("Invalid float value: %q", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemDatetime:
+		var t time.Time
+		var ok bool
+		var err error
+		for _, format := range []string{
+			"2006-01-02T15:04:05Z07:00",
+			"2006-01-02T15:04:05",
+			"2006-01-02",
+		} {
+			t, err = time.ParseInLocation(format, it.val, time.Local)
+			if err == nil {
+				ok = true
+				break
+			}
+		}
+		if !ok {
+			p.panicf("Invalid TOML Datetime: %q.", it.val)
+		}
+		return t, p.typeOfPrimitive(it)
+	case itemArray:
+		array := make([]interface{}, 0)
+		types := make([]tomlType, 0)
+
+		for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
+			if it.typ == itemCommentStart {
+				p.expect(itemText)
+				continue
+			}
+
+			val, typ := p.value(it)
+			array = append(array, val)
+			types = append(types, typ)
+		}
+		return array, p.typeOfArray(types)
+	case itemInlineTableStart:
+		var (
+			hash         = make(map[string]interface{})
+			outerContext = p.context
+			outerKey     = p.currentKey
+		)
+
+		p.context = append(p.context, p.currentKey)
+		p.currentKey = ""
+		for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() {
+			if it.typ != itemKeyStart {
+				p.bug("Expected key start but instead found %q, around line %d",
+					it.val, p.approxLine)
+			}
+			if it.typ == itemCommentStart {
+				p.expect(itemText)
+				continue
+			}
+
+			// retrieve key
+			k := p.next()
+			p.approxLine = k.line
+			kname := p.keyString(k)
+
+			// retrieve value
+			p.currentKey = kname
+			val, typ := p.value(p.next())
+			// make sure we keep metadata up to date
+			p.setType(kname, typ)
+			p.ordered = append(p.ordered, p.context.add(p.currentKey))
+			hash[kname] = val
+		}
+		p.context = outerContext
+		p.currentKey = outerKey
+		return hash, tomlHash
+	}
+	p.bug("Unexpected value type: %s", it.typ)
+	panic("unreachable")
+}
+
+// numUnderscoresOK checks whether each underscore in s is surrounded by
+// characters that are not underscores.
+func numUnderscoresOK(s string) bool {
+	accept := false
+	for _, r := range s {
+		if r == '_' {
+			if !accept {
+				return false
+			}
+			accept = false
+			continue
+		}
+		accept = true
+	}
+	return accept
+}
+
+// numPeriodsOK checks whether every period in s is followed by a digit.
+func numPeriodsOK(s string) bool {
+	period := false
+	for _, r := range s {
+		if period && !isDigit(r) {
+			return false
+		}
+		period = r == '.'
+	}
+	return !period
+}
+
+// establishContext sets the current context of the parser,
+// where the context is either a hash or an array of hashes. Which one is
+// set depends on the value of the `array` parameter.
+//
+// Establishing the context also makes sure that the key isn't a duplicate, and
+// will create implicit hashes automatically.
+func (p *parser) establishContext(key Key, array bool) {
+	var ok bool
+
+	// Always start at the top level and drill down for our context.
+	hashContext := p.mapping
+	keyContext := make(Key, 0)
+
+	// We only need implicit hashes for key[0:-1]
+	for _, k := range key[0 : len(key)-1] {
+		_, ok = hashContext[k]
+		keyContext = append(keyContext, k)
+
+		// No key? Make an implicit hash and move on.
+		if !ok {
+			p.addImplicit(keyContext)
+			hashContext[k] = make(map[string]interface{})
+		}
+
+		// If the hash context is actually an array of tables, then set
+		// the hash context to the last element in that array.
+		//
+		// Otherwise, it better be a table, since this MUST be a key group (by
+		// virtue of it not being the last element in a key).
+		switch t := hashContext[k].(type) {
+		case []map[string]interface{}:
+			hashContext = t[len(t)-1]
+		case map[string]interface{}:
+			hashContext = t
+		default:
+			p.panicf("Key '%s' was already created as a hash.", keyContext)
+		}
+	}
+
+	p.context = keyContext
+	if array {
+		// If this is the first element for this array, then allocate a new
+		// list of tables for it.
+		k := key[len(key)-1]
+		if _, ok := hashContext[k]; !ok {
+			hashContext[k] = make([]map[string]interface{}, 0, 5)
+		}
+
+		// Add a new table. But make sure the key hasn't already been used
+		// for something else.
+		if hash, ok := hashContext[k].([]map[string]interface{}); ok {
+			hashContext[k] = append(hash, make(map[string]interface{}))
+		} else {
+			p.panicf("Key '%s' was already created and cannot be used as "+
+				"an array.", keyContext)
+		}
+	} else {
+		p.setValue(key[len(key)-1], make(map[string]interface{}))
+	}
+	p.context = append(p.context, key[len(key)-1])
+}
+
+// setValue sets the given key to the given value in the current context.
+// It will make sure that the key hasn't already been defined, account for
+// implicit key groups.
+func (p *parser) setValue(key string, value interface{}) {
+	var tmpHash interface{}
+	var ok bool
+
+	hash := p.mapping
+	keyContext := make(Key, 0)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+		if tmpHash, ok = hash[k]; !ok {
+			p.bug("Context for key '%s' has not been established.", keyContext)
+		}
+		switch t := tmpHash.(type) {
+		case []map[string]interface{}:
+			// The context is a table of hashes. Pick the most recent table
+			// defined as the current hash.
+			hash = t[len(t)-1]
+		case map[string]interface{}:
+			hash = t
+		default:
+			p.bug("Expected hash to have type 'map[string]interface{}', but "+
+				"it has '%T' instead.", tmpHash)
+		}
+	}
+	keyContext = append(keyContext, key)
+
+	if _, ok := hash[key]; ok {
+		// Typically, if the given key has already been set, then we have
+		// to raise an error since duplicate keys are disallowed. However,
+		// it's possible that a key was previously defined implicitly. In this
+		// case, it is allowed to be redefined concretely. (See the
+		// `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
+		//
+		// But we have to make sure to stop marking it as an implicit. (So that
+		// another redefinition provokes an error.)
+		//
+		// Note that since it has already been defined (as a hash), we don't
+		// want to overwrite it. So our business is done.
+		if p.isImplicit(keyContext) {
+			p.removeImplicit(keyContext)
+			return
+		}
+
+		// Otherwise, we have a concrete key trying to override a previous
+		// key, which is *always* wrong.
+		p.panicf("Key '%s' has already been defined.", keyContext)
+	}
+	hash[key] = value
+}
+
+// setType sets the type of a particular value at a given key.
+// It should be called immediately AFTER setValue.
+//
+// Note that if `key` is empty, then the type given will be applied to the
+// current context (which is either a table or an array of tables).
+func (p *parser) setType(key string, typ tomlType) {
+	keyContext := make(Key, 0, len(p.context)+1)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+	}
+	if len(key) > 0 { // allow type setting for hashes
+		keyContext = append(keyContext, key)
+	}
+	p.types[keyContext.String()] = typ
+}
+
+// addImplicit sets the given Key as having been created implicitly.
+func (p *parser) addImplicit(key Key) {
+	p.implicits[key.String()] = true
+}
+
+// removeImplicit stops tagging the given key as having been implicitly
+// created.
+func (p *parser) removeImplicit(key Key) {
+	p.implicits[key.String()] = false
+}
+
+// isImplicit returns true if the key group pointed to by the key was created
+// implicitly.
+func (p *parser) isImplicit(key Key) bool {
+	return p.implicits[key.String()]
+}
+
+// current returns the full key name of the current context.
+func (p *parser) current() string {
+	if len(p.currentKey) == 0 {
+		return p.context.String()
+	}
+	if len(p.context) == 0 {
+		return p.currentKey
+	}
+	return fmt.Sprintf("%s.%s", p.context, p.currentKey)
+}
+
+func stripFirstNewline(s string) string {
+	if len(s) == 0 || s[0] != '\n' {
+		return s
+	}
+	return s[1:]
+}
+
+func stripEscapedWhitespace(s string) string {
+	esc := strings.Split(s, "\\\n")
+	if len(esc) > 1 {
+		for i := 1; i < len(esc); i++ {
+			esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace)
+		}
+	}
+	return strings.Join(esc, "")
+}
+
+func (p *parser) replaceEscapes(str string) string {
+	var replaced []rune
+	s := []byte(str)
+	r := 0
+	for r < len(s) {
+		if s[r] != '\\' {
+			c, size := utf8.DecodeRune(s[r:])
+			r += size
+			replaced = append(replaced, c)
+			continue
+		}
+		r += 1
+		if r >= len(s) {
+			p.bug("Escape sequence at end of string.")
+			return ""
+		}
+		switch s[r] {
+		default:
+			p.bug("Expected valid escape code after \\, but got %q.", s[r])
+			return ""
+		case 'b':
+			replaced = append(replaced, rune(0x0008))
+			r += 1
+		case 't':
+			replaced = append(replaced, rune(0x0009))
+			r += 1
+		case 'n':
+			replaced = append(replaced, rune(0x000A))
+			r += 1
+		case 'f':
+			replaced = append(replaced, rune(0x000C))
+			r += 1
+		case 'r':
+			replaced = append(replaced, rune(0x000D))
+			r += 1
+		case '"':
+			replaced = append(replaced, rune(0x0022))
+			r += 1
+		case '\\':
+			replaced = append(replaced, rune(0x005C))
+			r += 1
+		case 'u':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+5). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+5])
+			replaced = append(replaced, escaped)
+			r += 5
+		case 'U':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+9). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+9])
+			replaced = append(replaced, escaped)
+			r += 9
+		}
+	}
+	return string(replaced)
+}
+
+func (p *parser) asciiEscapeToUnicode(bs []byte) rune {
+	s := string(bs)
+	hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
+	if err != nil {
+		p.bug("Could not parse '%s' as a hexadecimal number, but the "+
+			"lexer claims it's OK: %s", s, err)
+	}
+	if !utf8.ValidRune(rune(hex)) {
+		p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s)
+	}
+	return rune(hex)
+}
+
+func isStringType(ty itemType) bool {
+	return ty == itemString || ty == itemMultilineString ||
+		ty == itemRawString || ty == itemRawMultilineString
+}

vendor/github.com/BurntSushi/toml/session.vim

@@ -0,0 +1 @@
+au BufWritePost *.go silent!make tags > /dev/null 2>&1

vendor/github.com/BurntSushi/toml/type_check.go

@@ -0,0 +1,91 @@
+package toml
+
+// tomlType represents any Go type that corresponds to a TOML type.
+// While the first draft of the TOML spec has a simplistic type system that
+// probably doesn't need this level of sophistication, we seem to be militating
+// toward adding real composite types.
+type tomlType interface {
+	typeString() string
+}
+
+// typeEqual accepts any two types and returns true if they are equal.
+func typeEqual(t1, t2 tomlType) bool {
+	if t1 == nil || t2 == nil {
+		return false
+	}
+	return t1.typeString() == t2.typeString()
+}
+
+func typeIsHash(t tomlType) bool {
+	return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash)
+}
+
+type tomlBaseType string
+
+func (btype tomlBaseType) typeString() string {
+	return string(btype)
+}
+
+func (btype tomlBaseType) String() string {
+	return btype.typeString()
+}
+
+var (
+	tomlInteger   tomlBaseType = "Integer"
+	tomlFloat     tomlBaseType = "Float"
+	tomlDatetime  tomlBaseType = "Datetime"
+	tomlString    tomlBaseType = "String"
+	tomlBool      tomlBaseType = "Bool"
+	tomlArray     tomlBaseType = "Array"
+	tomlHash      tomlBaseType = "Hash"
+	tomlArrayHash tomlBaseType = "ArrayHash"
+)
+
+// typeOfPrimitive returns a tomlType of any primitive value in TOML.
+// Primitive values are: Integer, Float, Datetime, String and Bool.
+//
+// Passing a lexer item other than the following will cause a BUG message
+// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
+func (p *parser) typeOfPrimitive(lexItem item) tomlType {
+	switch lexItem.typ {
+	case itemInteger:
+		return tomlInteger
+	case itemFloat:
+		return tomlFloat
+	case itemDatetime:
+		return tomlDatetime
+	case itemString:
+		return tomlString
+	case itemMultilineString:
+		return tomlString
+	case itemRawString:
+		return tomlString
+	case itemRawMultilineString:
+		return tomlString
+	case itemBool:
+		return tomlBool
+	}
+	p.bug("Cannot infer primitive type of lex item '%s'.", lexItem)
+	panic("unreachable")
+}
+
+// typeOfArray returns a tomlType for an array given a list of types of its
+// values.
+//
+// In the current spec, if an array is homogeneous, then its type is always
+// "Array". If the array is not homogeneous, an error is generated.
+func (p *parser) typeOfArray(types []tomlType) tomlType {
+	// Empty arrays are cool.
+	if len(types) == 0 {
+		return tomlArray
+	}
+
+	theType := types[0]
+	for _, t := range types[1:] {
+		if !typeEqual(theType, t) {
+			p.panicf("Array contains values of type '%s' and '%s', but "+
+				"arrays must be homogeneous.", theType, t)
+		}
+	}
+	return tomlArray
+}

vendor/github.com/BurntSushi/toml/type_fields.go

@@ -0,0 +1,242 @@
+package toml
+
+// Struct field handling is adapted from code in encoding/json:
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the Go distribution.
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+// A field represents a single field found in a struct.
+type field struct {
+	name  string       // the name of the field (`toml` tag included)
+	tag   bool         // whether field has a `toml` tag
+	index []int        // represents the depth of an anonymous field
+	typ   reflect.Type // the type of the field
+}
+
+// byName sorts field by name, breaking ties with depth,
+// then breaking ties with "name came from toml tag", then
+// breaking ties with index sequence.
+type byName []field
+
+func (x byName) Len() int { return len(x) }
+
+func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byName) Less(i, j int) bool {
+	if x[i].name != x[j].name {
+		return x[i].name < x[j].name
+	}
+	if len(x[i].index) != len(x[j].index) {
+		return len(x[i].index) < len(x[j].index)
+	}
+	if x[i].tag != x[j].tag {
+		return x[i].tag
+	}
+	return byIndex(x).Less(i, j)
+}
+
+// byIndex sorts field by index sequence.
+type byIndex []field
+
+func (x byIndex) Len() int { return len(x) }
+
+func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byIndex) Less(i, j int) bool {
+	for k, xik := range x[i].index {
+		if k >= len(x[j].index) {
+			return false
+		}
+		if xik != x[j].index[k] {
+			return xik < x[j].index[k]
+		}
+	}
+	return len(x[i].index) < len(x[j].index)
+}
+
+// typeFields returns a list of fields that TOML should recognize for the given
+// type. The algorithm is breadth-first search over the set of structs to
+// include - the top struct and then any reachable anonymous structs.
+func typeFields(t reflect.Type) []field {
+	// Anonymous fields to explore at the current level and the next.
+	current := []field{}
+	next := []field{{typ: t}}
+
+	// Count of queued names for current level and the next.
+	count := map[reflect.Type]int{}
+	nextCount := map[reflect.Type]int{}
+
+	// Types already visited at an earlier level.
+	visited := map[reflect.Type]bool{}
+
+	// Fields found.
+	var fields []field
+
+	for len(next) > 0 {
+		current, next = next, current[:0]
+		count, nextCount = nextCount, map[reflect.Type]int{}
+
+		for _, f := range current {
+			if visited[f.typ] {
+				continue
+			}
+			visited[f.typ] = true
+
+			// Scan f.typ for fields to include.
+			for i := 0; i < f.typ.NumField(); i++ {
+				sf := f.typ.Field(i)
+				if sf.PkgPath != "" && !sf.Anonymous { // unexported
+					continue
+				}
+				opts := getOptions(sf.Tag)
+				if opts.skip {
+					continue
+				}
+				index := make([]int, len(f.index)+1)
+				copy(index, f.index)
+				index[len(f.index)] = i
+
+				ft := sf.Type
+				if ft.Name() == "" && ft.Kind() == reflect.Ptr {
+					// Follow pointer.
+					ft = ft.Elem()
+				}
+
+				// Record found field and index sequence.
+				if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
+					tagged := opts.name != ""
+					name := opts.name
+					if name == "" {
+						name = sf.Name
+					}
+					fields = append(fields, field{name, tagged, index, ft})
+					if count[f.typ] > 1 {
+						// If there were multiple instances, add a second,
+						// so that the annihilation code will see a duplicate.
+						// It only cares about the distinction between 1 or 2,
+						// so don't bother generating any more copies.
+						fields = append(fields, fields[len(fields)-1])
+					}
+					continue
+				}
+
+				// Record new anonymous struct to explore in next round.
+				nextCount[ft]++
+				if nextCount[ft] == 1 {
+					f := field{name: ft.Name(), index: index, typ: ft}
+					next = append(next, f)
+				}
+			}
+		}
+	}
+
+	sort.Sort(byName(fields))
+
+	// Delete all fields that are hidden by the Go rules for embedded fields,
+	// except that fields with TOML tags are promoted.
+
+	// The fields are sorted in primary order of name, secondary order
+	// of field index length. Loop over names; for each name, delete
+	// hidden fields by choosing the one dominant field that survives.
+	out := fields[:0]
+	for advance, i := 0, 0; i < len(fields); i += advance {
+		// One iteration per name.
+		// Find the sequence of fields with the name of this first field.
+		fi := fields[i]
+		name := fi.name
+		for advance = 1; i+advance < len(fields); advance++ {
+			fj := fields[i+advance]
+			if fj.name != name {
+				break
+			}
+		}
+		if advance == 1 { // Only one field with this name
+			out = append(out, fi)
+			continue
+		}
+		dominant, ok := dominantField(fields[i : i+advance])
+		if ok {
+			out = append(out, dominant)
+		}
+	}
+
+	fields = out
+	sort.Sort(byIndex(fields))
+
+	return fields
+}
+
+// dominantField looks through the fields, all of which are known to
+// have the same name, to find the single field that dominates the
+// others using Go's embedding rules, modified by the presence of
+// TOML tags. If there are multiple top-level fields, the boolean
+// will be false: This condition is an error in Go and we skip all
+// the fields.
+func dominantField(fields []field) (field, bool) {
+	// The fields are sorted in increasing index-length order. The winner
+	// must therefore be one with the shortest index length. Drop all
+	// longer entries, which is easy: just truncate the slice.
+	length := len(fields[0].index)
+	tagged := -1 // Index of first tagged field.
+	for i, f := range fields {
+		if len(f.index) > length {
+			fields = fields[:i]
+			break
+		}
+		if f.tag {
+			if tagged >= 0 {
+				// Multiple tagged fields at the same level: conflict.
+				// Return no field.
+				return field{}, false
+			}
+			tagged = i
+		}
+	}
+	if tagged >= 0 {
+		return fields[tagged], true
+	}
+	// All remaining fields have the same length. If there's more than one,
+	// we have a conflict (two fields named "X" at the same level) and we
+	// return no field.
+	if len(fields) > 1 {
+		return field{}, false
+	}
+	return fields[0], true
+}
+
+var fieldCache struct {
+	sync.RWMutex
+	m map[reflect.Type][]field
+}
+
+// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
+func cachedTypeFields(t reflect.Type) []field {
+	fieldCache.RLock()
+	f := fieldCache.m[t]
+	fieldCache.RUnlock()
+	if f != nil {
+		return f
+	}
+
+	// Compute fields without lock.
+	// Might duplicate effort but won't hold other computations back.
+	f = typeFields(t)
+	if f == nil {
+		f = []field{}
+	}
+
+	fieldCache.Lock()
+	if fieldCache.m == nil {
+		fieldCache.m = map[reflect.Type][]field{}
+	}
+	fieldCache.m[t] = f
+	fieldCache.Unlock()
+	return f
+}

vendor/github.com/Philipp15b/go-steam/.gitignore

@@ -0,0 +1,22 @@
+# 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

vendor/github.com/Philipp15b/go-steam/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "generator/SteamKit"]
+	path = generator/SteamKit
+	url = https://github.com/Philipp15b/SteamKit.git

vendor/github.com/Philipp15b/go-steam/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright (c) 2014 The go-steam Authors. 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.
+   * The names of its contributors may not 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
+OWNER 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/Philipp15b/go-steam/README.md

@@ -0,0 +1,64 @@
+# Steam for Go
+
+This library implements Steam's protocol to allow automation of different actions on Steam without running an actual Steam client. It is based on [SteamKit2](https://github.com/SteamRE/SteamKit), a .NET library.
+
+In addition, it contains APIs to Steam Community features, like trade offers and inventories.
+
+Some of the currently implemented features:
+
+  * Trading and trade offers, including inventories and notifications
+  * Friend and group management
+  * Chatting with friends
+  * Persona states (online, offline, looking to trade, etc.)
+  * SteamGuard with two-factor authentication
+  * Team Fortress 2: Crafting, moving, naming and deleting items
+
+If this is useful to you, there's also the [go-steamapi](https://github.com/Philipp15b/go-steamapi) package that wraps some of the official Steam Web API's types.
+
+## Installation
+
+    go get github.com/Philipp15b/go-steam
+
+## Usage
+
+You can view the documentation with the [`godoc`](http://golang.org/cmd/godoc) tool or
+[online on godoc.org](http://godoc.org/github.com/Philipp15b/go-steam).
+
+You should also take a look at the following sub-packages:
+
+  * [`gsbot`](http://godoc.org/github.com/Philipp15b/go-steam/gsbot) utilites that make writing bots easier
+  * [example bot](http://godoc.org/github.com/Philipp15b/go-steam/gsbot/gsbot) and [its source code](https://github.com/Philipp15b/go-steam/blob/master/gsbot/gsbot/gsbot.go)
+  * [`trade`](http://godoc.org/github.com/Philipp15b/go-steam/trade) for trading
+  * [`tradeoffer`](http://godoc.org/github.com/Philipp15b/go-steam/tradeoffer) for trade offers
+  * [`economy/inventory`](http://godoc.org/github.com/Philipp15b/go-steam/economy/inventory) for inventories
+  * [`tf2`](http://godoc.org/github.com/Philipp15b/go-steam/tf2) for Team Fortress 2 related things
+
+## Working with go-steam
+
+Whether you want to develop your own Steam bot or directly work on go-steam itself, there are are few things to know.
+
+ * If something is not working, check first if the same operation works (under the same conditions!) in the Steam client on that account. Maybe there's something go-steam doesn't handle correctly or you're missing a warning that's not obviously shown in go-steam. This is particularly important when working with trading since there are [restrictions](https://support.steampowered.com/kb_article.php?ref=1047-edfm-2932), for example newly authorized devices will not be able to trade for seven days.
+ * Since Steam does not maintain a public API for most of the things go-steam implements, you can expect that sometimes things break randomly. Especially the `trade` and `tradeoffer` packages have been affected in the past.
+ * Always gather as much information as possible. When you file an issue, be as precise and complete as you can. This makes debugging way easier.
+ * If you haven't noticed yet, expect to find lots of things out yourself. Debugging can be complicated and Steam's internals are too.
+ * Sometimes things break and other [SteamKit ports](https://github.com/SteamRE/SteamKit/wiki/Ports) are fixed already. Maybe take a look what people are saying over there? There's also the [SteamKit IRC channel](https://github.com/SteamRE/SteamKit/wiki#contact).
+
+## Updating go-steam to a new SteamKit version
+
+To update go-steam to a new version of SteamKit, do the following:
+
+	go get github.com/golang/protobuf/protoc-gen-go/
+    git submodule init && git submodule update
+    cd generator
+    go run generator.go clean proto steamlang
+
+Make sure that `$GOPATH/bin` / `protoc-gen-go` is in your `$PATH`. You'll also need [`protoc`](https://developers.google.com/protocol-buffers/docs/downloads), the protocol buffer compiler. At the moment, we use Protocol Buffers 2.6.1 with `proco-gen-go`-[2402d76](https://github.com/golang/protobuf/tree/2402d76f3d41f928c7902a765dfc872356dd3aad).
+
+To compile the Steam Language files, you also need the [.NET Framework](https://www.microsoft.com/net/downloads)
+on Windows or [mono](http://www.go-mono.com/mono-downloads/download.html) on other operating systems.
+
+Apply the protocol changes where necessary.
+
+## License
+
+Steam for Go is licensed under the New BSD License. More information can be found in LICENSE.txt.

vendor/github.com/Philipp15b/go-steam/auth.go

@@ -0,0 +1,178 @@
+package steam
+
+import (
+	"crypto/sha1"
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	. "github.com/Philipp15b/go-steam/steamid"
+	"github.com/golang/protobuf/proto"
+	"sync/atomic"
+	"time"
+)
+
+type Auth struct {
+	client  *Client
+	details *LogOnDetails
+}
+
+type SentryHash []byte
+
+type LogOnDetails struct {
+	Username       string
+	Password       string
+	AuthCode       string
+	TwoFactorCode  string
+	SentryFileHash SentryHash
+}
+
+// Log on with the given details. You must always specify username and
+// password. For the first login, don't set an authcode or a hash and you'll receive an error
+// and Steam will send you an authcode. Then you have to login again, this time with the authcode.
+// Shortly after logging in, you'll receive a MachineAuthUpdateEvent with a hash which allows
+// you to login without using an authcode in the future.
+//
+// If you don't use Steam Guard, username and password are enough.
+func (a *Auth) LogOn(details *LogOnDetails) {
+	if len(details.Username) == 0 || len(details.Password) == 0 {
+		panic("Username and password must be set!")
+	}
+
+	logon := new(CMsgClientLogon)
+	logon.AccountName = &details.Username
+	logon.Password = &details.Password
+	if details.AuthCode != "" {
+		logon.AuthCode = proto.String(details.AuthCode)
+	}
+	if details.TwoFactorCode != "" {
+		logon.TwoFactorCode = proto.String(details.TwoFactorCode)
+	}
+	logon.ClientLanguage = proto.String("english")
+	logon.ProtocolVersion = proto.Uint32(MsgClientLogon_CurrentProtocol)
+	logon.ShaSentryfile = details.SentryFileHash
+
+	atomic.StoreUint64(&a.client.steamId, uint64(NewIdAdv(0, 1, int32(EUniverse_Public), int32(EAccountType_Individual))))
+
+	a.client.Write(NewClientMsgProtobuf(EMsg_ClientLogon, logon))
+}
+
+func (a *Auth) HandlePacket(packet *Packet) {
+	switch packet.EMsg {
+	case EMsg_ClientLogOnResponse:
+		a.handleLogOnResponse(packet)
+	case EMsg_ClientNewLoginKey:
+		a.handleLoginKey(packet)
+	case EMsg_ClientSessionToken:
+	case EMsg_ClientLoggedOff:
+		a.handleLoggedOff(packet)
+	case EMsg_ClientUpdateMachineAuth:
+		a.handleUpdateMachineAuth(packet)
+	case EMsg_ClientAccountInfo:
+		a.handleAccountInfo(packet)
+	case EMsg_ClientWalletInfoUpdate:
+	case EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse:
+	case EMsg_ClientMarketingMessageUpdate:
+	}
+}
+
+func (a *Auth) handleLogOnResponse(packet *Packet) {
+	if !packet.IsProto {
+		a.client.Fatalf("Got non-proto logon response!")
+		return
+	}
+
+	body := new(CMsgClientLogonResponse)
+	msg := packet.ReadProtoMsg(body)
+
+	result := EResult(body.GetEresult())
+	if result == EResult_OK {
+		atomic.StoreInt32(&a.client.sessionId, msg.Header.Proto.GetClientSessionid())
+		atomic.StoreUint64(&a.client.steamId, msg.Header.Proto.GetSteamid())
+		a.client.Web.webLoginKey = *body.WebapiAuthenticateUserNonce
+
+		go a.client.heartbeatLoop(time.Duration(body.GetOutOfGameHeartbeatSeconds()))
+
+		a.client.Emit(&LoggedOnEvent{
+			Result:                    EResult(body.GetEresult()),
+			ExtendedResult:            EResult(body.GetEresultExtended()),
+			OutOfGameSecsPerHeartbeat: body.GetOutOfGameHeartbeatSeconds(),
+			InGameSecsPerHeartbeat:    body.GetInGameHeartbeatSeconds(),
+			PublicIp:                  body.GetPublicIp(),
+			ServerTime:                body.GetRtime32ServerTime(),
+			AccountFlags:              EAccountFlags(body.GetAccountFlags()),
+			ClientSteamId:             SteamId(body.GetClientSuppliedSteamid()),
+			EmailDomain:               body.GetEmailDomain(),
+			CellId:                    body.GetCellId(),
+			CellIdPingThreshold:       body.GetCellIdPingThreshold(),
+			Steam2Ticket:              body.GetSteam2Ticket(),
+			UsePics:                   body.GetUsePics(),
+			WebApiUserNonce:           body.GetWebapiAuthenticateUserNonce(),
+			IpCountryCode:             body.GetIpCountryCode(),
+			VanityUrl:                 body.GetVanityUrl(),
+			NumLoginFailuresToMigrate: body.GetCountLoginfailuresToMigrate(),
+			NumDisconnectsToMigrate:   body.GetCountDisconnectsToMigrate(),
+		})
+	} else if result == EResult_Fail || result == EResult_ServiceUnavailable || result == EResult_TryAnotherCM {
+		// some error on Steam's side, we'll get an EOF later
+	} else {
+		a.client.Emit(&LogOnFailedEvent{
+			Result: EResult(body.GetEresult()),
+		})
+		a.client.Disconnect()
+	}
+}
+
+func (a *Auth) handleLoginKey(packet *Packet) {
+	body := new(CMsgClientNewLoginKey)
+	packet.ReadProtoMsg(body)
+	a.client.Write(NewClientMsgProtobuf(EMsg_ClientNewLoginKeyAccepted, &CMsgClientNewLoginKeyAccepted{
+		UniqueId: proto.Uint32(body.GetUniqueId()),
+	}))
+	a.client.Emit(&LoginKeyEvent{
+		UniqueId: body.GetUniqueId(),
+		LoginKey: body.GetLoginKey(),
+	})
+}
+
+func (a *Auth) handleLoggedOff(packet *Packet) {
+	result := EResult_Invalid
+	if packet.IsProto {
+		body := new(CMsgClientLoggedOff)
+		packet.ReadProtoMsg(body)
+		result = EResult(body.GetEresult())
+	} else {
+		body := new(MsgClientLoggedOff)
+		packet.ReadClientMsg(body)
+		result = body.Result
+	}
+	a.client.Emit(&LoggedOffEvent{Result: result})
+}
+
+func (a *Auth) handleUpdateMachineAuth(packet *Packet) {
+	body := new(CMsgClientUpdateMachineAuth)
+	packet.ReadProtoMsg(body)
+	hash := sha1.New()
+	hash.Write(packet.Data)
+	sha := hash.Sum(nil)
+
+	msg := NewClientMsgProtobuf(EMsg_ClientUpdateMachineAuthResponse, &CMsgClientUpdateMachineAuthResponse{
+		ShaFile: sha,
+	})
+	msg.SetTargetJobId(packet.SourceJobId)
+	a.client.Write(msg)
+
+	a.client.Emit(&MachineAuthUpdateEvent{sha})
+}
+
+func (a *Auth) handleAccountInfo(packet *Packet) {
+	body := new(CMsgClientAccountInfo)
+	packet.ReadProtoMsg(body)
+	a.client.Emit(&AccountInfoEvent{
+		PersonaName:          body.GetPersonaName(),
+		Country:              body.GetIpCountry(),
+		CountAuthedComputers: body.GetCountAuthedComputers(),
+		AccountFlags:         EAccountFlags(body.GetAccountFlags()),
+		FacebookId:           body.GetFacebookId(),
+		FacebookName:         body.GetFacebookName(),
+	})
+}

vendor/github.com/Philipp15b/go-steam/auth_events.go

@@ -0,0 +1,53 @@
+package steam
+
+import (
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	. "github.com/Philipp15b/go-steam/steamid"
+)
+
+type LoggedOnEvent struct {
+	Result                    EResult
+	ExtendedResult            EResult
+	OutOfGameSecsPerHeartbeat int32
+	InGameSecsPerHeartbeat    int32
+	PublicIp                  uint32
+	ServerTime                uint32
+	AccountFlags              EAccountFlags
+	ClientSteamId             SteamId `json:",string"`
+	EmailDomain               string
+	CellId                    uint32
+	CellIdPingThreshold       uint32
+	Steam2Ticket              []byte
+	UsePics                   bool
+	WebApiUserNonce           string
+	IpCountryCode             string
+	VanityUrl                 string
+	NumLoginFailuresToMigrate int32
+	NumDisconnectsToMigrate   int32
+}
+
+type LogOnFailedEvent struct {
+	Result EResult
+}
+
+type LoginKeyEvent struct {
+	UniqueId uint32
+	LoginKey string
+}
+
+type LoggedOffEvent struct {
+	Result EResult
+}
+
+type MachineAuthUpdateEvent struct {
+	Hash []byte
+}
+
+type AccountInfoEvent struct {
+	PersonaName          string
+	Country              string
+	CountAuthedComputers int32
+	AccountFlags         EAccountFlags
+	FacebookId           uint64 `json:",string"`
+	FacebookName         string
+}

vendor/github.com/Philipp15b/go-steam/client.go

@@ -0,0 +1,383 @@
+package steam
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"hash/crc32"
+	"io/ioutil"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/Philipp15b/go-steam/cryptoutil"
+	"github.com/Philipp15b/go-steam/netutil"
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	. "github.com/Philipp15b/go-steam/steamid"
+)
+
+// Represents a client to the Steam network.
+// Always poll events from the channel returned by Events() or receiving messages will stop.
+// All access, unless otherwise noted, should be threadsafe.
+//
+// When a FatalErrorEvent is emitted, the connection is automatically closed. The same client can be used to reconnect.
+// Other errors don't have any effect.
+type Client struct {
+	// these need to be 64 bit aligned for sync/atomic on 32bit
+	sessionId    int32
+	_            uint32
+	steamId      uint64
+	currentJobId uint64
+
+	Auth          *Auth
+	Social        *Social
+	Web           *Web
+	Notifications *Notifications
+	Trading       *Trading
+	GC            *GameCoordinator
+
+	events        chan interface{}
+	handlers      []PacketHandler
+	handlersMutex sync.RWMutex
+
+	tempSessionKey []byte
+
+	ConnectionTimeout time.Duration
+
+	mutex     sync.RWMutex // guarding conn and writeChan
+	conn      connection
+	writeChan chan IMsg
+	writeBuf  *bytes.Buffer
+	heartbeat *time.Ticker
+}
+
+type PacketHandler interface {
+	HandlePacket(*Packet)
+}
+
+func NewClient() *Client {
+	client := &Client{
+		events:   make(chan interface{}, 3),
+		writeBuf: new(bytes.Buffer),
+	}
+	client.Auth = &Auth{client: client}
+	client.RegisterPacketHandler(client.Auth)
+	client.Social = newSocial(client)
+	client.RegisterPacketHandler(client.Social)
+	client.Web = &Web{client: client}
+	client.RegisterPacketHandler(client.Web)
+	client.Notifications = newNotifications(client)
+	client.RegisterPacketHandler(client.Notifications)
+	client.Trading = &Trading{client: client}
+	client.RegisterPacketHandler(client.Trading)
+	client.GC = newGC(client)
+	client.RegisterPacketHandler(client.GC)
+	return client
+}
+
+// Get the event channel. By convention all events are pointers, except for errors.
+// It is never closed.
+func (c *Client) Events() <-chan interface{} {
+	return c.events
+}
+
+func (c *Client) Emit(event interface{}) {
+	c.events <- event
+}
+
+// Emits a FatalErrorEvent formatted with fmt.Errorf and disconnects.
+func (c *Client) Fatalf(format string, a ...interface{}) {
+	c.Emit(FatalErrorEvent(fmt.Errorf(format, a...)))
+	c.Disconnect()
+}
+
+// Emits an error formatted with fmt.Errorf.
+func (c *Client) Errorf(format string, a ...interface{}) {
+	c.Emit(fmt.Errorf(format, a...))
+}
+
+// Registers a PacketHandler that receives all incoming packets.
+func (c *Client) RegisterPacketHandler(handler PacketHandler) {
+	c.handlersMutex.Lock()
+	defer c.handlersMutex.Unlock()
+	c.handlers = append(c.handlers, handler)
+}
+
+func (c *Client) GetNextJobId() JobId {
+	return JobId(atomic.AddUint64(&c.currentJobId, 1))
+}
+
+func (c *Client) SteamId() SteamId {
+	return SteamId(atomic.LoadUint64(&c.steamId))
+}
+
+func (c *Client) SessionId() int32 {
+	return atomic.LoadInt32(&c.sessionId)
+}
+
+func (c *Client) Connected() bool {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	return c.conn != nil
+}
+
+// Connects to a random Steam server and returns its address.
+// If this client is already connected, it is disconnected first.
+// This method tries to use an address from the Steam Directory and falls
+// back to the built-in server list if the Steam Directory can't be reached.
+// If you want to connect to a specific server, use `ConnectTo`.
+func (c *Client) Connect() *netutil.PortAddr {
+	var server *netutil.PortAddr
+	if steamDirectoryCache.IsInitialized() {
+		server = steamDirectoryCache.GetRandomCM()
+	} else {
+		server = GetRandomCM()
+	}
+	c.ConnectTo(server)
+	return server
+}
+
+// Connects to a specific server.
+// You may want to use one of the `GetRandom*CM()` functions in this package.
+// If this client is already connected, it is disconnected first.
+func (c *Client) ConnectTo(addr *netutil.PortAddr) {
+	c.ConnectToBind(addr, nil)
+}
+
+// Connects to a specific server, and binds to a specified local IP
+// If this client is already connected, it is disconnected first.
+func (c *Client) ConnectToBind(addr *netutil.PortAddr, local *net.TCPAddr) {
+	c.Disconnect()
+
+	conn, err := dialTCP(local, addr.ToTCPAddr())
+	if err != nil {
+		c.Fatalf("Connect failed: %v", err)
+		return
+	}
+	c.conn = conn
+	c.writeChan = make(chan IMsg, 5)
+
+	go c.readLoop()
+	go c.writeLoop()
+}
+
+func (c *Client) Disconnect() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if c.conn == nil {
+		return
+	}
+
+	c.conn.Close()
+	c.conn = nil
+	if c.heartbeat != nil {
+		c.heartbeat.Stop()
+	}
+	close(c.writeChan)
+	c.Emit(&DisconnectedEvent{})
+
+}
+
+// Adds a message to the send queue. Modifications to the given message after
+// writing are not allowed (possible race conditions).
+//
+// Writes to this client when not connected are ignored.
+func (c *Client) Write(msg IMsg) {
+	if cm, ok := msg.(IClientMsg); ok {
+		cm.SetSessionId(c.SessionId())
+		cm.SetSteamId(c.SteamId())
+	}
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	if c.conn == nil {
+		return
+	}
+	c.writeChan <- msg
+}
+
+func (c *Client) readLoop() {
+	for {
+		// This *should* be atomic on most platforms, but the Go spec doesn't guarantee it
+		c.mutex.RLock()
+		conn := c.conn
+		c.mutex.RUnlock()
+		if conn == nil {
+			return
+		}
+		packet, err := conn.Read()
+
+		if err != nil {
+			c.Fatalf("Error reading from the connection: %v", err)
+			return
+		}
+		c.handlePacket(packet)
+	}
+}
+
+func (c *Client) writeLoop() {
+	for {
+		c.mutex.RLock()
+		conn := c.conn
+		c.mutex.RUnlock()
+		if conn == nil {
+			return
+		}
+
+		msg, ok := <-c.writeChan
+		if !ok {
+			return
+		}
+
+		err := msg.Serialize(c.writeBuf)
+		if err != nil {
+			c.writeBuf.Reset()
+			c.Fatalf("Error serializing message %v: %v", msg, err)
+			return
+		}
+
+		err = conn.Write(c.writeBuf.Bytes())
+
+		c.writeBuf.Reset()
+
+		if err != nil {
+			c.Fatalf("Error writing message %v: %v", msg, err)
+			return
+		}
+	}
+}
+
+func (c *Client) heartbeatLoop(seconds time.Duration) {
+	if c.heartbeat != nil {
+		c.heartbeat.Stop()
+	}
+	c.heartbeat = time.NewTicker(seconds * time.Second)
+	for {
+		_, ok := <-c.heartbeat.C
+		if !ok {
+			break
+		}
+		c.Write(NewClientMsgProtobuf(EMsg_ClientHeartBeat, new(CMsgClientHeartBeat)))
+	}
+	c.heartbeat = nil
+}
+
+func (c *Client) handlePacket(packet *Packet) {
+	switch packet.EMsg {
+	case EMsg_ChannelEncryptRequest:
+		c.handleChannelEncryptRequest(packet)
+	case EMsg_ChannelEncryptResult:
+		c.handleChannelEncryptResult(packet)
+	case EMsg_Multi:
+		c.handleMulti(packet)
+	case EMsg_ClientCMList:
+		c.handleClientCMList(packet)
+	}
+
+	c.handlersMutex.RLock()
+	defer c.handlersMutex.RUnlock()
+	for _, handler := range c.handlers {
+		handler.HandlePacket(packet)
+	}
+}
+
+func (c *Client) handleChannelEncryptRequest(packet *Packet) {
+	body := NewMsgChannelEncryptRequest()
+	packet.ReadMsg(body)
+
+	if body.Universe != EUniverse_Public {
+		c.Fatalf("Invalid univserse %v!", body.Universe)
+	}
+
+	c.tempSessionKey = make([]byte, 32)
+	rand.Read(c.tempSessionKey)
+	encryptedKey := cryptoutil.RSAEncrypt(GetPublicKey(EUniverse_Public), c.tempSessionKey)
+
+	payload := new(bytes.Buffer)
+	payload.Write(encryptedKey)
+	binary.Write(payload, binary.LittleEndian, crc32.ChecksumIEEE(encryptedKey))
+	payload.WriteByte(0)
+	payload.WriteByte(0)
+	payload.WriteByte(0)
+	payload.WriteByte(0)
+
+	c.Write(NewMsg(NewMsgChannelEncryptResponse(), payload.Bytes()))
+}
+
+func (c *Client) handleChannelEncryptResult(packet *Packet) {
+	body := NewMsgChannelEncryptResult()
+	packet.ReadMsg(body)
+
+	if body.Result != EResult_OK {
+		c.Fatalf("Encryption failed: %v", body.Result)
+		return
+	}
+	c.conn.SetEncryptionKey(c.tempSessionKey)
+	c.tempSessionKey = nil
+
+	c.Emit(&ConnectedEvent{})
+}
+
+func (c *Client) handleMulti(packet *Packet) {
+	body := new(CMsgMulti)
+	packet.ReadProtoMsg(body)
+
+	payload := body.GetMessageBody()
+
+	if body.GetSizeUnzipped() > 0 {
+		r, err := gzip.NewReader(bytes.NewReader(payload))
+		if err != nil {
+			c.Errorf("handleMulti: Error while decompressing: %v", err)
+			return
+		}
+
+		payload, err = ioutil.ReadAll(r)
+		if err != nil {
+			c.Errorf("handleMulti: Error while decompressing: %v", err)
+			return
+		}
+	}
+
+	pr := bytes.NewReader(payload)
+	for pr.Len() > 0 {
+		var length uint32
+		binary.Read(pr, binary.LittleEndian, &length)
+		packetData := make([]byte, length)
+		pr.Read(packetData)
+		p, err := NewPacket(packetData)
+		if err != nil {
+			c.Errorf("Error reading packet in Multi msg %v: %v", packet, err)
+			continue
+		}
+		c.handlePacket(p)
+	}
+}
+
+func (c *Client) handleClientCMList(packet *Packet) {
+	body := new(CMsgClientCMList)
+	packet.ReadProtoMsg(body)
+
+	l := make([]*netutil.PortAddr, 0)
+	for i, ip := range body.GetCmAddresses() {
+		l = append(l, &netutil.PortAddr{
+			readIp(ip),
+			uint16(body.GetCmPorts()[i]),
+		})
+	}
+
+	c.Emit(&ClientCMListEvent{l})
+}
+
+func readIp(ip uint32) net.IP {
+	r := make(net.IP, 4)
+	r[3] = byte(ip)
+	r[2] = byte(ip >> 8)
+	r[1] = byte(ip >> 16)
+	r[0] = byte(ip >> 24)
+	return r
+}

vendor/github.com/Philipp15b/go-steam/client_events.go

@@ -0,0 +1,20 @@
+package steam
+
+import (
+	"github.com/Philipp15b/go-steam/netutil"
+)
+
+// When this event is emitted by the Client, the connection is automatically closed.
+// This may be caused by a network error, for example.
+type FatalErrorEvent error
+
+type ConnectedEvent struct{}
+
+type DisconnectedEvent struct{}
+
+// A list of connection manager addresses to connect to in the future.
+// You should always save them and then select one of these
+// instead of the builtin ones for the next connection.
+type ClientCMListEvent struct {
+	Addresses []*netutil.PortAddr
+}

vendor/github.com/Philipp15b/go-steam/connection.go

@@ -0,0 +1,127 @@
+package steam
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+
+	"github.com/Philipp15b/go-steam/cryptoutil"
+	. "github.com/Philipp15b/go-steam/protocol"
+)
+
+type connection interface {
+	Read() (*Packet, error)
+	Write([]byte) error
+	Close() error
+	SetEncryptionKey([]byte)
+	IsEncrypted() bool
+}
+
+const tcpConnectionMagic uint32 = 0x31305456 // "VT01"
+
+type tcpConnection struct {
+	conn        *net.TCPConn
+	ciph        cipher.Block
+	cipherMutex sync.RWMutex
+}
+
+func dialTCP(laddr, raddr *net.TCPAddr) (*tcpConnection, error) {
+	conn, err := net.DialTCP("tcp", laddr, raddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &tcpConnection{
+		conn: conn,
+	}, nil
+}
+
+func (c *tcpConnection) Read() (*Packet, error) {
+	// All packets begin with a packet length
+	var packetLen uint32
+	err := binary.Read(c.conn, binary.LittleEndian, &packetLen)
+	if err != nil {
+		return nil, err
+	}
+
+	// A magic value follows for validation
+	var packetMagic uint32
+	err = binary.Read(c.conn, binary.LittleEndian, &packetMagic)
+	if err != nil {
+		return nil, err
+	}
+	if packetMagic != tcpConnectionMagic {
+		return nil, fmt.Errorf("Invalid connection magic! Expected %d, got %d!", tcpConnectionMagic, packetMagic)
+	}
+
+	buf := make([]byte, packetLen, packetLen)
+	_, err = io.ReadFull(c.conn, buf)
+	if err == io.ErrUnexpectedEOF {
+		return nil, io.EOF
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	// Packets after ChannelEncryptResult are encrypted
+	c.cipherMutex.RLock()
+	if c.ciph != nil {
+		buf = cryptoutil.SymmetricDecrypt(c.ciph, buf)
+	}
+	c.cipherMutex.RUnlock()
+
+	return NewPacket(buf)
+}
+
+// Writes a message. This may only be used by one goroutine at a time.
+func (c *tcpConnection) Write(message []byte) error {
+	c.cipherMutex.RLock()
+	if c.ciph != nil {
+		message = cryptoutil.SymmetricEncrypt(c.ciph, message)
+	}
+	c.cipherMutex.RUnlock()
+
+	err := binary.Write(c.conn, binary.LittleEndian, uint32(len(message)))
+	if err != nil {
+		return err
+	}
+	err = binary.Write(c.conn, binary.LittleEndian, tcpConnectionMagic)
+	if err != nil {
+		return err
+	}
+
+	_, err = c.conn.Write(message)
+	return err
+}
+
+func (c *tcpConnection) Close() error {
+	return c.conn.Close()
+}
+
+func (c *tcpConnection) SetEncryptionKey(key []byte) {
+	c.cipherMutex.Lock()
+	defer c.cipherMutex.Unlock()
+	if key == nil {
+		c.ciph = nil
+		return
+	}
+	if len(key) != 32 {
+		panic("Connection AES key is not 32 bytes long!")
+	}
+
+	var err error
+	c.ciph, err = aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (c *tcpConnection) IsEncrypted() bool {
+	c.cipherMutex.RLock()
+	defer c.cipherMutex.RUnlock()
+	return c.ciph != nil
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/cryptoutil.go

@@ -0,0 +1,38 @@
+package cryptoutil
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+)
+
+// Performs an encryption using AES/CBC/PKCS7
+// with a random IV prepended using AES/ECB/None.
+func SymmetricEncrypt(ciph cipher.Block, src []byte) []byte {
+	// get a random IV and ECB encrypt it
+	iv := make([]byte, aes.BlockSize, aes.BlockSize)
+	_, err := rand.Read(iv)
+	if err != nil {
+		panic(err)
+	}
+	encryptedIv := make([]byte, aes.BlockSize, aes.BlockSize)
+	newECBEncrypter(ciph).CryptBlocks(encryptedIv, iv)
+
+	// pad it, copy the IV to the first 16 bytes and encrypt the rest with CBC
+	encrypted := padPKCS7WithIV(src)
+	copy(encrypted, encryptedIv)
+	cipher.NewCBCEncrypter(ciph, iv).CryptBlocks(encrypted[aes.BlockSize:], encrypted[aes.BlockSize:])
+	return encrypted
+}
+
+// Decrypts data from the reader using AES/CBC/PKCS7 with an IV
+// prepended using AES/ECB/None. The src slice may not be used anymore.
+func SymmetricDecrypt(ciph cipher.Block, src []byte) []byte {
+	iv := src[:aes.BlockSize]
+	newECBDecrypter(ciph).CryptBlocks(iv, iv)
+
+	data := src[aes.BlockSize:]
+	cipher.NewCBCDecrypter(ciph, iv).CryptBlocks(data, data)
+
+	return unpadPKCS7(data)
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/ecb.go

@@ -0,0 +1,68 @@
+package cryptoutil
+
+import (
+	"crypto/cipher"
+)
+
+// From this code review: https://codereview.appspot.com/7860047/
+// by fasmat for the Go crypto/cipher package
+
+type ecb struct {
+	b         cipher.Block
+	blockSize int
+}
+
+func newECB(b cipher.Block) *ecb {
+	return &ecb{
+		b:         b,
+		blockSize: b.BlockSize(),
+	}
+}
+
+type ecbEncrypter ecb
+
+// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
+// mode, using the given Block.
+func newECBEncrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbEncrypter)(newECB(b))
+}
+
+func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
+
+func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("cryptoutil/ecb: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("cryptoutil/ecb: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Encrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}
+
+type ecbDecrypter ecb
+
+// newECBDecrypter returns a BlockMode which decrypts in electronic code book
+// mode, using the given Block.
+func newECBDecrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbDecrypter)(newECB(b))
+}
+
+func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
+
+func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("cryptoutil/ecb: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("cryptoutil/ecb: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Decrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/pkcs7.go

@@ -0,0 +1,25 @@
+package cryptoutil
+
+import (
+	"crypto/aes"
+)
+
+// Returns a new byte array padded with PKCS7 and prepended
+// with empty space of the AES block size (16 bytes) for the IV.
+func padPKCS7WithIV(src []byte) []byte {
+	missing := aes.BlockSize - (len(src) % aes.BlockSize)
+	newSize := len(src) + aes.BlockSize + missing
+	dest := make([]byte, newSize, newSize)
+	copy(dest[aes.BlockSize:], src)
+
+	padding := byte(missing)
+	for i := newSize - missing; i < newSize; i++ {
+		dest[i] = padding
+	}
+	return dest
+}
+
+func unpadPKCS7(src []byte) []byte {
+	padLen := src[len(src)-1]
+	return src[:len(src)-int(padLen)]
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/rsa.go

@@ -0,0 +1,31 @@
+package cryptoutil
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/x509"
+	"errors"
+)
+
+// Parses a DER encoded RSA public key
+func ParseASN1RSAPublicKey(derBytes []byte) (*rsa.PublicKey, error) {
+	key, err := x509.ParsePKIXPublicKey(derBytes)
+	if err != nil {
+		return nil, err
+	}
+	pubKey, ok := key.(*rsa.PublicKey)
+	if !ok {
+		return nil, errors.New("not an RSA public key")
+	}
+	return pubKey, nil
+}
+
+// Encrypts a message with the given public key using RSA-OAEP and the sha1 hash function.
+func RSAEncrypt(pub *rsa.PublicKey, msg []byte) []byte {
+	b, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, pub, msg, nil)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}

vendor/github.com/Philipp15b/go-steam/doc.go

@@ -0,0 +1,53 @@
+/*
+This package allows you to automate actions on Valve's Steam network. It is a Go port of SteamKit.
+
+To login, you'll have to create a new Client first. Then connect to the Steam network
+and wait for a ConnectedCallback. Then you may call the Login method in the Auth module
+with your login information. This is covered in more detail in the method's documentation. After you've
+received the LoggedOnEvent, you should set your persona state to online to receive friend lists etc.
+
+Example code
+
+You can also find a running example in the `gsbot` package.
+
+	package main
+
+	import (
+		"io/ioutil"
+		"log"
+
+		"github.com/Philipp15b/go-steam"
+		"github.com/Philipp15b/go-steam/protocol/steamlang"
+	)
+
+	func main() {
+		myLoginInfo := new(steam.LogOnDetails)
+		myLoginInfo.Username = "Your username"
+		myLoginInfo.Password = "Your password"
+
+		client := steam.NewClient()
+		client.Connect()
+		for event := range client.Events() {
+			switch e := event.(type) {
+			case *steam.ConnectedEvent:
+				client.Auth.LogOn(myLoginInfo)
+			case *steam.MachineAuthUpdateEvent:
+				ioutil.WriteFile("sentry", e.Hash, 0666)
+			case *steam.LoggedOnEvent:
+				client.Social.SetPersonaState(steamlang.EPersonaState_Online)
+			case steam.FatalErrorEvent:
+				log.Print(e)
+			case error:
+				log.Print(e)
+			}
+		}
+	}
+
+
+Events
+
+go-steam emits events that can be read via Client.Events(). Although the channel has the type interface{},
+only types from this package ending with "Event" and errors will be emitted.
+
+*/
+package steam

vendor/github.com/Philipp15b/go-steam/gamecoordinator.go

@@ -0,0 +1,79 @@
+package steam
+
+import (
+	"bytes"
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/gamecoordinator"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	"github.com/golang/protobuf/proto"
+)
+
+type GameCoordinator struct {
+	client   *Client
+	handlers []GCPacketHandler
+}
+
+func newGC(client *Client) *GameCoordinator {
+	return &GameCoordinator{
+		client:   client,
+		handlers: make([]GCPacketHandler, 0),
+	}
+}
+
+type GCPacketHandler interface {
+	HandleGCPacket(*GCPacket)
+}
+
+func (g *GameCoordinator) RegisterPacketHandler(handler GCPacketHandler) {
+	g.handlers = append(g.handlers, handler)
+}
+
+func (g *GameCoordinator) HandlePacket(packet *Packet) {
+	if packet.EMsg != EMsg_ClientFromGC {
+		return
+	}
+
+	msg := new(CMsgGCClient)
+	packet.ReadProtoMsg(msg)
+
+	p, err := NewGCPacket(msg)
+	if err != nil {
+		g.client.Errorf("Error reading GC message: %v", err)
+		return
+	}
+
+	for _, handler := range g.handlers {
+		handler.HandleGCPacket(p)
+	}
+}
+
+func (g *GameCoordinator) Write(msg IGCMsg) {
+	buf := new(bytes.Buffer)
+	msg.Serialize(buf)
+
+	msgType := msg.GetMsgType()
+	if msg.IsProto() {
+		msgType = msgType | 0x80000000 // mask with protoMask
+	}
+
+	g.client.Write(NewClientMsgProtobuf(EMsg_ClientToGC, &CMsgGCClient{
+		Msgtype: proto.Uint32(msgType),
+		Appid:   proto.Uint32(msg.GetAppId()),
+		Payload: buf.Bytes(),
+	}))
+}
+
+// Sets you in the given games. Specify none to quit all games.
+func (g *GameCoordinator) SetGamesPlayed(appIds ...uint64) {
+	games := make([]*CMsgClientGamesPlayed_GamePlayed, 0)
+	for _, appId := range appIds {
+		games = append(games, &CMsgClientGamesPlayed_GamePlayed{
+			GameId: proto.Uint64(appId),
+		})
+	}
+
+	g.client.Write(NewClientMsgProtobuf(EMsg_ClientGamesPlayed, &CMsgClientGamesPlayed{
+		GamesPlayed: games,
+	}))
+}

vendor/github.com/Philipp15b/go-steam/keys.go

@@ -0,0 +1,58 @@
+package steam
+
+import (
+	"crypto/rsa"
+	"github.com/Philipp15b/go-steam/cryptoutil"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+)
+
+var publicKeys = map[EUniverse][]byte{
+	EUniverse_Public: []byte{
+		0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
+		0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xDF, 0xEC, 0x1A,
+		0xD6, 0x2C, 0x10, 0x66, 0x2C, 0x17, 0x35, 0x3A, 0x14, 0xB0, 0x7C, 0x59, 0x11, 0x7F, 0x9D, 0xD3,
+		0xD8, 0x2B, 0x7A, 0xE3, 0xE0, 0x15, 0xCD, 0x19, 0x1E, 0x46, 0xE8, 0x7B, 0x87, 0x74, 0xA2, 0x18,
+		0x46, 0x31, 0xA9, 0x03, 0x14, 0x79, 0x82, 0x8E, 0xE9, 0x45, 0xA2, 0x49, 0x12, 0xA9, 0x23, 0x68,
+		0x73, 0x89, 0xCF, 0x69, 0xA1, 0xB1, 0x61, 0x46, 0xBD, 0xC1, 0xBE, 0xBF, 0xD6, 0x01, 0x1B, 0xD8,
+		0x81, 0xD4, 0xDC, 0x90, 0xFB, 0xFE, 0x4F, 0x52, 0x73, 0x66, 0xCB, 0x95, 0x70, 0xD7, 0xC5, 0x8E,
+		0xBA, 0x1C, 0x7A, 0x33, 0x75, 0xA1, 0x62, 0x34, 0x46, 0xBB, 0x60, 0xB7, 0x80, 0x68, 0xFA, 0x13,
+		0xA7, 0x7A, 0x8A, 0x37, 0x4B, 0x9E, 0xC6, 0xF4, 0x5D, 0x5F, 0x3A, 0x99, 0xF9, 0x9E, 0xC4, 0x3A,
+		0xE9, 0x63, 0xA2, 0xBB, 0x88, 0x19, 0x28, 0xE0, 0xE7, 0x14, 0xC0, 0x42, 0x89, 0x02, 0x01, 0x11,
+	},
+
+	EUniverse_Beta: []byte{
+		0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
+		0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xAE, 0xD1, 0x4B,
+		0xC0, 0xA3, 0x36, 0x8B, 0xA0, 0x39, 0x0B, 0x43, 0xDC, 0xED, 0x6A, 0xC8, 0xF2, 0xA3, 0xE4, 0x7E,
+		0x09, 0x8C, 0x55, 0x2E, 0xE7, 0xE9, 0x3C, 0xBB, 0xE5, 0x5E, 0x0F, 0x18, 0x74, 0x54, 0x8F, 0xF3,
+		0xBD, 0x56, 0x69, 0x5B, 0x13, 0x09, 0xAF, 0xC8, 0xBE, 0xB3, 0xA1, 0x48, 0x69, 0xE9, 0x83, 0x49,
+		0x65, 0x8D, 0xD2, 0x93, 0x21, 0x2F, 0xB9, 0x1E, 0xFA, 0x74, 0x3B, 0x55, 0x22, 0x79, 0xBF, 0x85,
+		0x18, 0xCB, 0x6D, 0x52, 0x44, 0x4E, 0x05, 0x92, 0x89, 0x6A, 0xA8, 0x99, 0xED, 0x44, 0xAE, 0xE2,
+		0x66, 0x46, 0x42, 0x0C, 0xFB, 0x6E, 0x4C, 0x30, 0xC6, 0x6C, 0x5C, 0x16, 0xFF, 0xBA, 0x9C, 0xB9,
+		0x78, 0x3F, 0x17, 0x4B, 0xCB, 0xC9, 0x01, 0x5D, 0x3E, 0x37, 0x70, 0xEC, 0x67, 0x5A, 0x33, 0x48,
+	},
+
+	EUniverse_Internal: []byte{
+		0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
+		0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xA8, 0xFE, 0x01,
+		0x3B, 0xB6, 0xD7, 0x21, 0x4B, 0x53, 0x23, 0x6F, 0xA1, 0xAB, 0x4E, 0xF1, 0x07, 0x30, 0xA7, 0xC6,
+		0x7E, 0x6A, 0x2C, 0xC2, 0x5D, 0x3A, 0xB8, 0x40, 0xCA, 0x59, 0x4D, 0x16, 0x2D, 0x74, 0xEB, 0x0E,
+		0x72, 0x46, 0x29, 0xF9, 0xDE, 0x9B, 0xCE, 0x4B, 0x8C, 0xD0, 0xCA, 0xF4, 0x08, 0x94, 0x46, 0xA5,
+		0x11, 0xAF, 0x3A, 0xCB, 0xB8, 0x4E, 0xDE, 0xC6, 0xD8, 0x85, 0x0A, 0x7D, 0xAA, 0x96, 0x0A, 0xEA,
+		0x7B, 0x51, 0xD6, 0x22, 0x62, 0x5C, 0x1E, 0x58, 0xD7, 0x46, 0x1E, 0x09, 0xAE, 0x43, 0xA7, 0xC4,
+		0x34, 0x69, 0xA2, 0xA5, 0xE8, 0x44, 0x76, 0x18, 0xE2, 0x3D, 0xB7, 0xC5, 0xA8, 0x96, 0xFD, 0xE5,
+		0xB4, 0x4B, 0xF8, 0x40, 0x12, 0xA6, 0x17, 0x4E, 0xC4, 0xC1, 0x60, 0x0E, 0xB0, 0xC2, 0xB8, 0x40,
+	},
+}
+
+func GetPublicKey(universe EUniverse) *rsa.PublicKey {
+	bytes, ok := publicKeys[universe]
+	if !ok {
+		return nil
+	}
+	key, err := cryptoutil.ParseASN1RSAPublicKey(bytes)
+	if err != nil {
+		panic(err)
+	}
+	return key
+}

vendor/github.com/Philipp15b/go-steam/netutil/addr.go

@@ -0,0 +1,43 @@
+package netutil
+
+import (
+	"net"
+	"strconv"
+	"strings"
+)
+
+// An addr that is neither restricted to TCP nor UDP, but has an IP and a port.
+type PortAddr struct {
+	IP   net.IP
+	Port uint16
+}
+
+// Parses an IP address with a port, for example "209.197.29.196:27017".
+// If the given string is not valid, this function returns nil.
+func ParsePortAddr(addr string) *PortAddr {
+	parts := strings.Split(addr, ":")
+	if len(parts) != 2 {
+		return nil
+	}
+	ip := net.ParseIP(parts[0])
+	if ip == nil {
+		return nil
+	}
+	port, err := strconv.ParseUint(parts[1], 10, 16)
+	if err != nil {
+		return nil
+	}
+	return &PortAddr{ip, uint16(port)}
+}
+
+func (p *PortAddr) ToTCPAddr() *net.TCPAddr {
+	return &net.TCPAddr{p.IP, int(p.Port), ""}
+}
+
+func (p *PortAddr) ToUDPAddr() *net.UDPAddr {
+	return &net.UDPAddr{p.IP, int(p.Port), ""}
+}
+
+func (p *PortAddr) String() string {
+	return p.IP.String() + ":" + strconv.FormatUint(uint64(p.Port), 10)
+}

vendor/github.com/Philipp15b/go-steam/netutil/http.go

@@ -0,0 +1,17 @@
+package netutil
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Version of http.Client.PostForm that returns a new request instead of executing it directly.
+func NewPostForm(url string, data url.Values) *http.Request {
+	req, err := http.NewRequest("POST", url, strings.NewReader(data.Encode()))
+	if err != nil {
+		panic(err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	return req
+}

vendor/github.com/Philipp15b/go-steam/netutil/url.go

@@ -0,0 +1,13 @@
+package netutil
+
+import (
+	"net/url"
+)
+
+func ToUrlValues(m map[string]string) url.Values {
+	r := make(url.Values)
+	for k, v := range m {
+		r.Add(k, v)
+	}
+	return r
+}

vendor/github.com/Philipp15b/go-steam/notifications.go

@@ -0,0 +1,62 @@
+package steam
+
+import (
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+)
+
+type Notifications struct {
+	// Maps notification types to their count. If a type is not present in the map,
+	// its count is zero.
+	notifications map[NotificationType]uint
+	client        *Client
+}
+
+func newNotifications(client *Client) *Notifications {
+	return &Notifications{
+		make(map[NotificationType]uint),
+		client,
+	}
+}
+
+func (n *Notifications) HandlePacket(packet *Packet) {
+	switch packet.EMsg {
+	case EMsg_ClientUserNotifications:
+		n.handleClientUserNotifications(packet)
+	}
+}
+
+type NotificationType uint
+
+const (
+	TradeOffer NotificationType = 1
+)
+
+func (n *Notifications) handleClientUserNotifications(packet *Packet) {
+	msg := new(CMsgClientUserNotifications)
+	packet.ReadProtoMsg(msg)
+
+	for _, notification := range msg.GetNotifications() {
+		typ := NotificationType(*notification.UserNotificationType)
+		count := uint(*notification.Count)
+		n.notifications[typ] = count
+		n.client.Emit(&NotificationEvent{typ, count})
+	}
+
+	// check if there is a notification in our map that isn't in the current packet
+	for typ, _ := range n.notifications {
+		exists := false
+		for _, t := range msg.GetNotifications() {
+			if NotificationType(*t.UserNotificationType) == typ {
+				exists = true
+				break
+			}
+		}
+
+		if !exists {
+			delete(n.notifications, typ)
+			n.client.Emit(&NotificationEvent{typ, 0})
+		}
+	}
+}

vendor/github.com/Philipp15b/go-steam/notifications_events.go

@@ -0,0 +1,9 @@
+package steam
+
+// This event is emitted for every CMsgClientUserNotifications message and likewise only used for
+// trade offers. Unlike the the above it is also emitted when the count of a type that was tracked
+// before by this Notifications instance reaches zero.
+type NotificationEvent struct {
+	Type  NotificationType
+	Count uint
+}

vendor/github.com/Philipp15b/go-steam/protocol/doc.go

@@ -0,0 +1,18 @@
+/*
+This package includes some basics for the Steam protocol. It defines basic interfaces that are used throughout go-steam:
+There is IMsg, which is extended by IClientMsg (sent after logging in) and abstracts over
+the outgoing message types. Both interfaces are implemented by ClientMsgProtobuf and ClientMsg.
+Msg is like ClientMsg, but it is used for sending messages before logging in.
+
+There is also the concept of a Packet: This is a type for incoming messages where only
+the header is deserialized. It therefore only contains EMsg data, job information and the remaining data.
+Its contents can then be read via the Read* methods which read data into a MessageBody - a type which is Serializable and
+has an EMsg.
+
+In addition, there are extra types for communication with the Game Coordinator (GC) included in the gamecoordinator sub-package.
+For outgoing messages the IGCMsg interface is used which is implemented by GCMsgProtobuf and GCMsg.
+Incoming messages are of the GCPacket type and are read like regular Packets.
+
+The actual messages and enums are in the sub-packages steamlang and protobuf, generated from the SteamKit data.
+*/
+package protocol

vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/msg.go

@@ -0,0 +1,132 @@
+package gamecoordinator
+
+import (
+	"io"
+
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	"github.com/golang/protobuf/proto"
+)
+
+// An outgoing message to the Game Coordinator.
+type IGCMsg interface {
+	Serializer
+	IsProto() bool
+	GetAppId() uint32
+	GetMsgType() uint32
+
+	GetTargetJobId() JobId
+	SetTargetJobId(JobId)
+	GetSourceJobId() JobId
+	SetSourceJobId(JobId)
+}
+
+type GCMsgProtobuf struct {
+	AppId  uint32
+	Header *MsgGCHdrProtoBuf
+	Body   proto.Message
+}
+
+func NewGCMsgProtobuf(appId, msgType uint32, body proto.Message) *GCMsgProtobuf {
+	hdr := NewMsgGCHdrProtoBuf()
+	hdr.Msg = msgType
+	return &GCMsgProtobuf{
+		AppId:  appId,
+		Header: hdr,
+		Body:   body,
+	}
+}
+
+func (g *GCMsgProtobuf) IsProto() bool {
+	return true
+}
+
+func (g *GCMsgProtobuf) GetAppId() uint32 {
+	return g.AppId
+}
+
+func (g *GCMsgProtobuf) GetMsgType() uint32 {
+	return g.Header.Msg
+}
+
+func (g *GCMsgProtobuf) GetTargetJobId() JobId {
+	return JobId(g.Header.Proto.GetJobidTarget())
+}
+
+func (g *GCMsgProtobuf) SetTargetJobId(job JobId) {
+	g.Header.Proto.JobidTarget = proto.Uint64(uint64(job))
+}
+
+func (g *GCMsgProtobuf) GetSourceJobId() JobId {
+	return JobId(g.Header.Proto.GetJobidSource())
+}
+
+func (g *GCMsgProtobuf) SetSourceJobId(job JobId) {
+	g.Header.Proto.JobidSource = proto.Uint64(uint64(job))
+}
+
+func (g *GCMsgProtobuf) Serialize(w io.Writer) error {
+	err := g.Header.Serialize(w)
+	if err != nil {
+		return err
+	}
+	body, err := proto.Marshal(g.Body)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(body)
+	return err
+}
+
+type GCMsg struct {
+	AppId   uint32
+	MsgType uint32
+	Header  *MsgGCHdr
+	Body    Serializer
+}
+
+func NewGCMsg(appId, msgType uint32, body Serializer) *GCMsg {
+	return &GCMsg{
+		AppId:   appId,
+		MsgType: msgType,
+		Header:  NewMsgGCHdr(),
+		Body:    body,
+	}
+}
+
+func (g *GCMsg) GetMsgType() uint32 {
+	return g.MsgType
+}
+
+func (g *GCMsg) GetAppId() uint32 {
+	return g.AppId
+}
+
+func (g *GCMsg) IsProto() bool {
+	return false
+}
+
+func (g *GCMsg) GetTargetJobId() JobId {
+	return JobId(g.Header.TargetJobID)
+}
+
+func (g *GCMsg) SetTargetJobId(job JobId) {
+	g.Header.TargetJobID = uint64(job)
+}
+
+func (g *GCMsg) GetSourceJobId() JobId {
+	return JobId(g.Header.SourceJobID)
+}
+
+func (g *GCMsg) SetSourceJobId(job JobId) {
+	g.Header.SourceJobID = uint64(job)
+}
+
+func (g *GCMsg) Serialize(w io.Writer) error {
+	err := g.Header.Serialize(w)
+	if err != nil {
+		return err
+	}
+	err = g.Body.Serialize(w)
+	return err
+}

vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/packet.go

@@ -0,0 +1,61 @@
+package gamecoordinator
+
+import (
+	"bytes"
+	. "github.com/Philipp15b/go-steam/protocol"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	"github.com/golang/protobuf/proto"
+)
+
+// An incoming, partially unread message from the Game Coordinator.
+type GCPacket struct {
+	AppId       uint32
+	MsgType     uint32
+	IsProto     bool
+	GCName      string
+	Body        []byte
+	TargetJobId JobId
+}
+
+func NewGCPacket(wrapper *CMsgGCClient) (*GCPacket, error) {
+	packet := &GCPacket{
+		AppId:   wrapper.GetAppid(),
+		MsgType: wrapper.GetMsgtype(),
+		GCName:  wrapper.GetGcname(),
+	}
+
+	r := bytes.NewReader(wrapper.GetPayload())
+	if IsProto(wrapper.GetMsgtype()) {
+		packet.MsgType = packet.MsgType & EMsgMask
+		packet.IsProto = true
+
+		header := NewMsgGCHdrProtoBuf()
+		err := header.Deserialize(r)
+		if err != nil {
+			return nil, err
+		}
+		packet.TargetJobId = JobId(header.Proto.GetJobidTarget())
+	} else {
+		header := NewMsgGCHdr()
+		err := header.Deserialize(r)
+		if err != nil {
+			return nil, err
+		}
+		packet.TargetJobId = JobId(header.TargetJobID)
+	}
+
+	body := make([]byte, r.Len())
+	r.Read(body)
+	packet.Body = body
+
+	return packet, nil
+}
+
+func (g *GCPacket) ReadProtoMsg(body proto.Message) {
+	proto.Unmarshal(g.Body, body)
+}
+
+func (g *GCPacket) ReadMsg(body MessageBody) {
+	body.Deserialize(bytes.NewReader(g.Body))
+}

vendor/github.com/Philipp15b/go-steam/protocol/internal.go

@@ -0,0 +1,47 @@
+package protocol
+
+import (
+	"io"
+	"math"
+	"strconv"
+
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+)
+
+type JobId uint64
+
+func (j JobId) String() string {
+	if j == math.MaxUint64 {
+		return "(none)"
+	}
+	return strconv.FormatUint(uint64(j), 10)
+}
+
+type Serializer interface {
+	Serialize(w io.Writer) error
+}
+
+type Deserializer interface {
+	Deserialize(r io.Reader) error
+}
+
+type Serializable interface {
+	Serializer
+	Deserializer
+}
+
+type MessageBody interface {
+	Serializable
+	GetEMsg() EMsg
+}
+
+// the default details to request in most situations
+const EClientPersonaStateFlag_DefaultInfoRequest = EClientPersonaStateFlag_PlayerName |
+	EClientPersonaStateFlag_Presence | EClientPersonaStateFlag_SourceID |
+	EClientPersonaStateFlag_GameExtraInfo
+
+const DefaultAvatar = "fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb"
+
+func ValidAvatar(avatar string) bool {
+	return !(avatar == "0000000000000000000000000000000000000000" || len(avatar) != 40)
+}

vendor/github.com/Philipp15b/go-steam/protocol/msg.go

@@ -0,0 +1,221 @@
+package protocol
+
+import (
+	"github.com/golang/protobuf/proto"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+	. "github.com/Philipp15b/go-steam/steamid"
+	"io"
+)
+
+// Interface for all messages, typically outgoing. They can also be created by
+// using the Read* methods in a PacketMsg.
+type IMsg interface {
+	Serializer
+	IsProto() bool
+	GetMsgType() EMsg
+	GetTargetJobId() JobId
+	SetTargetJobId(JobId)
+	GetSourceJobId() JobId
+	SetSourceJobId(JobId)
+}
+
+// Interface for client messages, i.e. messages that are sent after logging in.
+// ClientMsgProtobuf and ClientMsg implement this.
+type IClientMsg interface {
+	IMsg
+	GetSessionId() int32
+	SetSessionId(int32)
+	GetSteamId() SteamId
+	SetSteamId(SteamId)
+}
+
+// Represents a protobuf backed client message with session data.
+type ClientMsgProtobuf struct {
+	Header *MsgHdrProtoBuf
+	Body   proto.Message
+}
+
+func NewClientMsgProtobuf(eMsg EMsg, body proto.Message) *ClientMsgProtobuf {
+	hdr := NewMsgHdrProtoBuf()
+	hdr.Msg = eMsg
+	return &ClientMsgProtobuf{
+		Header: hdr,
+		Body:   body,
+	}
+}
+
+func (c *ClientMsgProtobuf) IsProto() bool {
+	return true
+}
+
+func (c *ClientMsgProtobuf) GetMsgType() EMsg {
+	return NewEMsg(uint32(c.Header.Msg))
+}
+
+func (c *ClientMsgProtobuf) GetSessionId() int32 {
+	return c.Header.Proto.GetClientSessionid()
+}
+
+func (c *ClientMsgProtobuf) SetSessionId(session int32) {
+	c.Header.Proto.ClientSessionid = &session
+}
+
+func (c *ClientMsgProtobuf) GetSteamId() SteamId {
+	return SteamId(c.Header.Proto.GetSteamid())
+}
+
+func (c *ClientMsgProtobuf) SetSteamId(s SteamId) {
+	c.Header.Proto.Steamid = proto.Uint64(uint64(s))
+}
+
+func (c *ClientMsgProtobuf) GetTargetJobId() JobId {
+	return JobId(c.Header.Proto.GetJobidTarget())
+}
+
+func (c *ClientMsgProtobuf) SetTargetJobId(job JobId) {
+	c.Header.Proto.JobidTarget = proto.Uint64(uint64(job))
+}
+
+func (c *ClientMsgProtobuf) GetSourceJobId() JobId {
+	return JobId(c.Header.Proto.GetJobidSource())
+}
+
+func (c *ClientMsgProtobuf) SetSourceJobId(job JobId) {
+	c.Header.Proto.JobidSource = proto.Uint64(uint64(job))
+}
+
+func (c *ClientMsgProtobuf) Serialize(w io.Writer) error {
+	err := c.Header.Serialize(w)
+	if err != nil {
+		return err
+	}
+	body, err := proto.Marshal(c.Body)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(body)
+	return err
+}
+
+// Represents a struct backed client message.
+type ClientMsg struct {
+	Header  *ExtendedClientMsgHdr
+	Body    MessageBody
+	Payload []byte
+}
+
+func NewClientMsg(body MessageBody, payload []byte) *ClientMsg {
+	hdr := NewExtendedClientMsgHdr()
+	hdr.Msg = body.GetEMsg()
+	return &ClientMsg{
+		Header:  hdr,
+		Body:    body,
+		Payload: payload,
+	}
+}
+
+func (c *ClientMsg) IsProto() bool {
+	return true
+}
+
+func (c *ClientMsg) GetMsgType() EMsg {
+	return c.Header.Msg
+}
+
+func (c *ClientMsg) GetSessionId() int32 {
+	return c.Header.SessionID
+}
+
+func (c *ClientMsg) SetSessionId(session int32) {
+	c.Header.SessionID = session
+}
+
+func (c *ClientMsg) GetSteamId() SteamId {
+	return c.Header.SteamID
+}
+
+func (c *ClientMsg) SetSteamId(s SteamId) {
+	c.Header.SteamID = s
+}
+
+func (c *ClientMsg) GetTargetJobId() JobId {
+	return JobId(c.Header.TargetJobID)
+}
+
+func (c *ClientMsg) SetTargetJobId(job JobId) {
+	c.Header.TargetJobID = uint64(job)
+}
+
+func (c *ClientMsg) GetSourceJobId() JobId {
+	return JobId(c.Header.SourceJobID)
+}
+
+func (c *ClientMsg) SetSourceJobId(job JobId) {
+	c.Header.SourceJobID = uint64(job)
+}
+
+func (c *ClientMsg) Serialize(w io.Writer) error {
+	err := c.Header.Serialize(w)
+	if err != nil {
+		return err
+	}
+	err = c.Body.Serialize(w)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(c.Payload)
+	return err
+}
+
+type Msg struct {
+	Header  *MsgHdr
+	Body    MessageBody
+	Payload []byte
+}
+
+func NewMsg(body MessageBody, payload []byte) *Msg {
+	hdr := NewMsgHdr()
+	hdr.Msg = body.GetEMsg()
+	return &Msg{
+		Header:  hdr,
+		Body:    body,
+		Payload: payload,
+	}
+}
+
+func (m *Msg) GetMsgType() EMsg {
+	return m.Header.Msg
+}
+
+func (m *Msg) IsProto() bool {
+	return false
+}
+
+func (m *Msg) GetTargetJobId() JobId {
+	return JobId(m.Header.TargetJobID)
+}
+
+func (m *Msg) SetTargetJobId(job JobId) {
+	m.Header.TargetJobID = uint64(job)
+}
+
+func (m *Msg) GetSourceJobId() JobId {
+	return JobId(m.Header.SourceJobID)
+}
+
+func (m *Msg) SetSourceJobId(job JobId) {
+	m.Header.SourceJobID = uint64(job)
+}
+
+func (m *Msg) Serialize(w io.Writer) error {
+	err := m.Header.Serialize(w)
+	if err != nil {
+		return err
+	}
+	err = m.Body.Serialize(w)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(m.Payload)
+	return err
+}

vendor/github.com/Philipp15b/go-steam/protocol/packet.go

@@ -0,0 +1,116 @@
+package protocol
+
+import (
+	"bytes"
+	"github.com/golang/protobuf/proto"
+	"encoding/binary"
+	"fmt"
+	. "github.com/Philipp15b/go-steam/protocol/steamlang"
+)
+
+// TODO: Headers are always deserialized twice.
+
+// Represents an incoming, partially unread message.
+type Packet struct {
+	EMsg        EMsg
+	IsProto     bool
+	TargetJobId JobId
+	SourceJobId JobId
+	Data        []byte
+}
+
+func NewPacket(data []byte) (*Packet, error) {
+	var rawEMsg uint32
+	err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &rawEMsg)
+	if err != nil {
+		return nil, err
+	}
+	eMsg := NewEMsg(rawEMsg)
+	buf := bytes.NewReader(data)
+	if eMsg == EMsg_ChannelEncryptRequest || eMsg == EMsg_ChannelEncryptResult {
+		header := NewMsgHdr()
+		header.Msg = eMsg
+		err = header.Deserialize(buf)
+		if err != nil {
+			return nil, err
+		}
+		return &Packet{
+			EMsg:        eMsg,
+			IsProto:     false,
+			TargetJobId: JobId(header.TargetJobID),
+			SourceJobId: JobId(header.SourceJobID),
+			Data:        data,
+		}, nil
+	} else if IsProto(rawEMsg) {
+		header := NewMsgHdrProtoBuf()
+		header.Msg = eMsg
+		err = header.Deserialize(buf)
+		if err != nil {
+			return nil, err
+		}
+		return &Packet{
+			EMsg:        eMsg,
+			IsProto:     true,
+			TargetJobId: JobId(header.Proto.GetJobidTarget()),
+			SourceJobId: JobId(header.Proto.GetJobidSource()),
+			Data:        data,
+		}, nil
+	} else {
+		header := NewExtendedClientMsgHdr()
+		header.Msg = eMsg
+		err = header.Deserialize(buf)
+		if err != nil {
+			return nil, err
+		}
+		return &Packet{
+			EMsg:        eMsg,
+			IsProto:     false,
+			TargetJobId: JobId(header.TargetJobID),
+			SourceJobId: JobId(header.SourceJobID),
+			Data:        data,
+		}, nil
+	}
+}
+
+func (p *Packet) String() string {
+	return fmt.Sprintf("Packet{EMsg = %v, Proto = %v, Len = %v, TargetJobId = %v, SourceJobId = %v}", p.EMsg, p.IsProto, len(p.Data), p.TargetJobId, p.SourceJobId)
+}
+
+func (p *Packet) ReadProtoMsg(body proto.Message) *ClientMsgProtobuf {
+	header := NewMsgHdrProtoBuf()
+	buf := bytes.NewBuffer(p.Data)
+	header.Deserialize(buf)
+	proto.Unmarshal(buf.Bytes(), body)
+	return &ClientMsgProtobuf{ // protobuf messages have no payload
+		Header: header,
+		Body:   body,
+	}
+}
+
+func (p *Packet) ReadClientMsg(body MessageBody) *ClientMsg {
+	header := NewExtendedClientMsgHdr()
+	buf := bytes.NewReader(p.Data)
+	header.Deserialize(buf)
+	body.Deserialize(buf)
+	payload := make([]byte, buf.Len())
+	buf.Read(payload)
+	return &ClientMsg{
+		Header:  header,
+		Body:    body,
+		Payload: payload,
+	}
+}
+
+func (p *Packet) ReadMsg(body MessageBody) *Msg {
+	header := NewMsgHdr()
+	buf := bytes.NewReader(p.Data)
+	header.Deserialize(buf)
+	body.Deserialize(buf)
+	payload := make([]byte, buf.Len())
+	buf.Read(payload)
+	return &Msg{
+		Header:  header,
+		Body:    body,
+		Payload: payload,
+	}
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/app_ticket.pb.go

@@ -0,0 +1,82 @@
+// Code generated by protoc-gen-go.
+// source: encrypted_app_ticket.proto
+// DO NOT EDIT!
+
+package protobuf
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type EncryptedAppTicket struct {
+	TicketVersionNo               *uint32 `protobuf:"varint,1,opt,name=ticket_version_no" json:"ticket_version_no,omitempty"`
+	CrcEncryptedticket            *uint32 `protobuf:"varint,2,opt,name=crc_encryptedticket" json:"crc_encryptedticket,omitempty"`
+	CbEncrypteduserdata           *uint32 `protobuf:"varint,3,opt,name=cb_encrypteduserdata" json:"cb_encrypteduserdata,omitempty"`
+	CbEncryptedAppownershipticket *uint32 `protobuf:"varint,4,opt,name=cb_encrypted_appownershipticket" json:"cb_encrypted_appownershipticket,omitempty"`
+	EncryptedTicket               []byte  `protobuf:"bytes,5,opt,name=encrypted_ticket" json:"encrypted_ticket,omitempty"`
+	XXX_unrecognized              []byte  `json:"-"`
+}
+
+func (m *EncryptedAppTicket) Reset()                    { *m = EncryptedAppTicket{} }
+func (m *EncryptedAppTicket) String() string            { return proto.CompactTextString(m) }
+func (*EncryptedAppTicket) ProtoMessage()               {}
+func (*EncryptedAppTicket) Descriptor() ([]byte, []int) { return app_ticket_fileDescriptor0, []int{0} }
+
+func (m *EncryptedAppTicket) GetTicketVersionNo() uint32 {
+	if m != nil && m.TicketVersionNo != nil {
+		return *m.TicketVersionNo
+	}
+	return 0
+}
+
+func (m *EncryptedAppTicket) GetCrcEncryptedticket() uint32 {
+	if m != nil && m.CrcEncryptedticket != nil {
+		return *m.CrcEncryptedticket
+	}
+	return 0
+}
+
+func (m *EncryptedAppTicket) GetCbEncrypteduserdata() uint32 {
+	if m != nil && m.CbEncrypteduserdata != nil {
+		return *m.CbEncrypteduserdata
+	}
+	return 0
+}
+
+func (m *EncryptedAppTicket) GetCbEncryptedAppownershipticket() uint32 {
+	if m != nil && m.CbEncryptedAppownershipticket != nil {
+		return *m.CbEncryptedAppownershipticket
+	}
+	return 0
+}
+
+func (m *EncryptedAppTicket) GetEncryptedTicket() []byte {
+	if m != nil {
+		return m.EncryptedTicket
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*EncryptedAppTicket)(nil), "EncryptedAppTicket")
+}
+
+var app_ticket_fileDescriptor0 = []byte{
+	// 162 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xcd, 0x4b, 0x2e,
+	0xaa, 0x2c, 0x28, 0x49, 0x4d, 0x89, 0x4f, 0x2c, 0x28, 0x88, 0x2f, 0xc9, 0x4c, 0xce, 0x4e, 0x2d,
+	0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x5a, 0xcb, 0xc8, 0x25, 0xe4, 0x0a, 0x93, 0x76, 0x2c,
+	0x28, 0x08, 0x01, 0x4b, 0x0a, 0x49, 0x72, 0x09, 0x42, 0x94, 0xc5, 0x97, 0xa5, 0x16, 0x15, 0x67,
+	0xe6, 0xe7, 0xc5, 0xe7, 0xe5, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x0a, 0x49, 0x73, 0x09, 0x27,
+	0x17, 0x25, 0xc7, 0xc3, 0xcd, 0x84, 0xa8, 0x93, 0x60, 0x02, 0x4b, 0xca, 0x70, 0x89, 0x24, 0x27,
+	0x21, 0xe4, 0x4a, 0x8b, 0x53, 0x8b, 0x52, 0x12, 0x4b, 0x12, 0x25, 0x98, 0xc1, 0xb2, 0xea, 0x5c,
+	0xf2, 0xc8, 0xb2, 0x20, 0xd7, 0xe4, 0x97, 0xe7, 0x01, 0x2d, 0xc8, 0xc8, 0x2c, 0x80, 0x1a, 0xc3,
+	0x02, 0x56, 0x28, 0xc1, 0x25, 0x80, 0x50, 0x05, 0x95, 0x61, 0x05, 0xca, 0xf0, 0x38, 0xb1, 0x7a,
+	0x30, 0x36, 0x30, 0x32, 0x00, 0x02, 0x00, 0x00, 0xff, 0xff, 0x03, 0x8c, 0xdb, 0x92, 0xd3, 0x00,
+	0x00, 0x00,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/base.pb.go

@@ -0,0 +1,613 @@
+// Code generated by protoc-gen-go.
+// source: steammessages_base.proto
+// DO NOT EDIT!
+
+package protobuf
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type CMsgProtoBufHeader struct {
+	Steamid           *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
+	ClientSessionid   *int32  `protobuf:"varint,2,opt,name=client_sessionid" json:"client_sessionid,omitempty"`
+	RoutingAppid      *uint32 `protobuf:"varint,3,opt,name=routing_appid" json:"routing_appid,omitempty"`
+	JobidSource       *uint64 `protobuf:"fixed64,10,opt,name=jobid_source,def=18446744073709551615" json:"jobid_source,omitempty"`
+	JobidTarget       *uint64 `protobuf:"fixed64,11,opt,name=jobid_target,def=18446744073709551615" json:"jobid_target,omitempty"`
+	TargetJobName     *string `protobuf:"bytes,12,opt,name=target_job_name" json:"target_job_name,omitempty"`
+	SeqNum            *int32  `protobuf:"varint,24,opt,name=seq_num" json:"seq_num,omitempty"`
+	Eresult           *int32  `protobuf:"varint,13,opt,name=eresult,def=2" json:"eresult,omitempty"`
+	ErrorMessage      *string `protobuf:"bytes,14,opt,name=error_message" json:"error_message,omitempty"`
+	Ip                *uint32 `protobuf:"varint,15,opt,name=ip" json:"ip,omitempty"`
+	AuthAccountFlags  *uint32 `protobuf:"varint,16,opt,name=auth_account_flags" json:"auth_account_flags,omitempty"`
+	TokenSource       *uint32 `protobuf:"varint,22,opt,name=token_source" json:"token_source,omitempty"`
+	AdminSpoofingUser *bool   `protobuf:"varint,23,opt,name=admin_spoofing_user" json:"admin_spoofing_user,omitempty"`
+	TransportError    *int32  `protobuf:"varint,17,opt,name=transport_error,def=1" json:"transport_error,omitempty"`
+	Messageid         *uint64 `protobuf:"varint,18,opt,name=messageid,def=18446744073709551615" json:"messageid,omitempty"`
+	PublisherGroupId  *uint32 `protobuf:"varint,19,opt,name=publisher_group_id" json:"publisher_group_id,omitempty"`
+	Sysid             *uint32 `protobuf:"varint,20,opt,name=sysid" json:"sysid,omitempty"`
+	TraceTag          *uint64 `protobuf:"varint,21,opt,name=trace_tag" json:"trace_tag,omitempty"`
+	WebapiKeyId       *uint32 `protobuf:"varint,25,opt,name=webapi_key_id" json:"webapi_key_id,omitempty"`
+	XXX_unrecognized  []byte  `json:"-"`
+}
+
+func (m *CMsgProtoBufHeader) Reset()                    { *m = CMsgProtoBufHeader{} }
+func (m *CMsgProtoBufHeader) String() string            { return proto.CompactTextString(m) }
+func (*CMsgProtoBufHeader) ProtoMessage()               {}
+func (*CMsgProtoBufHeader) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} }
+
+const Default_CMsgProtoBufHeader_JobidSource uint64 = 18446744073709551615
+const Default_CMsgProtoBufHeader_JobidTarget uint64 = 18446744073709551615
+const Default_CMsgProtoBufHeader_Eresult int32 = 2
+const Default_CMsgProtoBufHeader_TransportError int32 = 1
+const Default_CMsgProtoBufHeader_Messageid uint64 = 18446744073709551615
+
+func (m *CMsgProtoBufHeader) GetSteamid() uint64 {
+	if m != nil && m.Steamid != nil {
+		return *m.Steamid
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetClientSessionid() int32 {
+	if m != nil && m.ClientSessionid != nil {
+		return *m.ClientSessionid
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetRoutingAppid() uint32 {
+	if m != nil && m.RoutingAppid != nil {
+		return *m.RoutingAppid
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetJobidSource() uint64 {
+	if m != nil && m.JobidSource != nil {
+		return *m.JobidSource
+	}
+	return Default_CMsgProtoBufHeader_JobidSource
+}
+
+func (m *CMsgProtoBufHeader) GetJobidTarget() uint64 {
+	if m != nil && m.JobidTarget != nil {
+		return *m.JobidTarget
+	}
+	return Default_CMsgProtoBufHeader_JobidTarget
+}
+
+func (m *CMsgProtoBufHeader) GetTargetJobName() string {
+	if m != nil && m.TargetJobName != nil {
+		return *m.TargetJobName
+	}
+	return ""
+}
+
+func (m *CMsgProtoBufHeader) GetSeqNum() int32 {
+	if m != nil && m.SeqNum != nil {
+		return *m.SeqNum
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetEresult() int32 {
+	if m != nil && m.Eresult != nil {
+		return *m.Eresult
+	}
+	return Default_CMsgProtoBufHeader_Eresult
+}
+
+func (m *CMsgProtoBufHeader) GetErrorMessage() string {
+	if m != nil && m.ErrorMessage != nil {
+		return *m.ErrorMessage
+	}
+	return ""
+}
+
+func (m *CMsgProtoBufHeader) GetIp() uint32 {
+	if m != nil && m.Ip != nil {
+		return *m.Ip
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetAuthAccountFlags() uint32 {
+	if m != nil && m.AuthAccountFlags != nil {
+		return *m.AuthAccountFlags
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetTokenSource() uint32 {
+	if m != nil && m.TokenSource != nil {
+		return *m.TokenSource
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetAdminSpoofingUser() bool {
+	if m != nil && m.AdminSpoofingUser != nil {
+		return *m.AdminSpoofingUser
+	}
+	return false
+}
+
+func (m *CMsgProtoBufHeader) GetTransportError() int32 {
+	if m != nil && m.TransportError != nil {
+		return *m.TransportError
+	}
+	return Default_CMsgProtoBufHeader_TransportError
+}
+
+func (m *CMsgProtoBufHeader) GetMessageid() uint64 {
+	if m != nil && m.Messageid != nil {
+		return *m.Messageid
+	}
+	return Default_CMsgProtoBufHeader_Messageid
+}
+
+func (m *CMsgProtoBufHeader) GetPublisherGroupId() uint32 {
+	if m != nil && m.PublisherGroupId != nil {
+		return *m.PublisherGroupId
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetSysid() uint32 {
+	if m != nil && m.Sysid != nil {
+		return *m.Sysid
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetTraceTag() uint64 {
+	if m != nil && m.TraceTag != nil {
+		return *m.TraceTag
+	}
+	return 0
+}
+
+func (m *CMsgProtoBufHeader) GetWebapiKeyId() uint32 {
+	if m != nil && m.WebapiKeyId != nil {
+		return *m.WebapiKeyId
+	}
+	return 0
+}
+
+type CMsgMulti struct {
+	SizeUnzipped     *uint32 `protobuf:"varint,1,opt,name=size_unzipped" json:"size_unzipped,omitempty"`
+	MessageBody      []byte  `protobuf:"bytes,2,opt,name=message_body" json:"message_body,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *CMsgMulti) Reset()                    { *m = CMsgMulti{} }
+func (m *CMsgMulti) String() string            { return proto.CompactTextString(m) }
+func (*CMsgMulti) ProtoMessage()               {}
+func (*CMsgMulti) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{1} }
+
+func (m *CMsgMulti) GetSizeUnzipped() uint32 {
+	if m != nil && m.SizeUnzipped != nil {
+		return *m.SizeUnzipped
+	}
+	return 0
+}
+
+func (m *CMsgMulti) GetMessageBody() []byte {
+	if m != nil {
+		return m.MessageBody
+	}
+	return nil
+}
+
+type CMsgProtobufWrapped struct {
+	MessageBody      []byte `protobuf:"bytes,1,opt,name=message_body" json:"message_body,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *CMsgProtobufWrapped) Reset()                    { *m = CMsgProtobufWrapped{} }
+func (m *CMsgProtobufWrapped) String() string            { return proto.CompactTextString(m) }
+func (*CMsgProtobufWrapped) ProtoMessage()               {}
+func (*CMsgProtobufWrapped) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{2} }
+
+func (m *CMsgProtobufWrapped) GetMessageBody() []byte {
+	if m != nil {
+		return m.MessageBody
+	}
+	return nil
+}
+
+type CMsgAuthTicket struct {
+	Estate           *uint32 `protobuf:"varint,1,opt,name=estate" json:"estate,omitempty"`
+	Eresult          *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"`
+	Steamid          *uint64 `protobuf:"fixed64,3,opt,name=steamid" json:"steamid,omitempty"`
+	Gameid           *uint64 `protobuf:"fixed64,4,opt,name=gameid" json:"gameid,omitempty"`
+	HSteamPipe       *uint32 `protobuf:"varint,5,opt,name=h_steam_pipe" json:"h_steam_pipe,omitempty"`
+	TicketCrc        *uint32 `protobuf:"varint,6,opt,name=ticket_crc" json:"ticket_crc,omitempty"`
+	Ticket           []byte  `protobuf:"bytes,7,opt,name=ticket" json:"ticket,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *CMsgAuthTicket) Reset()                    { *m = CMsgAuthTicket{} }
+func (m *CMsgAuthTicket) String() string            { return proto.CompactTextString(m) }
+func (*CMsgAuthTicket) ProtoMessage()               {}
+func (*CMsgAuthTicket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{3} }
+
+const Default_CMsgAuthTicket_Eresult uint32 = 2
+
+func (m *CMsgAuthTicket) GetEstate() uint32 {
+	if m != nil && m.Estate != nil {
+		return *m.Estate
+	}
+	return 0
+}
+
+func (m *CMsgAuthTicket) GetEresult() uint32 {
+	if m != nil && m.Eresult != nil {
+		return *m.Eresult
+	}
+	return Default_CMsgAuthTicket_Eresult
+}
+
+func (m *CMsgAuthTicket) GetSteamid() uint64 {
+	if m != nil && m.Steamid != nil {
+		return *m.Steamid
+	}
+	return 0
+}
+
+func (m *CMsgAuthTicket) GetGameid() uint64 {
+	if m != nil && m.Gameid != nil {
+		return *m.Gameid
+	}
+	return 0
+}
+
+func (m *CMsgAuthTicket) GetHSteamPipe() uint32 {
+	if m != nil && m.HSteamPipe != nil {
+		return *m.HSteamPipe
+	}
+	return 0
+}
+
+func (m *CMsgAuthTicket) GetTicketCrc() uint32 {
+	if m != nil && m.TicketCrc != nil {
+		return *m.TicketCrc
+	}
+	return 0
+}
+
+func (m *CMsgAuthTicket) GetTicket() []byte {
+	if m != nil {
+		return m.Ticket
+	}
+	return nil
+}
+
+type CCDDBAppDetailCommon struct {
+	Appid                 *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
+	Name                  *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+	Icon                  *string `protobuf:"bytes,3,opt,name=icon" json:"icon,omitempty"`
+	Logo                  *string `protobuf:"bytes,4,opt,name=logo" json:"logo,omitempty"`
+	LogoSmall             *string `protobuf:"bytes,5,opt,name=logo_small" json:"logo_small,omitempty"`
+	Tool                  *bool   `protobuf:"varint,6,opt,name=tool" json:"tool,omitempty"`
+	Demo                  *bool   `protobuf:"varint,7,opt,name=demo" json:"demo,omitempty"`
+	Media                 *bool   `protobuf:"varint,8,opt,name=media" json:"media,omitempty"`
+	CommunityVisibleStats *bool   `protobuf:"varint,9,opt,name=community_visible_stats" json:"community_visible_stats,omitempty"`
+	FriendlyName          *string `protobuf:"bytes,10,opt,name=friendly_name" json:"friendly_name,omitempty"`
+	Propagation           *string `protobuf:"bytes,11,opt,name=propagation" json:"propagation,omitempty"`
+	HasAdultContent       *bool   `protobuf:"varint,12,opt,name=has_adult_content" json:"has_adult_content,omitempty"`
+	XXX_unrecognized      []byte  `json:"-"`
+}
+
+func (m *CCDDBAppDetailCommon) Reset()                    { *m = CCDDBAppDetailCommon{} }
+func (m *CCDDBAppDetailCommon) String() string            { return proto.CompactTextString(m) }
+func (*CCDDBAppDetailCommon) ProtoMessage()               {}
+func (*CCDDBAppDetailCommon) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{4} }
+
+func (m *CCDDBAppDetailCommon) GetAppid() uint32 {
+	if m != nil && m.Appid != nil {
+		return *m.Appid
+	}
+	return 0
+}
+
+func (m *CCDDBAppDetailCommon) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetIcon() string {
+	if m != nil && m.Icon != nil {
+		return *m.Icon
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetLogo() string {
+	if m != nil && m.Logo != nil {
+		return *m.Logo
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetLogoSmall() string {
+	if m != nil && m.LogoSmall != nil {
+		return *m.LogoSmall
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetTool() bool {
+	if m != nil && m.Tool != nil {
+		return *m.Tool
+	}
+	return false
+}
+
+func (m *CCDDBAppDetailCommon) GetDemo() bool {
+	if m != nil && m.Demo != nil {
+		return *m.Demo
+	}
+	return false
+}
+
+func (m *CCDDBAppDetailCommon) GetMedia() bool {
+	if m != nil && m.Media != nil {
+		return *m.Media
+	}
+	return false
+}
+
+func (m *CCDDBAppDetailCommon) GetCommunityVisibleStats() bool {
+	if m != nil && m.CommunityVisibleStats != nil {
+		return *m.CommunityVisibleStats
+	}
+	return false
+}
+
+func (m *CCDDBAppDetailCommon) GetFriendlyName() string {
+	if m != nil && m.FriendlyName != nil {
+		return *m.FriendlyName
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetPropagation() string {
+	if m != nil && m.Propagation != nil {
+		return *m.Propagation
+	}
+	return ""
+}
+
+func (m *CCDDBAppDetailCommon) GetHasAdultContent() bool {
+	if m != nil && m.HasAdultContent != nil {
+		return *m.HasAdultContent
+	}
+	return false
+}
+
+type CMsgAppRights struct {
+	EditInfo                 *bool  `protobuf:"varint,1,opt,name=edit_info" json:"edit_info,omitempty"`
+	Publish                  *bool  `protobuf:"varint,2,opt,name=publish" json:"publish,omitempty"`
+	ViewErrorData            *bool  `protobuf:"varint,3,opt,name=view_error_data" json:"view_error_data,omitempty"`
+	Download                 *bool  `protobuf:"varint,4,opt,name=download" json:"download,omitempty"`
+	UploadCdkeys             *bool  `protobuf:"varint,5,opt,name=upload_cdkeys" json:"upload_cdkeys,omitempty"`
+	GenerateCdkeys           *bool  `protobuf:"varint,6,opt,name=generate_cdkeys" json:"generate_cdkeys,omitempty"`
+	ViewFinancials           *bool  `protobuf:"varint,7,opt,name=view_financials" json:"view_financials,omitempty"`
+	ManageCeg                *bool  `protobuf:"varint,8,opt,name=manage_ceg" json:"manage_ceg,omitempty"`
+	ManageSigning            *bool  `protobuf:"varint,9,opt,name=manage_signing" json:"manage_signing,omitempty"`
+	ManageCdkeys             *bool  `protobuf:"varint,10,opt,name=manage_cdkeys" json:"manage_cdkeys,omitempty"`
+	EditMarketing            *bool  `protobuf:"varint,11,opt,name=edit_marketing" json:"edit_marketing,omitempty"`
+	EconomySupport           *bool  `protobuf:"varint,12,opt,name=economy_support" json:"economy_support,omitempty"`
+	EconomySupportSupervisor *bool  `protobuf:"varint,13,opt,name=economy_support_supervisor" json:"economy_support_supervisor,omitempty"`
+	ManagePricing            *bool  `protobuf:"varint,14,opt,name=manage_pricing" json:"manage_pricing,omitempty"`
+	BroadcastLive            *bool  `protobuf:"varint,15,opt,name=broadcast_live" json:"broadcast_live,omitempty"`
+	XXX_unrecognized         []byte `json:"-"`
+}
+
+func (m *CMsgAppRights) Reset()                    { *m = CMsgAppRights{} }
+func (m *CMsgAppRights) String() string            { return proto.CompactTextString(m) }
+func (*CMsgAppRights) ProtoMessage()               {}
+func (*CMsgAppRights) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{5} }
+
+func (m *CMsgAppRights) GetEditInfo() bool {
+	if m != nil && m.EditInfo != nil {
+		return *m.EditInfo
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetPublish() bool {
+	if m != nil && m.Publish != nil {
+		return *m.Publish
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetViewErrorData() bool {
+	if m != nil && m.ViewErrorData != nil {
+		return *m.ViewErrorData
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetDownload() bool {
+	if m != nil && m.Download != nil {
+		return *m.Download
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetUploadCdkeys() bool {
+	if m != nil && m.UploadCdkeys != nil {
+		return *m.UploadCdkeys
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetGenerateCdkeys() bool {
+	if m != nil && m.GenerateCdkeys != nil {
+		return *m.GenerateCdkeys
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetViewFinancials() bool {
+	if m != nil && m.ViewFinancials != nil {
+		return *m.ViewFinancials
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetManageCeg() bool {
+	if m != nil && m.ManageCeg != nil {
+		return *m.ManageCeg
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetManageSigning() bool {
+	if m != nil && m.ManageSigning != nil {
+		return *m.ManageSigning
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetManageCdkeys() bool {
+	if m != nil && m.ManageCdkeys != nil {
+		return *m.ManageCdkeys
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetEditMarketing() bool {
+	if m != nil && m.EditMarketing != nil {
+		return *m.EditMarketing
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetEconomySupport() bool {
+	if m != nil && m.EconomySupport != nil {
+		return *m.EconomySupport
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetEconomySupportSupervisor() bool {
+	if m != nil && m.EconomySupportSupervisor != nil {
+		return *m.EconomySupportSupervisor
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetManagePricing() bool {
+	if m != nil && m.ManagePricing != nil {
+		return *m.ManagePricing
+	}
+	return false
+}
+
+func (m *CMsgAppRights) GetBroadcastLive() bool {
+	if m != nil && m.BroadcastLive != nil {
+		return *m.BroadcastLive
+	}
+	return false
+}
+
+var E_MsgpoolSoftLimit = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.MessageOptions)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         50000,
+	Name:          "msgpool_soft_limit",
+	Tag:           "varint,50000,opt,name=msgpool_soft_limit,def=32",
+}
+
+var E_MsgpoolHardLimit = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.MessageOptions)(nil),
+	ExtensionType: (*int32)(nil),
+	Field:         50001,
+	Name:          "msgpool_hard_limit",
+	Tag:           "varint,50001,opt,name=msgpool_hard_limit,def=384",
+}
+
+func init() {
+	proto.RegisterType((*CMsgProtoBufHeader)(nil), "CMsgProtoBufHeader")
+	proto.RegisterType((*CMsgMulti)(nil), "CMsgMulti")
+	proto.RegisterType((*CMsgProtobufWrapped)(nil), "CMsgProtobufWrapped")
+	proto.RegisterType((*CMsgAuthTicket)(nil), "CMsgAuthTicket")
+	proto.RegisterType((*CCDDBAppDetailCommon)(nil), "CCDDBAppDetailCommon")
+	proto.RegisterType((*CMsgAppRights)(nil), "CMsgAppRights")
+	proto.RegisterExtension(E_MsgpoolSoftLimit)
+	proto.RegisterExtension(E_MsgpoolHardLimit)
+}
+
+var base_fileDescriptor0 = []byte{
+	// 906 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x6f, 0x1c, 0x45,
+	0x10, 0x65, 0x77, 0xfd, 0x31, 0xdb, 0xde, 0x5d, 0xdb, 0x63, 0x27, 0xee, 0x98, 0x43, 0xa2, 0xbd,
+	0x80, 0x40, 0x72, 0xe2, 0x78, 0x1d, 0x1b, 0xdf, 0xfc, 0x71, 0xc8, 0xc5, 0x02, 0x21, 0x24, 0x8e,
+	0xad, 0x9e, 0x99, 0xda, 0xd9, 0xc6, 0x33, 0xdd, 0x4d, 0x77, 0x8f, 0xad, 0xcd, 0x89, 0x13, 0x57,
+	0xfe, 0x1a, 0xfc, 0x12, 0x6e, 0x88, 0x23, 0xd5, 0x35, 0xb3, 0x38, 0x04, 0x81, 0x72, 0x1a, 0x55,
+	0xd5, 0xeb, 0xaa, 0x57, 0xaf, 0xaa, 0x86, 0x71, 0x1f, 0x40, 0xd6, 0x35, 0x78, 0x2f, 0x4b, 0xf0,
+	0x22, 0x93, 0x1e, 0x8e, 0xac, 0x33, 0xc1, 0x1c, 0xbe, 0x28, 0x8d, 0x29, 0x2b, 0x78, 0x49, 0x56,
+	0xd6, 0xcc, 0x5f, 0x16, 0xe0, 0x73, 0xa7, 0x6c, 0x30, 0xae, 0x45, 0x4c, 0xff, 0x1c, 0xb0, 0xf4,
+	0xfa, 0xd6, 0x97, 0xdf, 0x44, 0xeb, 0xaa, 0x99, 0xbf, 0x05, 0x59, 0x80, 0x4b, 0xb7, 0xd9, 0x26,
+	0x25, 0x55, 0x05, 0xef, 0xbd, 0xe8, 0x7d, 0xbe, 0x91, 0x72, 0xb6, 0x93, 0x57, 0x0a, 0x74, 0x10,
+	0x1e, 0xeb, 0x28, 0xa3, 0x31, 0xd2, 0xc7, 0xc8, 0x7a, 0xfa, 0x84, 0x8d, 0x9d, 0x69, 0x82, 0xd2,
+	0xa5, 0x90, 0xd6, 0xa2, 0x7b, 0x80, 0xee, 0x71, 0xfa, 0x05, 0x1b, 0xfd, 0x60, 0x32, 0x55, 0x08,
+	0x6f, 0x1a, 0x97, 0x03, 0x67, 0x31, 0xcd, 0xc5, 0xfe, 0xf1, 0xf9, 0x6c, 0xf6, 0xe6, 0x6c, 0x36,
+	0x7b, 0x75, 0x76, 0x72, 0xf6, 0xea, 0xab, 0xd3, 0xd3, 0xe3, 0x37, 0xc7, 0xa7, 0x8f, 0xd8, 0x20,
+	0x5d, 0x09, 0x81, 0x6f, 0xfd, 0x0f, 0xf6, 0x80, 0x6d, 0xb7, 0x28, 0x81, 0x4f, 0x84, 0x96, 0x35,
+	0xf0, 0x11, 0xc2, 0x87, 0x44, 0x19, 0x7e, 0x14, 0xba, 0xa9, 0x39, 0x27, 0x62, 0x29, 0xdb, 0x04,
+	0x07, 0xbe, 0xa9, 0x02, 0x1f, 0x47, 0xc7, 0x45, 0xef, 0x75, 0x24, 0x0b, 0xce, 0x19, 0x27, 0x3a,
+	0xb5, 0xf8, 0x84, 0xde, 0x32, 0xd6, 0x57, 0x96, 0x6f, 0x13, 0xf1, 0x43, 0x96, 0xca, 0x26, 0x2c,
+	0x84, 0xcc, 0x73, 0xd3, 0x60, 0xbf, 0xf3, 0x4a, 0x96, 0x9e, 0xef, 0x50, 0x6c, 0x9f, 0x8d, 0x82,
+	0xb9, 0x03, 0xbd, 0x6a, 0xea, 0x29, 0x79, 0x3f, 0x65, 0x7b, 0xb2, 0xa8, 0x15, 0x7a, 0xad, 0x31,
+	0xf3, 0x28, 0x44, 0xe3, 0xc1, 0xf1, 0x03, 0x0c, 0x26, 0x98, 0x6e, 0x3b, 0x38, 0xa9, 0x31, 0xe4,
+	0x82, 0xa0, 0xda, 0x7c, 0xb7, 0x65, 0x73, 0x9c, 0x7e, 0xc6, 0x86, 0x1d, 0x0f, 0x94, 0x2d, 0x45,
+	0xef, 0xda, 0x7f, 0x34, 0x8d, 0x9c, 0x6c, 0x93, 0x55, 0xca, 0x2f, 0xc0, 0x89, 0x12, 0xe5, 0xb6,
+	0x02, 0x5f, 0xec, 0x51, 0xf5, 0x31, 0x5b, 0xf7, 0x4b, 0x8f, 0xe6, 0x3e, 0x99, 0xbb, 0x6c, 0x88,
+	0xf5, 0x72, 0x40, 0x2d, 0x4b, 0xfe, 0x24, 0xe6, 0x8c, 0x4d, 0x3f, 0x40, 0x26, 0xad, 0x12, 0x77,
+	0xb0, 0x8c, 0x0f, 0x9f, 0x45, 0xe4, 0xf4, 0x9c, 0x0d, 0xe3, 0xe4, 0x6f, 0x51, 0x20, 0x15, 0x31,
+	0x5e, 0xbd, 0x03, 0xd1, 0xe8, 0x77, 0xca, 0x5a, 0x68, 0xc7, 0x4e, 0x0d, 0x77, 0x0c, 0x45, 0x66,
+	0x8a, 0x25, 0x8d, 0x7c, 0x34, 0xfd, 0x92, 0xed, 0xfd, 0xbd, 0x33, 0xb8, 0x55, 0xdf, 0x3b, 0x19,
+	0x9f, 0xfc, 0x0b, 0xdc, 0x23, 0xf0, 0x2f, 0x3d, 0x36, 0x89, 0xe8, 0x4b, 0x14, 0xf5, 0x3b, 0x95,
+	0xdf, 0x41, 0x48, 0x27, 0x6c, 0x03, 0x7c, 0x90, 0x01, 0xba, 0x2a, 0xef, 0x4d, 0x2a, 0x16, 0x18,
+	0xc7, 0x49, 0xbd, 0xb7, 0x81, 0x03, 0xda, 0x40, 0x7c, 0x54, 0xe2, 0xb4, 0xd1, 0x5e, 0x23, 0x1b,
+	0xab, 0x2d, 0x04, 0x41, 0x84, 0x55, 0x16, 0xf8, 0x7a, 0x97, 0x8a, 0x05, 0x2a, 0x22, 0x72, 0x97,
+	0xf3, 0x0d, 0xf2, 0xe1, 0xcb, 0xd6, 0xc7, 0x37, 0x89, 0xd1, 0x1f, 0x3d, 0xb6, 0x7f, 0x7d, 0x7d,
+	0x73, 0x73, 0x75, 0x69, 0xed, 0x0d, 0x04, 0xa9, 0xaa, 0x6b, 0x53, 0xd7, 0x46, 0x47, 0x29, 0xdb,
+	0x15, 0x6e, 0x69, 0x8d, 0xd8, 0x1a, 0xed, 0x57, 0x9f, 0x76, 0x04, 0x2d, 0x95, 0x1b, 0x4d, 0x6c,
+	0xc8, 0xaa, 0x4c, 0x69, 0x88, 0xcb, 0x30, 0x56, 0x8d, 0x96, 0xf0, 0xb5, 0xac, 0x2a, 0x62, 0x42,
+	0x88, 0x60, 0x4c, 0x45, 0x1c, 0x92, 0x68, 0x15, 0x50, 0x1b, 0x62, 0x90, 0xc4, 0x42, 0x35, 0x14,
+	0x4a, 0xf2, 0x84, 0xcc, 0xe7, 0xec, 0x20, 0x47, 0x06, 0x8d, 0x56, 0x61, 0x29, 0xee, 0x95, 0x57,
+	0x59, 0x05, 0x22, 0x0a, 0xe4, 0xf9, 0x90, 0x00, 0x38, 0x9d, 0xb9, 0xc3, 0xeb, 0x2b, 0xaa, 0x65,
+	0xbb, 0xf2, 0x8c, 0x4a, 0xec, 0xb1, 0x2d, 0xbc, 0x62, 0x2b, 0x4b, 0x19, 0xf0, 0x22, 0xe9, 0x6c,
+	0x86, 0xe9, 0x33, 0xb6, 0xbb, 0x90, 0x5e, 0xc8, 0x02, 0xe5, 0x14, 0x48, 0x38, 0xe0, 0xd1, 0xd2,
+	0x89, 0x24, 0xd3, 0xdf, 0xfb, 0x6c, 0x4c, 0xa3, 0xb0, 0xf6, 0x5b, 0x55, 0x2e, 0x82, 0x8f, 0xdb,
+	0x82, 0x3c, 0x82, 0x50, 0x7a, 0x6e, 0xa8, 0xeb, 0x24, 0x0a, 0xdf, 0xed, 0x1a, 0x35, 0x9e, 0xc4,
+	0x8b, 0xbb, 0x57, 0xf0, 0xd0, 0x2e, 0xaf, 0x28, 0x64, 0x90, 0xa4, 0x41, 0x92, 0xee, 0xb0, 0xa4,
+	0x30, 0x0f, 0xba, 0x32, 0xb2, 0x9d, 0x09, 0xf1, 0x6c, 0x6c, 0xb4, 0x45, 0x5e, 0xe0, 0xae, 0x79,
+	0x92, 0x82, 0x32, 0x94, 0xa0, 0xc1, 0xe1, 0xc4, 0x57, 0x81, 0x8d, 0x7f, 0xa4, 0xc6, 0xa3, 0x91,
+	0x3a, 0x57, 0xb2, 0xf2, 0x9d, 0x40, 0x28, 0x68, 0x2d, 0x75, 0xdc, 0xa4, 0x1c, 0xca, 0x4e, 0xa5,
+	0xa7, 0x6c, 0xd2, 0xf9, 0xbc, 0x2a, 0x35, 0x9e, 0xd9, 0xa3, 0x38, 0x2b, 0x6c, 0x9b, 0x9b, 0xad,
+	0xe0, 0xd4, 0x5a, 0x2d, 0x1d, 0x8e, 0x3e, 0xc2, 0xb7, 0x56, 0x35, 0x01, 0x65, 0x31, 0xf5, 0x52,
+	0xf8, 0xc6, 0xc6, 0xb3, 0x6c, 0xd5, 0x49, 0xa7, 0xec, 0xf0, 0x83, 0x40, 0xfc, 0x82, 0xc3, 0x81,
+	0xe0, 0xd1, 0x8e, 0x3f, 0xe0, 0x60, 0x9d, 0xca, 0x63, 0xd2, 0xc9, 0xca, 0x9f, 0x39, 0xec, 0x3b,
+	0x97, 0x3e, 0x88, 0x4a, 0xdd, 0x03, 0xfd, 0x4c, 0x92, 0x8b, 0x4b, 0x96, 0xd6, 0xbe, 0xc4, 0xdf,
+	0x42, 0x85, 0xbf, 0x8c, 0x79, 0x0c, 0xd5, 0x2a, 0xa4, 0xcf, 0x8f, 0xda, 0xff, 0xf2, 0xd1, 0xea,
+	0xbf, 0x7c, 0x74, 0xdb, 0xde, 0xcd, 0xd7, 0x36, 0x0e, 0xd2, 0xf3, 0x5f, 0x7f, 0x1e, 0xd0, 0x3f,
+	0xa2, 0x7f, 0xf2, 0xfa, 0xe2, 0xea, 0x31, 0xc5, 0x42, 0xba, 0xe2, 0x63, 0x53, 0xfc, 0xd6, 0xa5,
+	0x18, 0x9c, 0x9c, 0xcf, 0xae, 0xd6, 0xdf, 0xf6, 0x7e, 0xea, 0x7d, 0xf2, 0x57, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0x66, 0x1a, 0xa6, 0xfc, 0x29, 0x06, 0x00, 0x00,
+}