Release v1.11.2

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

@@ -6,6 +6,6 @@ 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 -o /bin/matterbridge \
+        && 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-0.6.md

@@ -1,115 +0,0 @@
-# matterbridge
-
-Simple bridge between mattermost, IRC, XMPP, Gitter and Slack
-
-* Relays public channel messages between mattermost, IRC, XMPP, Gitter and Slack. Pick and mix.
-* Supports multiple channels.
-* Matterbridge can also work with private groups on your mattermost.
-
-Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for documentation and an example.
-
-## Changelog
-Since v0.6.1 support for XMPP, Gitter and Slack is added. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
-
-## Requirements:
-Accounts to one of the supported bridges
-* [Mattermost] (https://github.com/mattermost/platform/)
-* [IRC] (http://www.mirc.com/servers.html)
-* [XMPP] (https://jabber.org)
-* [Gitter] (https://gitter.im)
-* [Slack] (https://www.slack.com)
-
-## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* For use with mattermost 3.3.0+ [v0.6.1](https://github.com/42wim/matterircd/releases/tag/v0.6.1)
-* For use with mattermost 3.0.0-3.2.0 [v0.5.0](https://github.com/42wim/matterircd/releases/tag/v0.5.0)
-
-
-## Docker
-Create your matterbridge.conf file locally eg in ```/tmp/matterbridge.conf```
-
-```
-docker run -ti -v /tmp/matterbridge.conf:/matterbridge.conf 42wim/matterbridge:0.6.1
-```
-
-## Compatibility
-### Mattermost 
-* Matterbridge v0.6.1 works with mattermost 3.3.0 and higher [3.3.0 release](https://github.com/mattermost/platform/releases/tag/v3.3.0)
-* Matterbridge v0.5.0 works with mattermost 3.0.0 - 3.2.0 [3.2.0 release](https://github.com/mattermost/platform/releases/tag/v3.2.0)
-
-
-#### Webhooks version
-* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
-
-#### Plus (API) version
-* A dedicated user(bot) on your mattermost instance.
-
-
-## building
-Go 1.6+ 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)
-
-```
-cd $GOPATH
-go get github.com/42wim/matterbridge
-```
-
-You should now have matterbridge binary in the bin directory:
-
-```
-$ 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. 
-
-```
-Usage of ./matterbridge:
-  -conf string
-        config file (default "matterbridge.conf")
-  -debug
-        enable debug
-  -plus
-        running using API instead of webhooks (deprecated, set Plus flag in [general] config)
-  -version
-        show version
-```
-
-## config
-### matterbridge
-matterbridge looks for matterbridge.conf in current directory. (use -conf to specify another file)
-
-Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for an example.
-
-### mattermost
-#### webhooks version
-You'll have to configure the incoming and outgoing webhooks. 
-
-* 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)  
-
-* 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.  
-
-e.g. http://192.168.1.1:9999 (192.168.1.1:9999 is the BindAddress specified in [mattermost] section of matterbridge.conf)
-
-#### plus version
-You'll have to create a new dedicated user on your mattermost instance.
-Specify the login and password in [mattermost] section of matterbridge.conf
-
-## FAQ
-Please look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for more information first. 
-### Mattermost doesn't show the IRC nicks
-If you're running the webhooks version, this can be fixed by either:
-* enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
-
-If you're running the plus version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
-
-Also look at the ```RemoteNickFormat``` setting.

README.md

@@ -1,52 +1,81 @@
 # matterbridge
-Simple bridge between mattermost, IRC, XMPP, Gitter, Slack and Discord
+Click on one of the badges below to join the chat   
 
-* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack and Discord. Pick and mix.
-* Supports multiple channels.
-* Matterbridge can also work with private groups on your mattermost.
-* Allow for bridging the same bridges, which means you can eg bridge between multiple mattermosts.
-* The bridge is now a gateway which has support multiple in and out bridges. (and supports multiple gateways).
+[![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/)
 
-Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
-Look at [matterbridge.toml.simple] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.simple) for a simple example.
+[![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)
 
-## Changelog
-Since v0.7.0 the configuration has changed. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
+![matterbridge.gif](https://github.com/42wim/matterbridge/blob/master/img/matterbridge.gif)
 
-## Requirements
+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)
+
+**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/)
-* [IRC] (http://www.mirc.com/servers.html)
-* [XMPP] (https://jabber.org)
-* [Gitter] (https://gitter.im)
-* [Slack] (https://slack.com)
-* [Discord] (https://discordapp.com)
+* [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)
 
-## Docker
-Create your matterbridge.toml file locally eg in ```/tmp/matterbridge.toml```
-```
-docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
-```
+# Screenshots
+See https://github.com/42wim/matterbridge/wiki
 
-## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* For use with mattermost 3.5.0+ [v0.8.0](https://github.com/42wim/matterircd/releases/tag/v0.8.0)
-* For use with mattermost 3.3.0 - 3.4.0 [v0.7.0](https://github.com/42wim/matterircd/releases/tag/v0.7.0)
+# Installing
+## Binaries
+* Latest stable release [v1.11.2](https://github.com/42wim/matterbridge/releases/latest)
+* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)  
 
-## Compatibility
-### Mattermost 
-* Matterbridge v0.8.0 works with mattermost 3.5.0+ [3.5.0 release](https://github.com/mattermost/platform/releases/tag/v3.5.0)
-* Matterbridge v0.7.0 works with mattermost 3.3.0 - 3.4.0 [3.4.0 release](https://github.com/mattermost/platform/releases/tag/v3.4.0)
+## 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).
 
-#### Webhooks version
-* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
-
-#### API version
-* A dedicated user(bot) on your mattermost instance.
-
-
-## building
-Go 1.6+ 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
@@ -60,10 +89,73 @@ $ 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)
+```
+[irc]
+    [irc.freenode]
+    Server="irc.freenode.net:6667"
+    Nick="yourbotname"
+
+[mattermost]
+    [mattermost.work]
+    Server="yourmattermostserver.tld"
+    Team="yourteam"
+    Login="yourlogin"
+    Password="yourpass"
+    PrefixMessagesWithNick=true
+    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+[[gateway]]
+name="mygateway"
+enable=true
+    [[gateway.inout]]
+    account="irc.freenode"
+    channel="#testing"
+
+    [[gateway.inout]]
+    account="mattermost.work"
+    channel="off-topic"
+```
+
+### Bridge slack (#general) - discord (general)
+```
+[slack]
+[slack.test]
+Token="yourslacktoken"
+PrefixMessagesWithNick=true
+
+[discord]
+[discord.test]
+Token="yourdiscordtoken"
+Server="yourdiscordservername"
+
+[general]
+RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
+
+[[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:
@@ -71,39 +163,43 @@ Usage of ./matterbridge:
         config file (default "matterbridge.toml")
   -debug
         enable debug
+  -gops
+        enable gops agent
   -version
         show version
 ```
 
-## config
-### matterbridge
-matterbridge looks for matterbridge.toml in current directory. (use -conf to specify another file)
+## Docker
+Create your matterbridge.toml file locally eg in ```/tmp/matterbridge.toml```
+```
+docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
+```
 
-Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for an example.
+# Changelog
+See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.md)
 
-### mattermost
-#### webhooks version
-You'll have to configure the incoming and outgoing webhooks. 
+# FAQ
 
-* 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)  
+See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
 
-* 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.  
+Want to tip ? 
+* eth: 0xb3f9b5387c66ad6be892bcb7bbc67862f3abc16f
+* btc: 1N7cKHj5SfqBHBzDJ6kad4BzeqUBBS2zhs
 
-e.g. http://192.168.1.1:9999 (192.168.1.1:9999 is the BindAddress specified in [mattermost] section of matterbridge.conf)
+# Thanks
+[![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
 
-## FAQ
-Please look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for more information first. 
-### Mattermost doesn't show the IRC nicks
-If you're running the webhooks version, this can be fixed by either:
-* enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
-
-If you're running the plus version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
-
-Also look at the ```RemoteNickFormat``` setting.
+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

@@ -2,44 +2,103 @@ package bridge
 
 import (
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/discord"
-	"github.com/42wim/matterbridge/bridge/gitter"
-	"github.com/42wim/matterbridge/bridge/irc"
-	"github.com/42wim/matterbridge/bridge/mattermost"
-	"github.com/42wim/matterbridge/bridge/slack"
-	"github.com/42wim/matterbridge/bridge/xmpp"
+	log "github.com/sirupsen/logrus"
+
 	"strings"
 )
 
-type Bridge interface {
-	Send(msg config.Message) error
-	Name() string
+type Bridger interface {
+	Send(msg config.Message) (string, error)
 	Connect() error
-	FullOrigin() string
-	Origin() string
-	Protocol() string
-	JoinChannel(channel string) error
+	JoinChannel(channel config.ChannelInfo) error
+	Disconnect() error
 }
 
-func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) Bridge {
+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]
-	// override config from environment
-	config.OverrideCfgFromEnv(cfg, protocol, name)
-	switch protocol {
-	case "mattermost":
-		return bmattermost.New(cfg.Mattermost[name], name, c)
-	case "irc":
-		return birc.New(cfg.IRC[name], name, c)
-	case "gitter":
-		return bgitter.New(cfg.Gitter[name], name, c)
-	case "slack":
-		return bslack.New(cfg.Slack[name], name, c)
-	case "xmpp":
-		return bxmpp.New(cfg.Xmpp[name], name, c)
-	case "discord":
-		return bdiscord.New(cfg.Discord[name], name, c)
+	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

@@ -1,57 +1,140 @@
 package config
 
 import (
-	"github.com/BurntSushi/toml"
-	"log"
+	"bytes"
 	"os"
-	"reflect"
 	"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
-	Channel    string
-	Username   string
-	Origin     string
-	FullOrigin string
-	Protocol   string
-	Avatar     string
+	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 {
-	BindAddress            string // mattermost, slack
+	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
-	Login                  string // mattermost
-	Muc                    string // xmpp
-	Name                   string // all protocols
-	Nick                   string // all protocols
-	NickFormatter          string // mattermost, slack
-	NickServNick           string // IRC
-	NickServPassword       string // IRC
-	NicksPerRow            int    // mattermost, slack
-	NoTLS                  bool   // mattermost
-	Password               string // IRC,mattermost,XMPP
-	PrefixMessagesWithNick bool   // mattemost, slack
-	Protocol               string //all protocols
-	MessageQueue           int    // IRC, size of message queue for flood control
-	MessageDelay           int    // IRC, time in millisecond to wait between messages
-	RemoteNickFormat       string // all protocols
-	Server                 string // IRC,mattermost,XMPP,discord
-	ShowJoinPart           bool   // all protocols
-	SkipTLSVerify          bool   // IRC, mattermost
-	Team                   string // mattermost
-	Token                  string // gitter, slack, discord
-	URL                    string // mattermost, slack
-	UseAPI                 bool   // mattermost, slack
-	UseSASL                bool   // IRC
-	UseTLS                 bool   // IRC
+	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
+	Account     string
+	Channel     string
+	Options     ChannelOptions
+	SameChannel bool
 }
 
 type Gateway struct {
@@ -59,6 +142,7 @@ type Gateway struct {
 	Enable bool
 	In     []Bridge
 	Out    []Bridge
+	InOut  []Bridge
 }
 
 type SameChannelGateway struct {
@@ -68,74 +152,135 @@ type SameChannelGateway struct {
 	Accounts []string
 }
 
-type Config struct {
-	IRC                map[string]Protocol
+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 {
-	var cfg Config
-	if _, err := toml.DecodeFile(cfgfile, &cfg); err != nil {
+	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)
 	}
-	return &cfg
-}
-
-func OverrideCfgFromEnv(cfg *Config, protocol string, account string) {
-	var protoCfg Protocol
-	val := reflect.ValueOf(cfg).Elem()
-	// loop over the Config struct
-	for i := 0; i < val.NumField(); i++ {
-		typeField := val.Type().Field(i)
-		// look for the protocol map (both lowercase)
-		if strings.ToLower(typeField.Name) == protocol {
-			// get the Protocol struct from the map
-			data := val.Field(i).MapIndex(reflect.ValueOf(account))
-			protoCfg = data.Interface().(Protocol)
-			protoStruct := reflect.ValueOf(&protoCfg).Elem()
-			// loop over the found protocol struct
-			for i := 0; i < protoStruct.NumField(); i++ {
-				typeField := protoStruct.Type().Field(i)
-				// build our environment key (eg MATTERBRIDGE_MATTERMOST_WORK_LOGIN)
-				key := "matterbridge_" + protocol + "_" + account + "_" + typeField.Name
-				key = strings.ToUpper(key)
-				// search the environment
-				res := os.Getenv(key)
-				// if it exists and the current field is a string
-				// then update the current field
-				if res != "" {
-					fieldVal := protoStruct.Field(i)
-					if fieldVal.Kind() == reflect.String {
-						log.Printf("config: overriding %s from env with %s\n", key, res)
-						fieldVal.Set(reflect.ValueOf(res))
-					}
-				}
-			}
-			// update the map with the modified Protocol (cfg.Protocol[account] = Protocol)
-			val.Field(i).SetMapIndex(reflect.ValueOf(account), reflect.ValueOf(protoCfg))
-			break
-		}
+	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 GetIconURL(msg *Message, cfg *Protocol) string {
-	iconURL := cfg.IconURL
+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}", msg.Origin, -1)
-	iconURL = strings.Replace(iconURL, "{PROTOCOL}", msg.Protocol, -1)
+	iconURL = strings.Replace(iconURL, "{BRIDGE}", name, -1)
+	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
 	return iconURL
 }
-
-func GetNick(msg *Message, cfg *Protocol) string {
-	nick := cfg.RemoteNickFormat
-	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
-	nick = strings.Replace(nick, "{BRIDGE}", msg.Origin, -1)
-	nick = strings.Replace(nick, "{PROTOCOL}", msg.Protocol, -1)
-	return nick
-}

bridge/discord/discord.go

@@ -1,136 +1,329 @@
 package bdiscord
 
 import (
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	"github.com/bwmarrin/discordgo"
+	"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"
 )
 
-type bdiscord struct {
-	c            *discordgo.Session
-	Config       *config.Protocol
-	Remote       chan config.Message
-	protocol     string
-	origin       string
-	Channels     []*discordgo.Channel
-	Nick         string
-	UseChannelID bool
+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
 }
 
-var flog *log.Entry
-var protocol = "discord"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *bdiscord {
-	b := &bdiscord{}
-	b.Config = &cfg
-	b.Remote = c
-	b.protocol = protocol
-	b.origin = origin
+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 {
+func (b *Bdiscord) Connect() error {
 	var err error
-	flog.Info("Connecting")
-	b.c, err = discordgo.New(b.Config.Token)
+	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 {
-		flog.Debugf("%#v", err)
 		return err
 	}
-	flog.Info("Connection succeeded")
+	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 {
-		flog.Debugf("%#v", err)
 		return err
 	}
-	guilds, err := b.c.UserGuilds()
+	guilds, err := b.c.UserGuilds(100, "", "")
 	if err != nil {
-		flog.Debugf("%#v", err)
 		return err
 	}
 	userinfo, err := b.c.User("@me")
 	if err != nil {
-		flog.Debugf("%#v", err)
 		return err
 	}
 	b.Nick = userinfo.Username
 	for _, guild := range guilds {
-		if guild.Name == b.Config.Server {
+		if guild.Name == b.GetString("Server") {
 			b.Channels, err = b.c.GuildChannels(guild.ID)
+			b.guildID = guild.ID
 			if err != nil {
-				flog.Debugf("%#v", err)
 				return err
 			}
 		}
 	}
+	for _, channel := range b.Channels {
+		b.Log.Debugf("found channel %#v", channel)
+	}
 	return nil
 }
 
-func (b *bdiscord) FullOrigin() string {
-	return b.protocol + "." + b.origin
+func (b *Bdiscord) Disconnect() error {
+	return b.c.Close()
 }
 
-func (b *bdiscord) JoinChannel(channel string) error {
-	idcheck := strings.Split(channel, "ID:")
+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) Name() string {
-	return b.protocol + "." + b.origin
-}
+func (b *Bdiscord) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
 
-func (b *bdiscord) Protocol() string {
-	return b.protocol
-}
-
-func (b *bdiscord) Origin() string {
-	return b.origin
-}
-
-func (b *bdiscord) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
 	channelID := b.getChannelID(msg.Channel)
 	if channelID == "" {
-		flog.Errorf("Could not find channelID for %v", msg.Channel)
-		return nil
+		return "", fmt.Errorf("Could not find channelID for %v", msg.Channel)
 	}
-	nick := config.GetNick(&msg, b.Config)
-	b.c.ChannelMessageSend(channelID, nick+msg.Text)
-	return nil
+
+	// 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) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+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
 		}
 	}
-	if m.Content == "" {
+
+	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
 	}
-	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.FullOrigin())
-	channelName := b.getChannelName(m.ChannelID)
-	if b.UseChannelID {
-		channelName = "ID:" + m.ChannelID
+
+	// 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.Remote <- config.Message{Username: m.Author.Username, Text: m.ContentWithMentionsReplaced(), Channel: channelName,
-		Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin(), Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg"}
+
+	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) getChannelID(name string) string {
+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]
@@ -143,7 +336,7 @@ func (b *bdiscord) getChannelID(name string) string {
 	return ""
 }
 
-func (b *bdiscord) getChannelName(id string) string {
+func (b *Bdiscord) getChannelName(id string) string {
 	for _, channel := range b.Channels {
 		if channel.ID == id {
 			return channel.Name
@@ -151,3 +344,91 @@ func (b *bdiscord) getChannelName(id string) string {
 	}
 	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

@@ -1,62 +1,58 @@
 package bgitter
 
 import (
-	"github.com/42wim/go-gitter"
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
+	"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
-	Config   *config.Protocol
-	Remote   chan config.Message
-	protocol string
-	origin   string
-	Users    []gitter.User
-	Rooms    []gitter.Room
+	c     *gitter.Gitter
+	User  *gitter.User
+	Users []gitter.User
+	Rooms []gitter.Room
+	*bridge.Config
 }
 
-var flog *log.Entry
-var protocol = "gitter"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *Bgitter {
-	b := &Bgitter{}
-	b.Config = &cfg
-	b.Remote = c
-	b.protocol = protocol
-	b.origin = origin
-	return b
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bgitter{Config: cfg}
 }
 
 func (b *Bgitter) Connect() error {
 	var err error
-	flog.Info("Connecting")
-	b.c = gitter.New(b.Config.Token)
-	_, err = b.c.GetUser()
+	b.Log.Info("Connecting")
+	b.c = gitter.New(b.GetString("Token"))
+	b.User, err = b.c.GetUser()
 	if err != nil {
-		flog.Debugf("%#v", err)
 		return err
 	}
-	flog.Info("Connection succeeded")
-	b.Rooms, _ = b.c.GetRooms()
+	b.Rooms, err = b.c.GetRooms()
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
 	return nil
 }
 
-func (b *Bgitter) FullOrigin() string {
-	return b.protocol + "." + b.origin
+func (b *Bgitter) Disconnect() error {
+	return nil
+
 }
 
-func (b *Bgitter) JoinChannel(channel string) error {
-	room := channel
-	roomID := b.getRoomID(room)
-	if roomID == "" {
-		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
@@ -71,46 +67,77 @@ func (b *Bgitter) JoinChannel(channel string) error {
 	go b.c.Listen(stream)
 
 	go func(stream *gitter.Stream, room string) {
-		for {
-			event := <-stream.Event
+		for event := range stream.Event {
 			switch ev := event.Data.(type) {
 			case *gitter.MessageReceived:
-				// check for ZWSP to see if it's not an echo
-				if !strings.HasSuffix(ev.Message.Text, "​") {
-					flog.Debugf("Sending message from %s on %s to gateway", ev.Message.From.Username, b.FullOrigin())
-					b.Remote <- config.Message{Username: ev.Message.From.Username, Text: ev.Message.Text, Channel: room,
-						Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin(), Avatar: b.getAvatar(ev.Message.From.Username)}
+				// 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:
-				flog.Errorf("connection with gitter closed for room %s", room)
+				b.Log.Errorf("connection with gitter closed for room %s", room)
 			}
 		}
-	}(stream, room)
+	}(stream, room.URI)
 	return nil
 }
 
-func (b *Bgitter) Name() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Bgitter) Protocol() string {
-	return b.protocol
-}
-
-func (b *Bgitter) Origin() string {
-	return b.origin
-}
-
-func (b *Bgitter) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
+func (b *Bgitter) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
 	roomID := b.getRoomID(msg.Channel)
 	if roomID == "" {
-		flog.Errorf("Could not find roomID for %v", msg.Channel)
-		return nil
+		b.Log.Errorf("Could not find roomID for %v", msg.Channel)
+		return "", nil
 	}
-	nick := config.GetNick(&msg, b.Config)
-	// add ZWSP because gitter echoes our own messages
-	return b.c.SendMessage(roomID, nick+msg.Text+" ​")
+
+	// 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 {
@@ -133,3 +160,23 @@ func (b *Bgitter) getAvatar(user string) string {
 	}
 	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

@@ -4,6 +4,7 @@ import (
 	"strings"
 )
 
+/*
 func tableformatter(nicks []string, nicksPerRow int, continued bool) string {
 	result := "|IRC users"
 	if continued {
@@ -29,6 +30,7 @@ func tableformatter(nicks []string, nicksPerRow int, continued bool) string {
 	}
 	return result
 }
+*/
 
 func plainformatter(nicks []string, nicksPerRow int) string {
 	return strings.Join(nicks, ", ") + " currently on IRC"

bridge/irc/irc.go

@@ -1,262 +1,466 @@
 package birc
 
 import (
+	"bytes"
 	"crypto/tls"
 	"fmt"
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	ircm "github.com/sorcix/irc"
-	"github.com/thoj/go-ircevent"
+	"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         *irc.Connection
-	Nick      string
-	names     map[string][]string
-	Config    *config.Protocol
-	origin    string
-	protocol  string
-	Remote    chan config.Message
-	connected chan struct{}
-	Local     chan config.Message // local queue for flood control
+	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
 }
 
-var flog *log.Entry
-var protocol = "irc"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *Birc {
+func New(cfg *bridge.Config) bridge.Bridger {
 	b := &Birc{}
-	b.Config = &cfg
-	b.Nick = b.Config.Nick
-	b.Remote = c
+	b.Config = cfg
+	b.Nick = b.GetString("Nick")
 	b.names = make(map[string][]string)
-	b.origin = origin
-	b.protocol = protocol
 	b.connected = make(chan struct{})
-	if b.Config.MessageDelay == 0 {
-		b.Config.MessageDelay = 1300
+	if b.GetInt("MessageDelay") == 0 {
+		b.MessageDelay = 1300
+	} else {
+		b.MessageDelay = b.GetInt("MessageDelay")
 	}
-	if b.Config.MessageQueue == 0 {
-		b.Config.MessageQueue = 30
+	if b.GetInt("MessageQueue") == 0 {
+		b.MessageQueue = 30
+	} else {
+		b.MessageQueue = b.GetInt("MessageQueue")
 	}
-	b.Local = make(chan config.Message, b.Config.MessageQueue+10)
+	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.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
-		b.i.SendRaw("NAMES " + msg.Channel)
-		b.i.ClearCallback(ircm.RPL_ENDOFNAMES)
+		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 {
-	flog.Infof("Connecting %s", b.Config.Server)
-	i := irc.IRC(b.Config.Nick, b.Config.Nick)
-	if log.GetLevel() == log.DebugLevel {
-		i.Debug = true
-	}
-	i.UseTLS = b.Config.UseTLS
-	i.UseSASL = b.Config.UseSASL
-	i.SASLLogin = b.Config.NickServNick
-	i.SASLPassword = b.Config.NickServPassword
-	i.TLSConfig = &tls.Config{InsecureSkipVerify: b.Config.SkipTLSVerify}
-	if b.Config.Password != "" {
-		i.Password = b.Config.Password
-	}
-	i.AddCallback(ircm.RPL_WELCOME, b.handleNewConnection)
-	err := i.Connect(b.Config.Server)
+	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:
-		flog.Info("Connection succeeded")
+		b.Log.Info("Connection succeeded")
 	case <-time.After(time.Second * 30):
 		return fmt.Errorf("connection timed out")
 	}
-	i.Debug = false
+	//i.Debug = false
+	if b.GetInt("DebugLevel") == 0 {
+		i.Handlers.Clear(girc.ALL_EVENTS)
+	}
 	go b.doSend()
 	return nil
 }
 
-func (b *Birc) FullOrigin() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Birc) JoinChannel(channel string) error {
-	b.i.Join(channel)
+func (b *Birc) Disconnect() error {
+	b.i.Close()
+	close(b.Local)
 	return nil
 }
 
-func (b *Birc) Name() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Birc) Protocol() string {
-	return b.protocol
-}
-
-func (b *Birc) Origin() string {
-	return b.origin
-}
-
-func (b *Birc) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	if msg.FullOrigin == b.FullOrigin() {
-		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)
-		return nil
 	}
-	nick := config.GetNick(&msg, b.Config)
-	for _, text := range strings.Split(msg.Text, "\n") {
-		if len(b.Local) < b.Config.MessageQueue {
-			if len(b.Local) == b.Config.MessageQueue-1 {
-				text = text + " <message clipped>"
+
+	// 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
 			}
-			b.Local <- config.Message{Text: text, Username: nick, Channel: msg.Channel}
-		} else {
-			flog.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
+			fmt.Fprint(w, msg.Text)
+			w.Close()
+			msg.Text = buf.String()
 		}
 	}
-	return nil
+
+	// 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.Config.MessageDelay)
-	throttle := time.Tick(rate)
+	rate := time.Millisecond * time.Duration(b.MessageDelay)
+	throttle := time.NewTicker(rate)
 	for msg := range b.Local {
-		<-throttle
-		b.i.Privmsg(msg.Channel, msg.Username+msg.Text)
+		<-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(event *irc.Event) {
-	channel := event.Arguments[1]
+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, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
+			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,
-		Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
+	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(event *irc.Event) {
-	flog.Debug("Registering callbacks")
+func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
+	b.Log.Debug("Registering callbacks")
 	i := b.i
-	b.Nick = event.Arguments[0]
-	i.AddCallback("PRIVMSG", b.handlePrivMsg)
-	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
-	i.AddCallback(ircm.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
-	i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
-	i.AddCallback(ircm.NOTICE, b.handleNotice)
-	//i.AddCallback(ircm.RPL_MYINFO, func(e *irc.Event) { flog.Infof("%s: %s", e.Code, strings.Join(e.Arguments[1:], " ")) })
-	i.AddCallback("PING", func(e *irc.Event) {
-		i.SendRaw("PONG :" + e.Message())
-		flog.Debugf("PING/PONG")
-	})
-	i.AddCallback("*", b.handleOther)
+	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) handleNotice(event *irc.Event) {
-	if strings.Contains(event.Message(), "This nickname is registered") && event.Nick == b.Config.NickServNick {
-		b.i.Privmsg(b.Config.NickServNick, "IDENTIFY "+b.Config.NickServPassword)
+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" {
+		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(event)
+		b.handlePrivMsg(client, event)
 	}
 }
 
-func (b *Birc) handleOther(event *irc.Event) {
-	switch event.Code {
+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
 	}
-	flog.Debugf("%#v", event.Raw)
+	b.Log.Debugf("%#v", event.String())
 }
 
-func (b *Birc) handlePrivMsg(event *irc.Event) {
+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.Arguments[0] == b.Nick {
-		return
+	if event.Params[0] == b.Nick {
+		return true
 	}
 	// don't forward message from ourself
-	if event.Nick == b.Nick {
-		return
+	if event.Source.Name == b.Nick {
+		return true
 	}
-	flog.Debugf("handlePrivMsg() %s %s %#v", event.Nick, event.Message(), event)
-	msg := ""
-	if event.Code == "CTCP_ACTION" {
-		msg = event.Nick + " "
-	}
-	msg += event.Message()
-	// strip IRC colors
-	re := regexp.MustCompile(`[[:cntrl:]](\d+,|)\d+`)
-	msg = re.ReplaceAllString(msg, "")
-	flog.Debugf("Sending message from %s on %s to gateway", event.Arguments[0], b.FullOrigin())
-	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
+	return false
 }
 
-func (b *Birc) handleTopicWhoTime(event *irc.Event) {
-	parts := strings.Split(event.Arguments[2], "!")
-	t, err := strconv.ParseInt(event.Arguments[3], 10, 64)
+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 {
-		flog.Errorf("Invalid time stamp: %s", event.Arguments[3])
+		b.Log.Errorf("Invalid time stamp: %s", event.Params[3])
 	}
 	user := parts[0]
 	if len(parts) > 1 {
 		user += " [" + parts[1] + "]"
 	}
-	flog.Debugf("%s: Topic set by %s [%s]", event.Code, user, time.Unix(t, 0))
+	b.Log.Debugf("%s: Topic set by %s [%s]", event.Command, user, time.Unix(t, 0))
 }
 
 func (b *Birc) nicksPerRow() int {
 	return 4
-	/*
-		if b.Config.Mattermost.NicksPerRow < 1 {
-			return 4
-		}
-		return b.Config.Mattermost.NicksPerRow
-	*/
 }
 
-func (b *Birc) storeNames(event *irc.Event) {
-	channel := event.Arguments[2]
+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.Message()), " ")...)
+		strings.Split(strings.TrimSpace(event.Trailing), " ")...)
 }
 
 func (b *Birc) formatnicks(nicks []string, continued bool) string {
 	return plainformatter(nicks, b.nicksPerRow())
-	/*
-		switch b.Config.Mattermost.NickFormatter {
-		case "table":
-			return tableformatter(nicks, b.nicksPerRow(), continued)
-		default:
-			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

@@ -1,54 +1,30 @@
 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"
-	log "github.com/Sirupsen/logrus"
+	"github.com/rs/xid"
 )
 
-type MMhook struct {
-	mh *matterhook.Client
-}
-
-type MMapi struct {
-	mc            *matterclient.MMClient
-	mmMap         map[string]string
-	mmIgnoreNicks []string
-}
-
-type MMMessage struct {
-	Text     string
-	Channel  string
-	Username string
-}
-
 type Bmattermost struct {
-	MMhook
-	MMapi
-	Config   *config.Protocol
-	Remote   chan config.Message
-	name     string
-	origin   string
-	protocol string
-	TeamId   string
+	mh     *matterhook.Client
+	mc     *matterclient.MMClient
+	uuid   string
+	TeamID string
+	*bridge.Config
+	avatarMap map[string]string
 }
 
-var flog *log.Entry
-var protocol = "mattermost"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *Bmattermost {
-	b := &Bmattermost{}
-	b.Config = &cfg
-	b.origin = origin
-	b.Remote = c
-	b.protocol = "mattermost"
-	b.name = cfg.Name
-	b.mmMap = make(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
 }
 
@@ -57,126 +33,433 @@ func (b *Bmattermost) Command(cmd string) string {
 }
 
 func (b *Bmattermost) Connect() error {
-	if !b.Config.UseAPI {
-		flog.Info("Connecting webhooks")
-		b.mh = matterhook.New(b.Config.URL,
-			matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
-				BindAddress: b.Config.BindAddress})
-	} else {
-		b.mc = matterclient.New(b.Config.Login, b.Config.Password,
-			b.Config.Team, b.Config.Server)
-		b.mc.SkipTLSVerify = b.Config.SkipTLSVerify
-		b.mc.NoTLS = b.Config.NoTLS
-		flog.Infof("Connecting %s (team: %s) on %s", b.Config.Login, b.Config.Team, b.Config.Server)
-		err := b.mc.Login()
-		if err != nil {
-			return err
-		}
-		flog.Info("Connection succeeded")
-		b.TeamId = b.mc.GetTeamId()
-		go b.mc.WsReceiver()
-	}
-	go b.handleMatter()
-	return nil
-}
-
-func (b *Bmattermost) FullOrigin() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Bmattermost) JoinChannel(channel string) error {
-	// we can only join channels using the API
-	if b.Config.UseAPI {
-		return b.mc.JoinChannel(b.mc.GetChannelId(channel, ""))
-	}
-	return nil
-}
-
-func (b *Bmattermost) Name() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Bmattermost) Origin() string {
-	return b.origin
-}
-
-func (b *Bmattermost) Protocol() string {
-	return b.protocol
-}
-
-func (b *Bmattermost) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	nick := config.GetNick(&msg, b.Config)
-	message := msg.Text
-	channel := msg.Channel
-
-	if b.Config.PrefixMessagesWithNick {
-		/*if IsMarkup(message) {
-			message = nick + "\n\n" + message
+	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 {
-		*/
-		message = nick + " " + message
-		//}
-	}
-	if !b.Config.UseAPI {
-		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
-		matterMessage.Channel = channel
-		matterMessage.UserName = nick
-		matterMessage.Type = ""
-		matterMessage.Text = message
-		err := b.mh.Send(matterMessage)
-		if err != nil {
-			flog.Info(err)
-			return err
+			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
 	}
-	b.mc.PostMessage(b.mc.GetChannelId(channel, ""), message)
+	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() {
-	flog.Debugf("Choosing API based Mattermost connection: %t", b.Config.UseAPI)
-	mchan := make(chan *MMMessage)
-	if b.Config.UseAPI {
-		go b.handleMatterClient(mchan)
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleMatterHook(messages)
 	} else {
-		go b.handleMatterHook(mchan)
+		if b.GetString("Token") != "" {
+			b.Log.Debugf("Choosing token based receiving")
+		} else {
+			b.Log.Debugf("Choosing login/password based receiving")
+		}
+		go b.handleMatterClient(messages)
 	}
-	for message := range mchan {
-		flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.FullOrigin())
-		b.Remote <- config.Message{Text: message.Text, Username: message.Username, Channel: message.Channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
+	var ok bool
+	for message := range messages {
+		message.Avatar = helper.GetAvatar(b.avatarMap, message.UserID, b.General)
+		message.Account = b.Account
+		if nick := b.mc.GetNickName(message.UserID); nick != "" {
+			message.Username = nick
+		}
+		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(mchan chan *MMMessage) {
+func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 	for message := range b.mc.MessageChan {
-		// do not post our own messages back to irc
-		// only listen to message from our team
-		if message.Raw.Event == "posted" && b.mc.User.Username != message.Username && message.Raw.Data["team_id"].(string) == b.TeamId {
-			flog.Debugf("Receiving from matterclient %#v", message)
-			m := &MMMessage{}
-			m.Username = message.Username
-			m.Channel = message.Channel
-			m.Text = message.Text
-			if len(message.Post.Filenames) > 0 {
-				for _, link := range b.mc.GetPublicLinks(message.Post.Filenames) {
-					m.Text = m.Text + "\n" + link
+		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)
+						}
+					}
 				}
 			}
-			mchan <- m
 		}
+
+		// 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)
+				}
+			}
+		}
+		messages <- rmsg
 	}
 }
 
-func (b *Bmattermost) handleMatterHook(mchan chan *MMMessage) {
+func (b *Bmattermost) handleMatterHook(messages chan *config.Message) {
 	for {
 		message := b.mh.Receive()
-		flog.Debugf("Receiving from matterhook %#v", message)
-		m := &MMMessage{}
-		m.Username = message.UserName
-		m.Text = message.Text
-		m.Channel = message.ChannelName
-		mchan <- m
+		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

@@ -1,49 +1,44 @@
 package bslack
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/matterhook"
-	log "github.com/Sirupsen/logrus"
-	"github.com/nlopes/slack"
+	"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 MMMessage struct {
-	Text     string
-	Channel  string
-	Username string
-	Raw      *slack.MessageEvent
-}
-
 type Bslack struct {
-	mh       *matterhook.Client
-	sc       *slack.Client
-	Config   *config.Protocol
-	rtm      *slack.RTM
-	Plus     bool
-	Remote   chan config.Message
-	Users    []slack.User
-	protocol string
-	origin   string
-	si       *slack.Info
-	channels []slack.Channel
+	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
 }
 
-var flog *log.Entry
-var protocol = "slack"
+const messageDeleted = "message_deleted"
 
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *Bslack {
-	b := &Bslack{}
-	b.Config = &cfg
-	b.Remote = c
-	b.protocol = protocol
-	b.origin = origin
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bslack{Config: cfg, uuid: xid.New().String()}
+	b.cache, _ = lru.New(5000)
 	return b
 }
 
@@ -52,99 +47,191 @@ func (b *Bslack) Command(cmd string) string {
 }
 
 func (b *Bslack) Connect() error {
-	flog.Info("Connecting")
-	if !b.Config.UseAPI {
-		b.mh = matterhook.New(b.Config.URL,
-			matterhook.Config{BindAddress: b.Config.BindAddress})
-	} else {
-		b.sc = slack.New(b.Config.Token)
+	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")
 	}
-	flog.Info("Connection succeeded")
-	go b.handleSlack()
 	return nil
 }
 
-func (b *Bslack) FullOrigin() string {
-	return b.protocol + "." + b.origin
+func (b *Bslack) Disconnect() error {
+	return b.rtm.Disconnect()
 }
 
-func (b *Bslack) JoinChannel(channel string) error {
+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.Config.UseAPI {
-		_, err := b.sc.JoinChannel(channel)
+	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 {
-			return err
+			switch err.Error() {
+			case "name_taken", "restricted_action":
+			case "default":
+				{
+					return err
+				}
+			}
 		}
 	}
 	return nil
 }
 
-func (b *Bslack) Name() string {
-	return b.protocol + "." + b.origin
-}
+func (b *Bslack) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
 
-func (b *Bslack) Protocol() string {
-	return b.protocol
-}
-
-func (b *Bslack) Origin() string {
-	return b.origin
-}
-
-func (b *Bslack) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	if msg.FullOrigin == b.FullOrigin() {
-		return nil
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
 	}
-	nick := config.GetNick(&msg, b.Config)
-	message := msg.Text
-	channel := msg.Channel
-	if b.Config.PrefixMessagesWithNick {
-		message = nick + " " + message
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return b.sendWebhook(msg)
 	}
-	if !b.Config.UseAPI {
-		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
-		matterMessage.Channel = channel
-		matterMessage.UserName = nick
-		matterMessage.Type = ""
-		matterMessage.Text = message
-		err := b.mh.Send(matterMessage)
-		if err != nil {
-			flog.Info(err)
-			return err
+
+	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
 		}
-		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
 	}
-	schannel, err := b.getChannelByName(channel)
-	if err != nil {
-		return err
+
+	// 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.Config.PrefixMessagesWithNick == true {
+	if b.GetBool("PrefixMessagesWithNick") {
 		np.AsUser = true
 	}
-	np.Username = nick
-	np.IconURL = config.GetIconURL(&msg, b.Config)
+	np.Username = msg.Username
+	np.LinkNames = 1 // replace mentions
+	np.IconURL = config.GetIconURL(&msg, b.GetString("iconurl"))
 	if msg.Avatar != "" {
 		np.IconURL = msg.Avatar
 	}
-	b.sc.PostMessage(schannel.ID, message, np)
+	// 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)...)
+		}
+	}
 
-	/*
-	   newmsg := b.rtm.NewOutgoingMessage(message, schannel.ID)
-	   b.rtm.SendMessage(newmsg)
-	*/
+	// 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)
+		}
+	}
 
-	return nil
+	// Post normal message
+	_, id, err := b.sc.PostMessage(channelID, msg.Text, np)
+	if err != nil {
+		return "", err
+	}
+	return "slack " + id, nil
 }
 
-func (b *Bslack) getAvatar(user string) string {
+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 user == u.Name {
+			if userid == u.ID {
 				return u.Profile.Image48
 			}
 		}
@@ -152,87 +239,506 @@ func (b *Bslack) getAvatar(user string) string {
 	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.FullOrigin(), name)
+		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.FullOrigin(), name)
+	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() {
-	flog.Debugf("Choosing API based slack connection: %t", b.Config.UseAPI)
-	mchan := make(chan *MMMessage)
-	if b.Config.UseAPI {
-		go b.handleSlackClient(mchan)
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleMatterHook(messages)
 	} else {
-		go b.handleMatterHook(mchan)
+		b.Log.Debugf("Choosing token based receiving")
+		go b.handleSlackClient(messages)
 	}
 	time.Sleep(time.Second)
-	flog.Debug("Start listening for Slack messages")
-	for message := range mchan {
-		// do not send messages from ourself
-		if message.Username == b.si.User.Name {
-			continue
-		}
-		texts := strings.Split(message.Text, "\n")
-		for _, text := range texts {
-			flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.FullOrigin())
-			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin(), Avatar: b.getAvatar(message.Username)}
-		}
+	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(mchan chan *MMMessage) {
-	count := 0
+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:
-			// ignore first message
-			if count > 0 {
-				flog.Debugf("Receiving from slackclient %#v", ev)
-				//ev.ReplyTo
-				channel, err := b.rtm.GetChannelInfo(ev.Channel)
-				if err != nil {
-					continue
-				}
-				user, err := b.rtm.GetUserInfo(ev.User)
-				if err != nil {
-					continue
-				}
-				m := &MMMessage{}
-				m.Username = user.Name
-				m.Channel = channel.Name
-				m.Text = ev.Text
-				m.Raw = ev
-				mchan <- m
+			if b.skipMessageEvent(ev) {
+				b.Log.Debugf("Skipped message: %#v", ev)
+				continue
 			}
-			count++
+			rmsg, err := b.handleMessageEvent(ev)
+			if err != nil {
+				b.Log.Errorf("%#v", err)
+				continue
+			}
+			messages <- rmsg
 		case *slack.OutgoingErrorEvent:
-			flog.Debugf("%#v", ev.Error())
+			b.Log.Debugf("%#v", ev.Error())
+		case *slack.ChannelJoinedEvent:
+			b.Users, _ = b.sc.GetUsers()
+			b.Usergroups, _ = b.sc.GetUserGroups()
 		case *slack.ConnectedEvent:
-			b.channels = ev.Info.Channels
+			var err error
+			b.channels, _, err = b.sc.GetConversations(&slack.GetConversationsParameters{})
+			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:
-			flog.Fatalf("Invalid Token %#v", ev)
+			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(mchan chan *MMMessage) {
+func (b *Bslack) handleMatterHook(messages chan *config.Message) {
 	for {
 		message := b.mh.Receive()
-		flog.Debugf("receiving from matterhook (slack) %#v", message)
-		m := &MMMessage{}
-		m.Username = message.UserName
-		m.Text = message.Text
-		m.Channel = message.ChannelName
-		mchan <- m
+		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

@@ -1,115 +1,161 @@
 package bxmpp
 
 import (
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	"github.com/mattn/go-xmpp"
-
+	"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
-	Config   *config.Protocol
-	origin   string
-	protocol string
-	Remote   chan config.Message
+	xc      *xmpp.Client
+	xmppMap map[string]string
+	*bridge.Config
 }
 
-var flog *log.Entry
-var protocol = "xmpp"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, origin string, c chan config.Message) *Bxmpp {
-	b := &Bxmpp{}
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bxmpp{Config: cfg}
 	b.xmppMap = make(map[string]string)
-	b.Config = &cfg
-	b.protocol = protocol
-	b.origin = origin
-	b.Remote = c
 	return b
 }
 
 func (b *Bxmpp) Connect() error {
 	var err error
-	flog.Infof("Connecting %s", b.Config.Server)
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
 	b.xc, err = b.createXMPP()
 	if err != nil {
-		flog.Debugf("%#v", err)
+		b.Log.Debugf("%#v", err)
 		return err
 	}
-	flog.Info("Connection succeeded")
-	go b.handleXmpp()
+	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) FullOrigin() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Bxmpp) JoinChannel(channel string) error {
-	b.xc.JoinMUCNoHistory(channel+"@"+b.Config.Muc, b.Config.Nick)
+func (b *Bxmpp) Disconnect() error {
 	return nil
 }
 
-func (b *Bxmpp) Name() string {
-	return b.protocol + "." + b.origin
-}
-
-func (b *Bxmpp) Protocol() string {
-	return b.protocol
-}
-
-func (b *Bxmpp) Origin() string {
-	return b.origin
-}
-
-func (b *Bxmpp) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	nick := config.GetNick(&msg, b.Config)
-	b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.Config.Muc, Text: nick + msg.Text})
+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.Config.Server,
-		User:     b.Config.Jid,
-		Password: b.Config.Password,
-		NoTLS:    true,
-		StartTLS: true,
-		//StartTLS:      false,
-		Debug:                        true,
+		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,
-		//InsecureAllowUnencryptedAuth: true,
 	}
 	var err error
 	b.xc, err = options.NewClient()
 	return b.xc, err
 }
 
-func (b *Bxmpp) xmppKeepAlive() {
+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.xc.Send(xmpp.Chat{})
+				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 {
+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 {
@@ -117,23 +163,104 @@ func (b *Bxmpp) handleXmpp() error {
 		}
 		switch v := m.(type) {
 		case xmpp.Chat:
-			var channel, nick string
 			if v.Type == "groupchat" {
-				s := strings.Split(v.Remote, "@")
-				if len(s) == 2 {
-					channel = s[0]
+				b.Log.Debugf("== Receiving %#v", v)
+				// skip invalid messages
+				if b.skipMessage(v) {
+					continue
 				}
-				s = strings.Split(s[1], "/")
-				if len(s) == 2 {
-					nick = s[1]
+				msgid = v.ID
+				if v.ReplaceID != "" {
+					msgid = v.ReplaceID
 				}
-				if nick != b.Config.Nick {
-					flog.Debugf("Sending message from %s on %s to gateway", nick, b.FullOrigin())
-					b.Remote <- config.Message{Username: nick, Text: v.Text, Channel: channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
+				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

@@ -1,9 +1,597 @@
-# v0.8
+# 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
+# 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
@@ -37,6 +625,7 @@ See matterbridge.toml.sample for an example
 # v0.6.1
 ## New features
 * Slack support added.  See matterbridge.conf.sample for more information
+
 ## Bugfix
 * Fix 100% CPU bug on incorrect closed connections
 

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
+

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

@@ -1,151 +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"
-	log "github.com/Sirupsen/logrus"
-	"reflect"
+	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
-	MyConfig    *config.Gateway
-	Bridges     []bridge.Bridge
-	ChannelsOut map[string][]string
-	ChannelsIn  map[string][]string
-	ignoreNicks map[string][]string
-	Name        string
+	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
 }
 
-func New(cfg *config.Config, gateway *config.Gateway) error {
-	c := make(chan config.Message)
-	gw := &Gateway{}
-	gw.Name = gateway.Name
-	gw.Config = cfg
-	gw.MyConfig = gateway
-	exists := make(map[string]bool)
-	for _, br := range append(gateway.In, gateway.Out...) {
-		if exists[br.Account] {
-			continue
-		}
-		log.Infof("Starting bridge: %s channel: %s", br.Account, br.Channel)
-		gw.Bridges = append(gw.Bridges, bridge.New(cfg, &br, c))
-		exists[br.Account] = true
+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.mapChannels()
-	//TODO fix mapIgnores
-	//gw.mapIgnores()
-	exists = make(map[string]bool)
-	for _, br := range gw.Bridges {
-		err := br.Connect()
-		if err != nil {
-			log.Fatalf("Bridge %s failed to start: %v", br.FullOrigin(), err)
-		}
-		for _, channel := range append(gw.ChannelsOut[br.FullOrigin()], gw.ChannelsIn[br.FullOrigin()]...) {
-			if exists[br.FullOrigin()+channel] {
-				continue
-			}
-			log.Infof("%s: joining %s", br.FullOrigin(), channel)
-			br.JoinChannel(channel)
-			exists[br.FullOrigin()+channel] = true
-		}
-	}
-	gw.handleReceive(c)
+	gw.mapChannelsToBridge(br)
+	gw.Bridges[cfg.Account] = br
 	return nil
 }
 
-func (gw *Gateway) handleReceive(c chan config.Message) {
-	for {
-		select {
-		case msg := <-c:
-			for _, br := range gw.Bridges {
-				gw.handleMessage(msg, br)
+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 {
-	m := make(map[string][]string)
-	for _, br := range gw.MyConfig.Out {
-		m[br.Account] = append(m[br.Account], br.Channel)
-	}
-	gw.ChannelsOut = m
-	m = nil
-	m = make(map[string][]string)
-	for _, br := range gw.MyConfig.In {
-		m[br.Account] = append(m[br.Account], br.Channel)
-	}
-	gw.ChannelsIn = m
+	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
 	return nil
 }
 
-func (gw *Gateway) mapIgnores() {
-	m := make(map[string][]string)
-	for _, br := range gw.MyConfig.In {
-		accInfo := strings.Split(br.Account, ".")
-		m[br.Account] = strings.Fields(gw.Config.IRC[accInfo[1]].IgnoreNicks)
-	}
-	gw.ignoreNicks = m
-}
+func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
+	var channels []config.ChannelInfo
 
-func (gw *Gateway) getDestChannel(msg *config.Message, dest string) []string {
-	channels := gw.ChannelsIn[msg.FullOrigin]
-	for _, channel := range channels {
-		if channel == msg.Channel {
-			return gw.ChannelsOut[dest]
-		}
+	// for messages received from the api check that the gateway is the specified one
+	if msg.Protocol == "api" && gw.Name != msg.Gateway {
+		return channels
 	}
-	return []string{}
-}
 
-func (gw *Gateway) handleMessage(msg config.Message, dest bridge.Bridge) {
-	if gw.ignoreMessage(&msg) {
-		return
-	}
-	originchannel := msg.Channel
-	channels := gw.getDestChannel(&msg, dest.FullOrigin())
-	for _, channel := range channels {
-		// do not send the message to the bridge we come from if also the channel is the same
-		if msg.FullOrigin == dest.FullOrigin() && channel == originchannel {
+	// 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
 		}
-		msg.Channel = channel
-		if msg.Channel == "" {
-			log.Debug("empty channel")
-			return
+	}
+	for _, channel := range gw.Channels {
+		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
+			continue
 		}
-		log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.FullOrigin, originchannel, dest.FullOrigin(), channel)
-		err := dest.Send(msg)
-		if err != nil {
-			fmt.Println(err)
+
+		// 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 {
-	// should we discard messages ?
-	for _, entry := range gw.ignoreNicks[msg.FullOrigin] {
+	// 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) modifyMessage(msg *config.Message, dest bridge.Bridge) {
-	val := reflect.ValueOf(gw.Config).Elem()
-	for i := 0; i < val.NumField(); i++ {
-		typeField := val.Type().Field(i)
-		// look for the protocol map (both lowercase)
-		if strings.ToLower(typeField.Name) == dest.Protocol() {
-			// get the Protocol struct from the map
-			protoCfg := val.Field(i).MapIndex(reflect.ValueOf(dest.Origin()))
-			//config.SetNickFormat(msg, protoCfg.Interface().(config.Protocol))
-			val.Field(i).SetMapIndex(reflect.ValueOf(dest.Origin()), protoCfg)
+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

@@ -1,103 +1,28 @@
 package samechannelgateway
 
 import (
-	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	"strings"
 )
 
 type SameChannelGateway struct {
 	*config.Config
-	MyConfig    *config.SameChannelGateway
-	Bridges     []bridge.Bridge
-	Channels    []string
-	ignoreNicks map[string][]string
-	Name        string
 }
 
-func New(cfg *config.Config, gateway *config.SameChannelGateway) error {
-	c := make(chan config.Message)
-	gw := &SameChannelGateway{}
-	gw.Name = gateway.Name
-	gw.Config = cfg
-	gw.MyConfig = gateway
-	gw.Channels = gateway.Channels
-	for _, account := range gateway.Accounts {
-		br := config.Bridge{Account: account}
-		log.Infof("Starting bridge: %s", account)
-		gw.Bridges = append(gw.Bridges, bridge.New(cfg, &br, c))
-	}
-	for _, br := range gw.Bridges {
-		err := br.Connect()
-		if err != nil {
-			log.Fatalf("Bridge %s failed to start: %v", br.FullOrigin(), err)
-		}
-		for _, channel := range gw.Channels {
-			log.Infof("%s: joining %s", br.FullOrigin(), channel)
-			br.JoinChannel(channel)
-		}
-	}
-	gw.handleReceive(c)
-	return nil
+func New(cfg *config.Config) *SameChannelGateway {
+	return &SameChannelGateway{Config: cfg}
 }
 
-func (gw *SameChannelGateway) handleReceive(c chan config.Message) {
-	for {
-		select {
-		case msg := <-c:
-			for _, br := range gw.Bridges {
-				gw.handleMessage(msg, br)
+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)
 	}
-}
-
-func (gw *SameChannelGateway) handleMessage(msg config.Message, dest bridge.Bridge) {
-	// is this a configured channel
-	if !gw.validChannel(msg.Channel) {
-		return
-	}
-	// do not send the message to the bridge we come from if also the channel is the same
-	if msg.FullOrigin == dest.FullOrigin() {
-		return
-	}
-	gw.modifyMessage(&msg, dest)
-	log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.FullOrigin, msg.Channel, dest.FullOrigin(), msg.Channel)
-	err := dest.Send(msg)
-	if err != nil {
-		log.Error(err)
-	}
-}
-
-func setNickFormat(msg *config.Message, format string) {
-	if format == "" {
-		msg.Username = msg.Protocol + "." + msg.Origin + "-" + msg.Username + ": "
-		return
-	}
-	msg.Username = strings.Replace(format, "{NICK}", msg.Username, -1)
-	msg.Username = strings.Replace(msg.Username, "{BRIDGE}", msg.Origin, -1)
-	msg.Username = strings.Replace(msg.Username, "{PROTOCOL}", msg.Protocol, -1)
-}
-
-func (gw *SameChannelGateway) modifyMessage(msg *config.Message, dest bridge.Bridge) {
-	switch dest.Protocol() {
-	case "irc":
-		setNickFormat(msg, gw.Config.IRC[dest.Origin()].RemoteNickFormat)
-	case "mattermost":
-		setNickFormat(msg, gw.Config.Mattermost[dest.Origin()].RemoteNickFormat)
-	case "slack":
-		setNickFormat(msg, gw.Config.Slack[dest.Origin()].RemoteNickFormat)
-	case "discord":
-		setNickFormat(msg, gw.Config.Discord[dest.Origin()].RemoteNickFormat)
-	}
-}
-
-func (gw *SameChannelGateway) validChannel(channel string) bool {
-	for _, c := range gw.Channels {
-		if c == channel {
-			return true
-		}
-	}
-	return false
+	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,287 +0,0 @@
-#This is configuration for matterbridge.
-###################################################################
-#IRC section
-###################################################################
-[IRC]
-#Enable enables this bridge
-#OPTIONAL (default false)
-Enable=true
-#irc server to connect to. 
-#REQUIRED
-Server="irc.freenode.net:6667"
-
-#Enable to use TLS connection to your irc server. 
-#OPTIONAL (default false)
-UseTLS=false
-
-#Enable SASL (PLAIN) authentication. (freenode requires this from eg AWS hosts)
-#It uses NickServNick and NickServPassword as login and password
-#OPTIONAL (default false)
-UseSASL=false
-
-#Enable to not verify the certificate on your irc server. i
-#e.g. when using selfsigned certificates
-#OPTIONAL (default false)
-SkipTLSVerify=true
-
-#Your nick on irc. 
-#REQUIRED
-Nick="matterbot"
-
-#If you registered your bot with a service like Nickserv on freenode. 
-#Also being used when UseSASL=true
-#OPTIONAL
-NickServNick="nickserv"
-NickServPassword="secret"
-
-#RemoteNickFormat defines how remote users appear on this bridge 
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
-#OPTIONAL (default {BRIDGE}-{NICK})
-RemoteNickFormat="[{BRIDGE}] <{NICK}> "
-
-#Nicks you want to ignore. 
-#Messages from those users will not be sent to other bridges.
-#OPTIONAL
-IgnoreNicks="ircspammer1 ircspammer2"
-
-###################################################################
-#XMPP section
-###################################################################
-[XMPP]
-#Enable enables this bridge
-#OPTIONAL (default false)
-Enable=true
-
-#xmpp server to connect to. 
-#REQUIRED
-Server="jabber.example.com:5222"
-
-#Jid
-#REQUIRED
-Jid="user@example.com"
-
-#Password
-#REQUIRED
-Password="yourpass"
-
-#MUC
-#REQUIRED
-Muc="conference.jabber.example.com"
-
-#Your nick in the rooms
-#REQUIRED
-Nick="xmppbot"
-
-
-###################################################################
-#mattermost section
-###################################################################
-
-[mattermost]
-#Enable enables this bridge
-#OPTIONAL (default false)
-Enable=true
-
-#### Settings for webhook matterbridge.
-#### These settings will not be used when using -plus switch which doesn't use 
-#### webhooks.
-
-#Url is your incoming webhook url as specified in mattermost. 
-#See account settings - integrations - incoming webhooks on mattermost.
-#REQUIRED
-URL="https://yourdomain/hooks/yourhookkey"
-
-#Address to listen on for outgoing webhook requests from mattermost.
-#See account settings - integrations - outgoing webhooks on mattermost.
-#This setting will not be used when using -plus switch which doesn't use 
-#webhooks
-#REQUIRED
-BindAddress="0.0.0.0:9999"
-
-#Icon that will be showed in mattermost. 
-#OPTIONAL
-IconURL="http://youricon.png"
-
-#### Settings for matterbridge -plus
-#### Thse settings will only be used when using the -plus switch.
-
-#The mattermost hostname. 
-#REQUIRED
-Server="yourmattermostserver.domain"
-
-#Your team on mattermost. 
-#REQUIRED
-Team="yourteam"
-
-#login/pass of your bot. 
-#Use a dedicated user for this and not your own! 
-#REQUIRED
-Login="yourlogin"
-Password="yourpass"
-
-#Enable this to make a http connection (instead of https) to your mattermost. 
-#OPTIONAL (default false)
-NoTLS=false
-
-#### Shared settings for matterbridge and -plus
-
-#Enable to not verify the certificate on your mattermost server. 
-#e.g. when using selfsigned certificates
-#OPTIONAL (default false)
-SkipTLSVerify=true
-
-#Enable to show IRC joins/parts in mattermost. 
-#OPTIONAL (default false)
-ShowJoinPart=false
-
-#Whether to prefix messages from other bridges to mattermost with the sender's nick. 
-#Useful if username overrides for incoming webhooks isn't enabled on the 
-#mattermost server. If you set PrefixMessagesWithNick to true, each message 
-#from bridge to Mattermost will by default be prefixed by "bridge-" + nick. You can, 
-#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
-#OPTIONAL (default false)
-PrefixMessagesWithNick=false
-
-#RemoteNickFormat defines how remote users appear on this bridge 
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
-#OPTIONAL (default {BRIDGE}-{NICK})
-RemoteNickFormat="[{BRIDGE}] <{NICK}> "
-
-#how to format the list of IRC nicks when displayed in mattermost. 
-#Possible options are "table" and "plain"
-#OPTIONAL (default plain)
-NickFormatter=plain
-#How many nicks to list per row for formatters that support this. 
-#OPTIONAL (default 4)
-NicksPerRow=4
-
-#Nicks you want to ignore. Messages from those users will not be bridged.
-#OPTIONAL 
-IgnoreNicks="mmbot spammer2"
-
-###################################################################
-#Gitter section
-#Best to make a dedicated gitter account for the bot.
-###################################################################
-[Gitter]
-#Enable enables this bridge
-#OPTIONAL (default false)
-Enable=true
-
-#Token to connect with Gitter API
-#You can get your token by going to https://developer.gitter.im/docs/welcome and SIGN IN
-#REQUIRED
-Token="Yourtokenhere"
-
-#Nicks you want to ignore. Messages of those users will not be bridged.
-#OPTIONAL 
-IgnoreNicks="spammer1 spammer2"
-
-#RemoteNickFormat defines how remote users appear on this bridge 
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
-#OPTIONAL (default {BRIDGE}-{NICK})
-RemoteNickFormat="[{BRIDGE}] <{NICK}> "
-
-###################################################################
-#slack section
-###################################################################
-
-[slack]
-#Enable enables this bridge
-#OPTIONAL (default false)
-Enable=true
-
-#### Settings for webhook matterbridge.
-#### These settings will not be used when useAPI is enabled
-
-#Url is your incoming webhook url as specified in slack
-#See account settings - integrations - incoming webhooks on slack
-#REQUIRED (unless useAPI=true)
-URL="https://hooks.slack.com/services/yourhook"
-
-#Address to listen on for outgoing webhook requests from slack
-#See account settings - integrations - outgoing webhooks on slack
-#This setting will not be used when useAPI is eanbled
-#webhooks
-#REQUIRED (unless useAPI=true)
-BindAddress="0.0.0.0:9999"
-
-#Icon that will be showed in slack
-#OPTIONAL
-IconURL="http://youricon.png"
-
-#### Settings for using slack API
-#OPTIONAL
-useAPI=false
-
-#Token to connect with the Slack API
-#REQUIRED (when useAPI=true)
-Token="yourslacktoken"
-
-#### Shared settings for webhooks and API
-
-#Whether to prefix messages from other bridges to mattermost with the sender's nick. 
-#Useful if username overrides for incoming webhooks isn't enabled on the 
-#slack server. If you set PrefixMessagesWithNick to true, each message 
-#from bridge to Slack will by default be prefixed by "bridge-" + nick. You can, 
-#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
-#OPTIONAL (default false)
-PrefixMessagesWithNick=false
-
-#RemoteNickFormat defines how remote users appear on this bridge 
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
-#OPTIONAL (default {BRIDGE}-{NICK})
-RemoteNickFormat="[{BRIDGE}] <{NICK}> 
-
-#how to format the list of IRC nicks when displayed in slack
-#Possible options are "table" and "plain"
-#OPTIONAL (default plain)
-NickFormatter=plain
-#How many nicks to list per row for formatters that support this. 
-#OPTIONAL (default 4)
-NicksPerRow=4
-
-#Nicks you want to ignore. Messages from those users will not be bridged.
-#OPTIONAL 
-IgnoreNicks="mmbot spammer2"
-
-###################################################################
-#multiple channel config
-###################################################################
-#You can specify multiple channels. 
-#The name is just an identifier for you.
-#REQUIRED (at least 1 channel)
-[Channel "channel1"] 
-#Choose the IRC channel to send messages to.
-IRC="#off-topic"
-#Choose the mattermost channel to messages to.
-mattermost="off-topic"
-#Choose the xmpp channel to send messages to.
-xmpp="off-topic"
-#Choose the Gitter channel to send messages to.
-#Gitter channels are named "user/repo"
-gitter="42wim/matterbridge"
-#Choose the slack channel to send messages to.
-slack="general"
-
-[Channel "testchannel"]
-IRC="#testing"
-mattermost="testing"
-xmpp="testing"
-gitter="user/repo"
-slack="testing"
-
-###################################################################
-#general
-###################################################################
-[general]
-#request your API key on https://github.com/giphy/GiphyAPI. This is a public beta key. 
-#OPTIONAL
-GiphyApiKey="dc6zaTOxFJmzC"
-
-#Enabling plus means you'll use the API version instead of the webhooks one
-Plus=false

matterbridge.go

@@ -3,58 +3,56 @@ package main
 import (
 	"flag"
 	"fmt"
+	"os"
+	"strings"
+
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/gateway"
-	"github.com/42wim/matterbridge/gateway/samechannel"
-	log "github.com/Sirupsen/logrus"
+	"github.com/google/gops/agent"
+	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/sirupsen/logrus"
 )
 
-var version = "0.8.0"
-
-func init() {
-	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
-}
+var (
+	version = "1.11.2"
+	githash string
+)
 
 func main() {
+	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()
+	if *flagGops {
+		agent.Listen(&agent.Options{})
+		defer agent.Close()
+	}
 	if *flagVersion {
-		fmt.Println("version:", version)
+		fmt.Printf("version: %s %s\n", version, githash)
 		return
 	}
-	flag.Parse()
-	if *flagDebug {
-		log.Info("enabling debug")
+	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)
 	}
-	fmt.Println("running version", version)
+	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)
-	for _, gw := range cfg.SameChannelGateway {
-		if !gw.Enable {
-			continue
-		}
-		fmt.Printf("starting samechannel gateway %#v\n", gw.Name)
-		go func(gw config.SameChannelGateway) {
-			err := samechannelgateway.New(cfg, &gw)
-			if err != nil {
-				log.Debugf("starting gateway failed %#v", err)
-			}
-		}(gw)
+	cfg.General.Debug = *flagDebug
+	r, err := gateway.NewRouter(cfg)
+	if err != nil {
+		flog.Fatalf("Starting gateway failed: %s", err)
 	}
-
-	for _, gw := range cfg.Gateway {
-		if !gw.Enable {
-			continue
-		}
-		fmt.Printf("starting gateway %#v\n", gw.Name)
-		go func(gw config.Gateway) {
-			err := gateway.New(cfg, &gw)
-			if err != nil {
-				log.Debugf("starting gateway failed %#v", err)
-			}
-		}(gw)
+	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

@@ -1,3 +1,4 @@
+#WARNING: as this file contains credentials, be sure to set correct file permissions
 [irc]
     [irc.freenode]
     Server="irc.freenode.net:6667"
@@ -5,7 +6,7 @@
 
 [mattermost]
     [mattermost.work]
-    useAPI=true
+    #do not prefix it wit http:// or https://
     Server="yourmattermostserver.domain" 
     Team="yourteam"
     Login="yourlogin"
@@ -15,18 +16,19 @@
 [[gateway]]
 name="gateway1"
 enable=true
-    [[gateway.in]]
+    [[gateway.inout]]
     account="irc.freenode"
     channel="#testing"
 
-    [[gateway.in]]
+    [[gateway.inout]]
     account="mattermost.work"
     channel="off-topic"
     
-    [[gateway.out]]
-    account="irc.freenode"
-    channel="#testing"
-
-    [[gateway.out]]
-    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

@@ -1,9 +1,11 @@
 package matterclient
 
 import (
+	"crypto/md5"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
 	"net/http/cookiejar"
 	"net/url"
@@ -11,9 +13,11 @@ import (
 	"sync"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
+	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"
 )
@@ -34,42 +38,52 @@ type Message struct {
 	Channel  string
 	Username string
 	Text     string
+	Type     string
+	UserID   string
 }
 
 type Team struct {
 	Team         *model.Team
 	Id           string
-	Channels     *model.ChannelList
-	MoreChannels *model.ChannelList
+	Channels     []*model.Channel
+	MoreChannels []*model.Channel
 	Users        map[string]*model.User
 }
 
 type MMClient struct {
 	sync.RWMutex
 	*Credentials
-	Team        *Team
-	OtherTeams  []*Team
-	Client      *model.Client
-	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
+	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)}
-	mmclient.log = log.WithFields(log.Fields{"module": "matterclient"})
-	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
+	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 {
@@ -80,6 +94,11 @@ func (m *MMClient) SetLogLevel(level string) {
 }
 
 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
@@ -90,46 +109,66 @@ func (m *MMClient) Login() error {
 		Jitter: true,
 	}
 	uriScheme := "https://"
-	wsScheme := "wss://"
 	if m.NoTLS {
 		uriScheme = "http://"
-		wsScheme = "ws://"
 	}
 	// login to mattermost
-	m.Client = model.NewClient(uriScheme + m.Credentials.Server)
-	m.Client.HttpClient.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
-	var myinfo *model.Result
+	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 %s", 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.MockSession(token[1])
-			myinfo, appErr = m.Client.GetMe("")
-			if appErr != nil {
-				return errors.New(appErr.DetailedError)
+			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 myinfo.Data.(*model.User) == nil {
+			if m.User == nil {
 				m.log.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
 				return errors.New("invalid " + model.SESSION_COOKIE_TOKEN)
 			}
 		} else {
-			myinfo, appErr = m.Client.Login(m.Credentials.Login, m.Credentials.Pass)
+			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)
-			//TODO more generic fix needed
-			if !strings.Contains(appErr.DetailedError, "connection refused") &&
-				!strings.Contains(appErr.DetailedError, "invalid character") &&
-				!strings.Contains(appErr.DetailedError, "connection reset by peer") &&
-				!strings.Contains(appErr.DetailedError, "connection timed out") {
+			if firstConnection {
 				if appErr.Message == "" {
 					return errors.New(appErr.DetailedError)
 				}
@@ -151,19 +190,40 @@ func (m *MMClient) Login() error {
 	}
 
 	if m.Team == nil {
-		return errors.New("team not found")
+		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://"
 	}
-	// set our team id as default route
-	m.Client.SetTeamId(m.Team.Id)
 
 	// setup websocket connection
-	wsurl := wsScheme + m.Credentials.Server + model.API_URL_SUFFIX + "/users/websocket"
+	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.Debug("WsClient: making connection")
+	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()
@@ -173,14 +233,12 @@ func (m *MMClient) Login() error {
 		}
 		break
 	}
-	b.Reset()
 
+	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
-
-	return nil
 }
 
 func (m *MMClient) Logout() error {
@@ -188,9 +246,13 @@ func (m *MMClient) Logout() error {
 	m.WsQuit = true
 	m.WsClient.Close()
 	m.WsClient.UnderlyingConn().Close()
-	_, err := m.Client.Logout()
-	if err != nil {
-		return err
+	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
 }
@@ -213,21 +275,31 @@ func (m *MMClient) WsReceiver() {
 		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
 			m.log.Error("error:", err)
 			// reconnect
-			m.Login()
+			m.wsConnect()
 		}
 
 		var event model.WebSocketEvent
 		if err := json.Unmarshal(rawMsg, &event); err == nil && event.IsValid() {
-			m.log.Debugf("WsReceiver: %#v", event)
+			m.log.Debugf("WsReceiver event: %#v", event)
 			msg := &Message{Raw: &event, Team: m.Credentials.Team}
 			m.parseMessage(msg)
-			m.MessageChan <- 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: %#v", response)
+			m.log.Debugf("WsReceiver response: %#v", response)
 			m.parseResponse(response)
 			continue
 		}
@@ -236,8 +308,13 @@ func (m *MMClient) WsReceiver() {
 
 func (m *MMClient) parseMessage(rmsg *Message) {
 	switch rmsg.Raw.Event {
-	case model.WEBSOCKET_EVENT_POSTED:
+	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)
@@ -257,46 +334,70 @@ func (m *MMClient) parseResponse(rmsg model.WebSocketResponse) {
 }
 
 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.UpdateUsers()
+		m.log.Infof("User %s is not known, ignoring message %s", data)
+		return
 	}
-	rmsg.Username = m.GetUser(data.UserId).Username
+	rmsg.Username = m.GetUserName(data.UserId)
 	rmsg.Channel = m.GetChannelName(data.ChannelId)
-	rmsg.Team = m.GetTeamName(rmsg.Raw.Data["team_id"].(string))
+	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
-	return
 }
 
 func (m *MMClient) UpdateUsers() error {
-	mmusers, err := m.Client.GetProfiles(0, 1000, "")
-	if err != nil {
-		return errors.New(err.DetailedError)
+	mmusers, resp := m.Client.GetUsers(0, 50000, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
 	}
 	m.Lock()
-	m.Users = mmusers.Data.(map[string]*model.User)
+	for _, user := range mmusers {
+		m.Users[user.Id] = user
+	}
 	m.Unlock()
 	return nil
 }
 
 func (m *MMClient) UpdateChannels() error {
-	mmchannels, err := m.Client.GetChannels("")
-	if err != nil {
-		return errors.New(err.DetailedError)
-	}
-	mmchannels2, err := m.Client.GetMoreChannels("")
-	if err != nil {
-		return errors.New(err.DetailedError)
+	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.Data.(*model.ChannelList)
-	m.Team.MoreChannels = mmchannels2.Data.(*model.ChannelList)
+	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
 }
@@ -305,9 +406,21 @@ func (m *MMClient) GetChannelName(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.Name
+		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
+				}
 			}
 		}
 	}
@@ -322,7 +435,7 @@ func (m *MMClient) GetChannelId(name string, teamId string) string {
 	}
 	for _, t := range m.OtherTeams {
 		if t.Id == teamId {
-			for _, channel := range append(*t.Channels, *t.MoreChannels...) {
+			for _, channel := range append(t.Channels, t.MoreChannels...) {
 				if channel.Name == name {
 					return channel.Id
 				}
@@ -332,11 +445,24 @@ func (m *MMClient) GetChannelId(name string, teamId string) string {
 	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...) {
+		for _, channel := range append(t.Channels, t.MoreChannels...) {
 			if channel.Id == channelId {
 				return channel.Header
 			}
@@ -346,55 +472,85 @@ func (m *MMClient) GetChannelHeader(channelId string) string {
 	return ""
 }
 
-func (m *MMClient) PostMessage(channelId string, text string) {
+func (m *MMClient) PostMessage(channelId string, text string) (string, error) {
 	post := &model.Post{ChannelId: channelId, Message: text}
-	m.Client.CreatePost(post)
+	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 {
+	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)
-	_, err := m.Client.JoinChannel(channelId)
-	if err != nil {
-		return errors.New("failed to join")
+	_, 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, err := m.Client.GetPostsSince(channelId, time)
-	if err != nil {
+	res, resp := m.Client.GetPostsSince(channelId, time)
+	if resp.Error != nil {
 		return nil
 	}
-	return res.Data.(*model.PostList)
+	return res
 }
 
 func (m *MMClient) SearchPosts(query string) *model.PostList {
-	res, err := m.Client.SearchPosts(query, false)
-	if err != nil {
+	res, resp := m.Client.SearchPosts(m.Team.Id, query, false)
+	if resp.Error != nil {
 		return nil
 	}
-	return res.Data.(*model.PostList)
+	return res
 }
 
 func (m *MMClient) GetPosts(channelId string, limit int) *model.PostList {
-	res, err := m.Client.GetPosts(channelId, 0, limit, "")
-	if err != nil {
+	res, resp := m.Client.GetPostsForChannel(channelId, 0, limit, "")
+	if resp.Error != nil {
 		return nil
 	}
-	return res.Data.(*model.PostList)
+	return res
 }
 
 func (m *MMClient) GetPublicLink(filename string) string {
-	res, err := m.Client.GetPublicLink(filename)
-	if err != nil {
+	res, resp := m.Client.GetFileLink(filename)
+	if resp.Error != nil {
 		return ""
 	}
 	return res
@@ -403,8 +559,27 @@ func (m *MMClient) GetPublicLink(filename string) string {
 func (m *MMClient) GetPublicLinks(filenames []string) []string {
 	var output []string
 	for _, f := range filenames {
-		res, err := m.Client.GetPublicLink(f)
-		if err != nil {
+		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)
@@ -413,36 +588,43 @@ func (m *MMClient) GetPublicLinks(filenames []string) []string {
 }
 
 func (m *MMClient) UpdateChannelHeader(channelId string, header string) {
-	data := make(map[string]string)
-	data["channel_id"] = channelId
-	data["channel_header"] = header
+	channel := &model.Channel{Id: channelId, Header: header}
 	m.log.Debugf("updating channelheader %#v, %#v", channelId, header)
-	_, err := m.Client.UpdateChannelHeader(data)
-	if err != nil {
-		log.Error(err)
+	_, 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)
-	_, err := m.Client.UpdateLastViewedAt(channelId, true)
-	if err != nil {
-		m.log.Error(err)
+	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, err := m.Client.GetMyChannelMembers()
-	if err != nil {
-		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, err)
+	res, resp := m.Client.GetChannelMembers(channelId, 0, 50000, "")
+	if resp.Error != nil {
+		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, resp.Error)
 		return []string{}
 	}
-	members := res.Data.(*model.ChannelMembers)
+	allusers := m.GetUsers()
 	result := []string{}
-	for _, channel := range *members {
-		if channel.ChannelId == channelId {
-			result = append(result, m.GetUser(channel.UserId).Username)
-		}
+	for _, member := range *res {
+		result = append(result, allusers[member.UserId].Nickname)
 	}
 	return result
 }
@@ -466,17 +648,15 @@ func (m *MMClient) createCookieJar(token string) *cookiejar.Jar {
 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)
-	_, err := m.Client.CreateDirectChannel(toUserId)
-	if err != nil {
-		m.log.Debugf("SendDirectMessage to %#v failed: %s", toUserId, err)
+	_, 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
-	mmchannels, _ := m.Client.GetChannels("")
-	m.Lock()
-	m.Team.Channels = mmchannels.Data.(*model.ChannelList)
-	m.Unlock()
+	m.UpdateChannels()
 
 	// build & send the message
 	msg = strings.Replace(msg, "\r", "", -1)
@@ -502,10 +682,10 @@ func (m *MMClient) GetChannels() []*model.Channel {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	// our primary team channels first
-	channels = append(channels, *m.Team.Channels...)
+	channels = append(channels, m.Team.Channels...)
 	for _, t := range m.OtherTeams {
 		if t.Id != m.Team.Id {
-			channels = append(channels, *t.Channels...)
+			channels = append(channels, t.Channels...)
 		}
 	}
 	return channels
@@ -517,7 +697,7 @@ func (m *MMClient) GetMoreChannels() []*model.Channel {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	for _, t := range m.OtherTeams {
-		channels = append(channels, *t.MoreChannels...)
+		channels = append(channels, t.MoreChannels...)
 	}
 	return channels
 }
@@ -528,8 +708,10 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	for _, t := range m.OtherTeams {
-		channels = append(channels, *t.Channels...)
-		channels = append(channels, *t.MoreChannels...)
+		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
@@ -542,14 +724,11 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 func (m *MMClient) GetLastViewedAt(channelId string) int64 {
 	m.RLock()
 	defer m.RUnlock()
-	/*
-		for _, t := range m.OtherTeams {
-			if _, ok := t.Channels.Members[channelId]; ok {
-				return t.Channels.Members[channelId].LastViewedAt
-			}
-		}
-	*/
-	return 0
+	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 {
@@ -563,31 +742,108 @@ func (m *MMClient) GetUsers() map[string]*model.User {
 }
 
 func (m *MMClient) GetUser(userId string) *model.User {
-	m.RLock()
-	defer m.RUnlock()
+	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, err := m.Client.GetStatuses()
-	if err != nil {
+	res, resp := m.Client.GetUserStatus(userId, "")
+	if resp.Error != nil {
 		return ""
 	}
-	status := res.Data.(map[string]string)
-	if status[userId] == model.STATUS_AWAY {
+	if res.Status == model.STATUS_AWAY {
 		return "away"
 	}
-	if status[userId] == model.STATUS_ONLINE {
+	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
@@ -598,13 +854,28 @@ func (m *MMClient) StatusLoop() {
 			select {
 			case <-m.WsPingChan:
 				m.log.Debug("WS PONG received")
+				backoff = time.Second * 60
 			case <-time.After(time.Second * 5):
-				m.Logout()
-				m.WsQuit = false
-				m.Login()
+				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(time.Second * 60)
+		time.Sleep(backoff)
 	}
 }
 
@@ -612,27 +883,39 @@ func (m *MMClient) StatusLoop() {
 func (m *MMClient) initUser() error {
 	m.Lock()
 	defer m.Unlock()
-	initLoad, err := m.Client.GetInitialLoad()
-	if err != nil {
-		return err
-	}
-	initData := initLoad.Data.(*model.InitialLoad)
-	m.User = initData.User
 	// 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")
-	for _, v := range initData.Teams {
-		m.Client.SetTeamId(v.Id)
-		mmusers, _ := m.Client.GetProfiles(0, 1000, "")
-		t := &Team{Team: v, Users: mmusers.Data.(map[string]*model.User), Id: v.Id}
-		mmchannels, _ := m.Client.GetChannels("")
-		t.Channels = mmchannels.Data.(*model.ChannelList)
-		mmchannels, _ = m.Client.GetMoreChannels("")
-		t.MoreChannels = mmchannels.Data.(*model.ChannelList)
+	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 v.Name == m.Credentials.Team {
+		if team.Name == m.Credentials.Team {
 			m.Team = t
-			m.log.Debugf("initUser(): found our team %s (id: %s)", v.Name, v.Id)
+			m.log.Debugf("initUser(): found our team %s (id: %s)", team.Name, team.Id)
 		}
 		// add all users
 		for k, v := range t.Users {
@@ -652,3 +935,18 @@ func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) err
 	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,23 +6,27 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"github.com/gorilla/schema"
 	"io"
 	"io/ioutil"
 	"log"
 	"net"
 	"net/http"
+	"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)
@@ -42,6 +46,7 @@ type IMessage struct {
 	ServiceId   string `schema:"service_id"`
 	Text        string `schema:"text"`
 	TriggerWord string `schema:"trigger_word"`
+	FileIDs     string `schema:"file_ids"`
 }
 
 // Client for Mattermost.
@@ -82,8 +87,14 @@ func New(url string, config Config) *Client {
 func (c *Client) StartServer() {
 	mux := http.NewServeMux()
 	mux.Handle("/", c)
+	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 := http.ListenAndServe(c.BindAddress, mux); err != nil {
+	if err := srv.ListenAndServe(); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -127,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.

migration.md

@@ -1,50 +0,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"
-```

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

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

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/gitter.go

@@ -127,7 +127,6 @@ func (gitter *Gitter) GetRooms() ([]Room, error) {
 
 // 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 {
@@ -206,17 +205,43 @@ func (gitter *Gitter) GetMessage(roomID, messageID string) (*Message, error) {
 }
 
 // SendMessage sends a message to a room
-func (gitter *Gitter) SendMessage(roomID, text string) error {
+func (gitter *Gitter) SendMessage(roomID, text string) (*Message, error) {
 
 	message := Message{Text: text}
 	body, _ := json.Marshal(message)
-	_, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
+	response, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
 	if err != nil {
 		gitter.log(err)
-		return err
+		return nil, err
 	}
 
-	return nil
+	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
@@ -259,6 +284,45 @@ func (gitter *Gitter) SetDebug(debug bool, logWriter io.Writer) {
 	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 {
 
@@ -376,6 +440,39 @@ func (gitter *Gitter) post(url string, body []byte) ([]byte, error) {
 	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 {

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

@@ -112,6 +112,7 @@ type Stream struct {
 
 func (stream *Stream) destroy() {
 	close(stream.Event)
+	stream.streamConnection.currentRetries = 0
 }
 
 type Event struct {
@@ -135,10 +136,11 @@ func (stream *Stream) connect() {
 	}
 
 	res, err := stream.gitter.getResponse(stream.url, stream)
-	if stream.streamConnection.canceled {
-		// do nothing
-	} else if err != nil || res.StatusCode != 200 {
-		stream.gitter.log("Failed to get response, trying reconnect ")
+	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
@@ -161,9 +163,6 @@ type streamConnection struct {
 	// connection was closed
 	closed bool
 
-	// canceled
-	canceled bool
-
 	// wait time till next try
 	wait time.Duration
 
@@ -192,13 +191,10 @@ func (stream *Stream) Close() {
 		stream.gitter.log("Stream connection close request")
 		switch transport := stream.gitter.config.client.Transport.(type) {
 		case *httpclient.Transport:
-			stream.streamConnection.canceled = true
 			transport.CancelRequest(conn.request)
 		default:
 		}
-
 	}
-	conn.currentRetries = 0
 }
 
 func (stream *Stream) isClosed() bool {

vendor/github.com/42wim/matterbridge-plus/bridge/bridge.go

@@ -1,434 +0,0 @@
-package bridge
-
-import (
-	"crypto/tls"
-	"github.com/42wim/matterbridge-plus/matterclient"
-	"github.com/42wim/matterbridge/matterhook"
-	log "github.com/Sirupsen/logrus"
-	"github.com/peterhellberg/giphy"
-	ircm "github.com/sorcix/irc"
-	"github.com/thoj/go-ircevent"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-//type Bridge struct {
-type MMhook struct {
-	mh *matterhook.Client
-}
-
-type MMapi struct {
-	mc            *matterclient.MMClient
-	mmMap         map[string]string
-	mmIgnoreNicks []string
-}
-
-type MMirc struct {
-	i              *irc.Connection
-	ircNick        string
-	ircMap         map[string]string
-	names          map[string][]string
-	ircIgnoreNicks []string
-}
-
-type MMMessage struct {
-	Text     string
-	Channel  string
-	Username string
-}
-
-type Bridge struct {
-	MMhook
-	MMapi
-	MMirc
-	*Config
-	kind string
-}
-
-type FancyLog struct {
-	irc *log.Entry
-	mm  *log.Entry
-}
-
-var flog FancyLog
-
-const Legacy = "legacy"
-
-func initFLog() {
-	flog.irc = log.WithFields(log.Fields{"module": "irc"})
-	flog.mm = log.WithFields(log.Fields{"module": "mattermost"})
-}
-
-func NewBridge(name string, config *Config, kind string) *Bridge {
-	initFLog()
-	b := &Bridge{}
-	b.Config = config
-	b.kind = kind
-	b.ircNick = b.Config.IRC.Nick
-	b.ircMap = make(map[string]string)
-	b.MMirc.names = make(map[string][]string)
-	b.ircIgnoreNicks = strings.Fields(b.Config.IRC.IgnoreNicks)
-	b.mmIgnoreNicks = strings.Fields(b.Config.Mattermost.IgnoreNicks)
-	if kind == Legacy {
-		if len(b.Config.Token) > 0 {
-			for _, val := range b.Config.Token {
-				b.ircMap[val.IRCChannel] = val.MMChannel
-			}
-		}
-
-		b.mh = 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})
-	} else {
-		b.mmMap = make(map[string]string)
-		if len(b.Config.Channel) > 0 {
-			for _, val := range b.Config.Channel {
-				b.ircMap[val.IRC] = val.Mattermost
-				b.mmMap[val.Mattermost] = val.IRC
-			}
-		}
-		b.mc = matterclient.New(b.Config.Mattermost.Login, b.Config.Mattermost.Password,
-			b.Config.Mattermost.Team, b.Config.Mattermost.Server)
-		b.mc.SkipTLSVerify = b.Config.Mattermost.SkipTLSVerify
-		b.mc.NoTLS = b.Config.Mattermost.NoTLS
-		flog.mm.Infof("Trying login %s (team: %s) on %s", b.Config.Mattermost.Login, b.Config.Mattermost.Team, b.Config.Mattermost.Server)
-		err := b.mc.Login()
-		if err != nil {
-			flog.mm.Fatal("Can not connect", err)
-		}
-		flog.mm.Info("Login ok")
-		b.mc.JoinChannel(b.Config.Mattermost.Channel)
-		if len(b.Config.Channel) > 0 {
-			for _, val := range b.Config.Channel {
-				b.mc.JoinChannel(val.Mattermost)
-			}
-		}
-		go b.mc.WsReceiver()
-	}
-	flog.irc.Info("Trying IRC connection")
-	b.i = b.createIRC(name)
-	flog.irc.Info("Connection succeeded")
-	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.AddCallback(ircm.RPL_WELCOME, b.handleNewConnection)
-	i.Connect(b.Config.IRC.Server + ":" + strconv.Itoa(b.Config.IRC.Port))
-	return i
-}
-
-func (b *Bridge) handleNewConnection(event *irc.Event) {
-	flog.irc.Info("Registering callbacks")
-	i := b.i
-	b.ircNick = event.Arguments[0]
-	i.AddCallback("PRIVMSG", b.handlePrivMsg)
-	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
-	i.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
-	i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
-	i.AddCallback(ircm.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
-	i.AddCallback(ircm.NOTICE, b.handleNotice)
-	i.AddCallback(ircm.RPL_MYINFO, func(e *irc.Event) { flog.irc.Infof("%s: %s", e.Code, strings.Join(e.Arguments[1:], " ")) })
-	i.AddCallback("PING", func(e *irc.Event) {
-		i.SendRaw("PONG :" + e.Message())
-		flog.irc.Debugf("PING/PONG")
-	})
-	if b.Config.Mattermost.ShowJoinPart {
-		i.AddCallback("JOIN", b.handleJoinPart)
-		i.AddCallback("PART", b.handleJoinPart)
-	}
-	i.AddCallback("*", b.handleOther)
-	b.setupChannels()
-}
-
-func (b *Bridge) setupChannels() {
-	i := b.i
-	if b.Config.IRC.Channel != "" {
-		flog.irc.Infof("Joining %s as %s", b.Config.IRC.Channel, b.ircNick)
-		i.Join(b.Config.IRC.Channel)
-	}
-	if b.kind == Legacy {
-		for _, val := range b.Config.Token {
-			flog.irc.Infof("Joining %s as %s", val.IRCChannel, b.ircNick)
-			i.Join(val.IRCChannel)
-		}
-	} else {
-		for _, val := range b.Config.Channel {
-			flog.irc.Infof("Joining %s as %s", val.IRC, b.ircNick)
-			i.Join(val.IRC)
-		}
-	}
-}
-
-func (b *Bridge) handleIrcBotCommand(event *irc.Event) bool {
-	parts := strings.Fields(event.Message())
-	exp, _ := regexp.Compile("[:,]+$")
-	channel := event.Arguments[0]
-	command := ""
-	if len(parts) == 2 {
-		command = parts[1]
-	}
-	if exp.ReplaceAllString(parts[0], "") == b.ircNick {
-		switch command {
-		case "users":
-			usernames := b.mc.UsernamesInChannel(b.getMMChannel(channel))
-			sort.Strings(usernames)
-			b.i.Privmsg(channel, "Users on Mattermost: "+strings.Join(usernames, ", "))
-		default:
-			b.i.Privmsg(channel, "Valid commands are: [users, help]")
-		}
-		return true
-	}
-	return false
-}
-
-func (b *Bridge) ircNickFormat(nick string) string {
-	if nick == b.ircNick {
-		return nick
-	}
-	if b.Config.Mattermost.RemoteNickFormat == nil {
-		return "irc-" + nick
-	}
-	return strings.Replace(*b.Config.Mattermost.RemoteNickFormat, "{NICK}", nick, -1)
-}
-
-func (b *Bridge) handlePrivMsg(event *irc.Event) {
-	if b.ignoreMessage(event.Nick, event.Message(), "irc") {
-		return
-	}
-	if b.handleIrcBotCommand(event) {
-		return
-	}
-	msg := ""
-	if event.Code == "CTCP_ACTION" {
-		msg = event.Nick + " "
-	}
-	msg += event.Message()
-	b.Send(b.ircNickFormat(event.Nick), msg, b.getMMChannel(event.Arguments[0]))
-}
-
-func (b *Bridge) handleJoinPart(event *irc.Event) {
-	b.Send(b.ircNick, b.ircNickFormat(event.Nick)+" "+strings.ToLower(event.Code)+"s "+event.Message(), b.getMMChannel(event.Arguments[0]))
-}
-
-func (b *Bridge) handleNotice(event *irc.Event) {
-	if strings.Contains(event.Message(), "This nickname is registered") {
-		b.i.Privmsg(b.Config.IRC.NickServNick, "IDENTIFY "+b.Config.IRC.NickServPassword)
-	}
-}
-
-func (b *Bridge) nicksPerRow() int {
-	if b.Config.Mattermost.NicksPerRow < 1 {
-		return 4
-	}
-	return b.Config.Mattermost.NicksPerRow
-}
-
-func (b *Bridge) formatnicks(nicks []string, continued bool) string {
-	switch b.Config.Mattermost.NickFormatter {
-	case "table":
-		return tableformatter(nicks, b.nicksPerRow(), continued)
-	default:
-		return plainformatter(nicks, b.nicksPerRow())
-	}
-}
-
-func (b *Bridge) storeNames(event *irc.Event) {
-	channel := event.Arguments[2]
-	b.MMirc.names[channel] = append(
-		b.MMirc.names[channel],
-		strings.Split(strings.TrimSpace(event.Message()), " ")...)
-}
-
-func (b *Bridge) endNames(event *irc.Event) {
-	channel := event.Arguments[1]
-	sort.Strings(b.MMirc.names[channel])
-	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
-	continued := false
-	for len(b.MMirc.names[channel]) > maxNamesPerPost {
-		b.Send(
-			b.ircNick,
-			b.formatnicks(b.MMirc.names[channel][0:maxNamesPerPost], continued),
-			b.getMMChannel(channel))
-		b.MMirc.names[channel] = b.MMirc.names[channel][maxNamesPerPost:]
-		continued = true
-	}
-	b.Send(b.ircNick, b.formatnicks(b.MMirc.names[channel], continued), b.getMMChannel(channel))
-	b.MMirc.names[channel] = nil
-}
-
-func (b *Bridge) handleTopicWhoTime(event *irc.Event) {
-	parts := strings.Split(event.Arguments[2], "!")
-	t, err := strconv.ParseInt(event.Arguments[3], 10, 64)
-	if err != nil {
-		flog.irc.Errorf("Invalid time stamp: %s", event.Arguments[3])
-	}
-	user := parts[0]
-	if len(parts) > 1 {
-		user += " [" + parts[1] + "]"
-	}
-	flog.irc.Infof("%s: Topic set by %s [%s]", event.Code, user, time.Unix(t, 0))
-}
-
-func (b *Bridge) handleOther(event *irc.Event) {
-	flog.irc.Debugf("%#v", event)
-}
-
-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 {
-	if b.Config.Mattermost.PrefixMessagesWithNick {
-		if IsMarkup(message) {
-			message = nick + "\n\n" + message
-		} else {
-			message = nick + " " + message
-		}
-	}
-	if b.kind == Legacy {
-		matterMessage := matterhook.OMessage{IconURL: b.Config.Mattermost.IconURL}
-		matterMessage.Channel = channel
-		matterMessage.UserName = nick
-		matterMessage.Type = mtype
-		matterMessage.Text = message
-		err := b.mh.Send(matterMessage)
-		if err != nil {
-			flog.mm.Info(err)
-			return err
-		}
-		return nil
-	}
-	flog.mm.Debug("->mattermost channel: ", channel, " ", message)
-	b.mc.PostMessage(channel, message)
-	return nil
-}
-
-func (b *Bridge) handleMatterHook(mchan chan *MMMessage) {
-	for {
-		message := b.mh.Receive()
-		m := &MMMessage{}
-		m.Username = message.UserName
-		m.Text = message.Text
-		m.Channel = message.Token
-		mchan <- m
-	}
-}
-
-func (b *Bridge) handleMatterClient(mchan chan *MMMessage) {
-	for message := range b.mc.MessageChan {
-		// do not post our own messages back to irc
-		if message.Raw.Action == "posted" && b.mc.User.Username != message.Username {
-			m := &MMMessage{}
-			m.Username = message.Username
-			m.Channel = message.Channel
-			m.Text = message.Text
-			flog.mm.Debugf("<-mattermost channel: %s %#v %#v", message.Channel, message.Post, message.Raw)
-			mchan <- m
-		}
-	}
-}
-
-func (b *Bridge) handleMatter() {
-	flog.mm.Infof("Choosing Mattermost connection type %s", b.kind)
-	mchan := make(chan *MMMessage)
-	if b.kind == Legacy {
-		go b.handleMatterHook(mchan)
-	} else {
-		go b.handleMatterClient(mchan)
-	}
-	flog.mm.Info("Start listening for Mattermost messages")
-	for message := range mchan {
-		var username string
-		if b.ignoreMessage(message.Username, message.Text, "mattermost") {
-			continue
-		}
-		username = message.Username + ": "
-		if b.Config.IRC.RemoteNickFormat != "" {
-			username = strings.Replace(b.Config.IRC.RemoteNickFormat, "{NICK}", message.Username, -1)
-		} else if b.Config.IRC.UseSlackCircumfix {
-			username = "<" + message.Username + "> "
-		}
-		cmds := strings.Fields(message.Text)
-		// empty message
-		if len(cmds) == 0 {
-			continue
-		}
-		cmd := cmds[0]
-		switch cmd {
-		case "!users":
-			flog.mm.Info("Received !users from ", message.Username)
-			b.i.SendRaw("NAMES " + b.getIRCChannel(message.Channel))
-			continue
-		case "!gif":
-			message.Text = b.giphyRandom(strings.Fields(strings.Replace(message.Text, "!gif ", "", 1)))
-			b.Send(b.ircNick, message.Text, b.getIRCChannel(message.Channel))
-			continue
-		}
-		texts := strings.Split(message.Text, "\n")
-		for _, text := range texts {
-			flog.mm.Debug("Sending message from " + message.Username + " to " + message.Channel)
-			b.i.Privmsg(b.getIRCChannel(message.Channel), 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.ircMap[ircChannel]
-	if !ok {
-		mmchannel = b.Config.Mattermost.Channel
-	}
-	return mmchannel
-}
-
-func (b *Bridge) getIRCChannel(channel string) string {
-	if b.kind == Legacy {
-		ircchannel := b.Config.IRC.Channel
-		_, ok := b.Config.Token[channel]
-		if ok {
-			ircchannel = b.Config.Token[channel].IRCChannel
-		}
-		return ircchannel
-	}
-	ircchannel, ok := b.mmMap[channel]
-	if !ok {
-		ircchannel = b.Config.IRC.Channel
-	}
-	return ircchannel
-}
-
-func (b *Bridge) ignoreMessage(nick string, message string, protocol string) bool {
-	var ignoreNicks = b.mmIgnoreNicks
-	if protocol == "irc" {
-		ignoreNicks = b.ircIgnoreNicks
-	}
-	// should we discard messages ?
-	for _, entry := range ignoreNicks {
-		if nick == entry {
-			return true
-		}
-	}
-	return false
-}

vendor/github.com/42wim/matterbridge-plus/bridge/config.go

@@ -1,68 +0,0 @@
-package bridge
-
-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
-		NickServNick      string
-		NickServPassword  string
-		RemoteNickFormat  string
-		IgnoreNicks       string
-	}
-	Mattermost struct {
-		URL                    string
-		Port                   int
-		ShowJoinPart           bool
-		Token                  string
-		IconURL                string
-		SkipTLSVerify          bool
-		BindAddress            string
-		Channel                string
-		PrefixMessagesWithNick bool
-		NicksPerRow            int
-		NickFormatter          string
-		Server                 string
-		Team                   string
-		Login                  string
-		Password               string
-		RemoteNickFormat       *string
-		IgnoreNicks            string
-		NoTLS                  bool
-	}
-	Token map[string]*struct {
-		IRCChannel string
-		MMChannel  string
-	}
-	Channel map[string]*struct {
-		IRC        string
-		Mattermost 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
-}

vendor/github.com/42wim/matterbridge-plus/bridge/helper.go

@@ -1,59 +0,0 @@
-package bridge
-
-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
-}

vendor/github.com/42wim/matterbridge-plus/matterclient/matterclient.go

@@ -1,441 +0,0 @@
-package matterclient
-
-import (
-	"crypto/tls"
-	"errors"
-	log "github.com/Sirupsen/logrus"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"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.Message
-	Post     *model.Post
-	Team     string
-	Channel  string
-	Username string
-	Text     string
-}
-
-type MMClient struct {
-	*Credentials
-	Client       *model.Client
-	WsClient     *websocket.Conn
-	WsQuit       bool
-	WsAway       bool
-	Channels     *model.ChannelList
-	MoreChannels *model.ChannelList
-	User         *model.User
-	Users        map[string]*model.User
-	MessageChan  chan *Message
-	Team         *model.Team
-	log          *log.Entry
-}
-
-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)}
-	mmclient.log = log.WithFields(log.Fields{"module": "matterclient"})
-	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
-	return mmclient
-}
-
-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 {
-	if m.WsQuit {
-		return nil
-	}
-	b := &backoff.Backoff{
-		Min:    time.Second,
-		Max:    5 * time.Minute,
-		Jitter: true,
-	}
-	uriScheme := "https://"
-	wsScheme := "wss://"
-	if m.NoTLS {
-		uriScheme = "http://"
-		wsScheme = "ws://"
-	}
-	// login to mattermost
-	m.Client = model.NewClient(uriScheme + m.Credentials.Server)
-	m.Client.HttpClient.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
-	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 ", model.SESSION_COOKIE_TOKEN)
-			token := strings.Split(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN+"=")
-			m.Client.HttpClient.Jar = m.createCookieJar(token[1])
-			m.Client.MockSession(token[1])
-			myinfo, appErr = m.Client.GetMe("")
-			if myinfo.Data.(*model.User) == nil {
-				m.log.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
-				return errors.New("invalid " + model.SESSION_COOKIE_TOKEN)
-			}
-		} else {
-			myinfo, appErr = m.Client.Login(m.Credentials.Login, m.Credentials.Pass)
-		}
-		if appErr != nil {
-			d := b.Duration()
-			m.log.Debug(appErr.DetailedError)
-			if !strings.Contains(appErr.DetailedError, "connection refused") &&
-				!strings.Contains(appErr.DetailedError, "invalid character") {
-				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()
-
-	initLoad, _ := m.Client.GetInitialLoad()
-	initData := initLoad.Data.(*model.InitialLoad)
-	m.User = initData.User
-	for _, v := range initData.Teams {
-		m.log.Debugf("trying %s (id: %s)", v.Name, v.Id)
-		if v.Name == m.Credentials.Team {
-			m.Client.SetTeamId(v.Id)
-			m.Team = v
-			m.log.Debugf("GetallTeamListings: found id %s for team %s", v.Id, v.Name)
-			break
-		}
-	}
-	if m.Team == nil {
-		return errors.New("team not found")
-	}
-
-	// setup websocket connection
-	wsurl := wsScheme + m.Credentials.Server + "/api/v3/users/websocket"
-	header := http.Header{}
-	header.Set(model.HEADER_AUTH, "BEARER "+m.Client.AuthToken)
-
-	m.log.Debug("WsClient: making connection")
-	var err error
-	for {
-		wsDialer := &websocket.Dialer{Proxy: http.ProxyFromEnvironment, TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
-		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
-	}
-	b.Reset()
-
-	// populating users
-	m.UpdateUsers()
-
-	// populating channels
-	m.UpdateChannels()
-
-	return nil
-}
-
-func (m *MMClient) WsReceiver() {
-	var rmsg model.Message
-	for {
-		if m.WsQuit {
-			m.log.Debug("exiting WsReceiver")
-			return
-		}
-		if err := m.WsClient.ReadJSON(&rmsg); err != nil {
-			m.log.Error("error:", err)
-			// reconnect
-			m.Login()
-		}
-		if rmsg.Action == "ping" {
-			m.handleWsPing()
-			continue
-		}
-		msg := &Message{Raw: &rmsg, Team: m.Credentials.Team}
-		m.parseMessage(msg)
-		m.MessageChan <- msg
-	}
-
-}
-
-func (m *MMClient) handleWsPing() {
-	m.log.Debug("Ws PING")
-	if !m.WsQuit && !m.WsAway {
-		m.log.Debug("Ws PONG")
-		m.WsClient.WriteMessage(websocket.PongMessage, []byte{})
-	}
-}
-
-func (m *MMClient) parseMessage(rmsg *Message) {
-	switch rmsg.Raw.Action {
-	case model.ACTION_POSTED:
-		m.parseActionPost(rmsg)
-		/*
-			case model.ACTION_USER_REMOVED:
-				m.handleWsActionUserRemoved(&rmsg)
-			case model.ACTION_USER_ADDED:
-				m.handleWsActionUserAdded(&rmsg)
-		*/
-	}
-}
-
-func (m *MMClient) parseActionPost(rmsg *Message) {
-	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Props["post"]))
-	//	log.Println("receiving userid", data.UserId)
-	// we don't have the user, refresh the userlist
-	if m.Users[data.UserId] == nil {
-		m.UpdateUsers()
-	}
-	rmsg.Username = m.Users[data.UserId].Username
-	rmsg.Channel = m.GetChannelName(data.ChannelId)
-	// direct message
-	if strings.Contains(rmsg.Channel, "__") {
-		//log.Println("direct message")
-		rcvusers := strings.Split(rmsg.Channel, "__")
-		if rcvusers[0] != m.User.Id {
-			rmsg.Channel = m.Users[rcvusers[0]].Username
-		} else {
-			rmsg.Channel = m.Users[rcvusers[1]].Username
-		}
-	}
-	rmsg.Text = data.Message
-	rmsg.Post = data
-	return
-}
-
-func (m *MMClient) UpdateUsers() error {
-	mmusers, _ := m.Client.GetProfilesForDirectMessageList(m.Team.Id)
-	m.Users = mmusers.Data.(map[string]*model.User)
-	return nil
-}
-
-func (m *MMClient) UpdateChannels() error {
-	mmchannels, _ := m.Client.GetChannels("")
-	m.Channels = mmchannels.Data.(*model.ChannelList)
-	mmchannels, _ = m.Client.GetMoreChannels("")
-	m.MoreChannels = mmchannels.Data.(*model.ChannelList)
-	return nil
-}
-
-func (m *MMClient) GetChannelName(id string) string {
-	for _, channel := range append(m.Channels.Channels, m.MoreChannels.Channels...) {
-		if channel.Id == id {
-			return channel.Name
-		}
-	}
-	// not found? could be a new direct message from mattermost. Try to update and check again
-	m.UpdateChannels()
-	for _, channel := range append(m.Channels.Channels, m.MoreChannels.Channels...) {
-		if channel.Id == id {
-			return channel.Name
-		}
-	}
-	return ""
-}
-
-func (m *MMClient) GetChannelId(name string) string {
-	for _, channel := range append(m.Channels.Channels, m.MoreChannels.Channels...) {
-		if channel.Name == name {
-			return channel.Id
-		}
-	}
-	return ""
-}
-
-func (m *MMClient) GetChannelHeader(id string) string {
-	for _, channel := range append(m.Channels.Channels, m.MoreChannels.Channels...) {
-		if channel.Id == id {
-			return channel.Header
-		}
-	}
-	return ""
-}
-
-func (m *MMClient) PostMessage(channel string, text string) {
-	post := &model.Post{ChannelId: m.GetChannelId(channel), Message: text}
-	m.Client.CreatePost(post)
-}
-
-func (m *MMClient) JoinChannel(channel string) error {
-	cleanChan := strings.Replace(channel, "#", "", 1)
-	if m.GetChannelId(cleanChan) == "" {
-		return errors.New("failed to join")
-	}
-	for _, c := range m.Channels.Channels {
-		if c.Name == cleanChan {
-			m.log.Debug("Not joining ", cleanChan, " already joined.")
-			return nil
-		}
-	}
-	m.log.Debug("Joining ", cleanChan)
-	_, err := m.Client.JoinChannel(m.GetChannelId(cleanChan))
-	if err != nil {
-		return errors.New("failed to join")
-	}
-	//	m.SyncChannel(m.getMMChannelId(strings.Replace(channel, "#", "", 1)), strings.Replace(channel, "#", "", 1))
-	return nil
-}
-
-func (m *MMClient) GetPostsSince(channelId string, time int64) *model.PostList {
-	res, err := m.Client.GetPostsSince(channelId, time)
-	if err != nil {
-		return nil
-	}
-	return res.Data.(*model.PostList)
-}
-
-func (m *MMClient) SearchPosts(query string) *model.PostList {
-	res, err := m.Client.SearchPosts(query, false)
-	if err != nil {
-		return nil
-	}
-	return res.Data.(*model.PostList)
-}
-
-func (m *MMClient) GetPosts(channelId string, limit int) *model.PostList {
-	res, err := m.Client.GetPosts(channelId, 0, limit, "")
-	if err != nil {
-		return nil
-	}
-	return res.Data.(*model.PostList)
-}
-
-func (m *MMClient) GetPublicLink(filename string) string {
-	res, err := m.Client.GetPublicLink(filename)
-	if err != nil {
-		return ""
-	}
-	return res.Data.(string)
-}
-
-func (m *MMClient) GetPublicLinks(filenames []string) []string {
-	var output []string
-	for _, f := range filenames {
-		res, err := m.Client.GetPublicLink(f)
-		if err != nil {
-			continue
-		}
-		output = append(output, res.Data.(string))
-	}
-	return output
-}
-
-func (m *MMClient) UpdateChannelHeader(channelId string, header string) {
-	data := make(map[string]string)
-	data["channel_id"] = channelId
-	data["channel_header"] = header
-	m.log.Debugf("updating channelheader %#v, %#v", channelId, header)
-	_, err := m.Client.UpdateChannelHeader(data)
-	if err != nil {
-		log.Error(err)
-	}
-}
-
-func (m *MMClient) UpdateLastViewed(channelId string) {
-	m.log.Debugf("posting lastview %#v", channelId)
-	_, err := m.Client.UpdateLastViewedAt(channelId)
-	if err != nil {
-		m.log.Error(err)
-	}
-}
-
-func (m *MMClient) UsernamesInChannel(channelName string) []string {
-	ceiRes, err := m.Client.GetChannelExtraInfo(m.GetChannelId(channelName), 5000, "")
-	if err != nil {
-		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelName, err)
-		return []string{}
-	}
-	extra := ceiRes.Data.(*model.ChannelExtra)
-	result := []string{}
-	for _, member := range extra.Members {
-		result = append(result, member.Username)
-	}
-	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
-}
-
-func (m *MMClient) GetOtherUserDM(channel string) *model.User {
-	m.UpdateUsers()
-	var rcvuser *model.User
-	if strings.Contains(channel, "__") {
-		rcvusers := strings.Split(channel, "__")
-		if rcvusers[0] != m.User.Id {
-			rcvuser = m.Users[rcvusers[0]]
-		} else {
-			rcvuser = m.Users[rcvusers[1]]
-		}
-	}
-	return rcvuser
-}
-
-func (m *MMClient) SendDirectMessage(toUserId string, msg string) {
-	m.log.Debugf("SendDirectMessage to %s, msg %s", toUserId, msg)
-	var channel string
-	// We don't have a DM with this user yet.
-	if m.GetChannelId(toUserId+"__"+m.User.Id) == "" && m.GetChannelId(m.User.Id+"__"+toUserId) == "" {
-		// create DM channel
-		_, err := m.Client.CreateDirectChannel(toUserId)
-		if err != nil {
-			m.log.Debugf("SendDirectMessage to %#v failed: %s", toUserId, err)
-		}
-		// update our channels
-		mmchannels, _ := m.Client.GetChannels("")
-		m.Channels = mmchannels.Data.(*model.ChannelList)
-	}
-
-	// build the channel name
-	if toUserId > m.User.Id {
-		channel = m.User.Id + "__" + toUserId
-	} else {
-		channel = toUserId + "__" + m.User.Id
-	}
-	// build & send the message
-	msg = strings.Replace(msg, "\r", "", -1)
-	post := &model.Post{ChannelId: m.GetChannelId(channel), Message: msg}
-	m.Client.CreatePost(post)
-}

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/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/cmd/toml-test-decoder/main.go

@@ -1,90 +0,0 @@
-// Command toml-test-decoder satisfies the toml-test interface for testing
-// TOML decoders. Namely, it accepts TOML on stdin and outputs JSON on stdout.
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"path"
-	"time"
-
-	"github.com/BurntSushi/toml"
-)
-
-func init() {
-	log.SetFlags(0)
-
-	flag.Usage = usage
-	flag.Parse()
-}
-
-func usage() {
-	log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
-	flag.PrintDefaults()
-
-	os.Exit(1)
-}
-
-func main() {
-	if flag.NArg() != 0 {
-		flag.Usage()
-	}
-
-	var tmp interface{}
-	if _, err := toml.DecodeReader(os.Stdin, &tmp); err != nil {
-		log.Fatalf("Error decoding TOML: %s", err)
-	}
-
-	typedTmp := translate(tmp)
-	if err := json.NewEncoder(os.Stdout).Encode(typedTmp); err != nil {
-		log.Fatalf("Error encoding JSON: %s", err)
-	}
-}
-
-func translate(tomlData interface{}) interface{} {
-	switch orig := tomlData.(type) {
-	case map[string]interface{}:
-		typed := make(map[string]interface{}, len(orig))
-		for k, v := range orig {
-			typed[k] = translate(v)
-		}
-		return typed
-	case []map[string]interface{}:
-		typed := make([]map[string]interface{}, len(orig))
-		for i, v := range orig {
-			typed[i] = translate(v).(map[string]interface{})
-		}
-		return typed
-	case []interface{}:
-		typed := make([]interface{}, len(orig))
-		for i, v := range orig {
-			typed[i] = translate(v)
-		}
-
-		// We don't really need to tag arrays, but let's be future proof.
-		// (If TOML ever supports tuples, we'll need this.)
-		return tag("array", typed)
-	case time.Time:
-		return tag("datetime", orig.Format("2006-01-02T15:04:05Z"))
-	case bool:
-		return tag("bool", fmt.Sprintf("%v", orig))
-	case int64:
-		return tag("integer", fmt.Sprintf("%d", orig))
-	case float64:
-		return tag("float", fmt.Sprintf("%v", orig))
-	case string:
-		return tag("string", orig)
-	}
-
-	panic(fmt.Sprintf("Unknown type: %T", tomlData))
-}
-
-func tag(typeName string, data interface{}) map[string]interface{} {
-	return map[string]interface{}{
-		"type":  typeName,
-		"value": data,
-	}
-}

vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/main.go

@@ -1,131 +0,0 @@
-// Command toml-test-encoder satisfies the toml-test interface for testing
-// TOML encoders. Namely, it accepts JSON on stdin and outputs TOML on stdout.
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"log"
-	"os"
-	"path"
-	"strconv"
-	"time"
-
-	"github.com/BurntSushi/toml"
-)
-
-func init() {
-	log.SetFlags(0)
-
-	flag.Usage = usage
-	flag.Parse()
-}
-
-func usage() {
-	log.Printf("Usage: %s < json-file\n", path.Base(os.Args[0]))
-	flag.PrintDefaults()
-
-	os.Exit(1)
-}
-
-func main() {
-	if flag.NArg() != 0 {
-		flag.Usage()
-	}
-
-	var tmp interface{}
-	if err := json.NewDecoder(os.Stdin).Decode(&tmp); err != nil {
-		log.Fatalf("Error decoding JSON: %s", err)
-	}
-
-	tomlData := translate(tmp)
-	if err := toml.NewEncoder(os.Stdout).Encode(tomlData); err != nil {
-		log.Fatalf("Error encoding TOML: %s", err)
-	}
-}
-
-func translate(typedJson interface{}) interface{} {
-	switch v := typedJson.(type) {
-	case map[string]interface{}:
-		if len(v) == 2 && in("type", v) && in("value", v) {
-			return untag(v)
-		}
-		m := make(map[string]interface{}, len(v))
-		for k, v2 := range v {
-			m[k] = translate(v2)
-		}
-		return m
-	case []interface{}:
-		tabArray := make([]map[string]interface{}, len(v))
-		for i := range v {
-			if m, ok := translate(v[i]).(map[string]interface{}); ok {
-				tabArray[i] = m
-			} else {
-				log.Fatalf("JSON arrays may only contain objects. This " +
-					"corresponds to only tables being allowed in " +
-					"TOML table arrays.")
-			}
-		}
-		return tabArray
-	}
-	log.Fatalf("Unrecognized JSON format '%T'.", typedJson)
-	panic("unreachable")
-}
-
-func untag(typed map[string]interface{}) interface{} {
-	t := typed["type"].(string)
-	v := typed["value"]
-	switch t {
-	case "string":
-		return v.(string)
-	case "integer":
-		v := v.(string)
-		n, err := strconv.Atoi(v)
-		if err != nil {
-			log.Fatalf("Could not parse '%s' as integer: %s", v, err)
-		}
-		return n
-	case "float":
-		v := v.(string)
-		f, err := strconv.ParseFloat(v, 64)
-		if err != nil {
-			log.Fatalf("Could not parse '%s' as float64: %s", v, err)
-		}
-		return f
-	case "datetime":
-		v := v.(string)
-		t, err := time.Parse("2006-01-02T15:04:05Z", v)
-		if err != nil {
-			log.Fatalf("Could not parse '%s' as a datetime: %s", v, err)
-		}
-		return t
-	case "bool":
-		v := v.(string)
-		switch v {
-		case "true":
-			return true
-		case "false":
-			return false
-		}
-		log.Fatalf("Could not parse '%s' as a boolean.", v)
-	case "array":
-		v := v.([]interface{})
-		array := make([]interface{}, len(v))
-		for i := range v {
-			if m, ok := v[i].(map[string]interface{}); ok {
-				array[i] = untag(m)
-			} else {
-				log.Fatalf("Arrays may only contain other arrays or "+
-					"primitive values, but found a '%T'.", m)
-			}
-		}
-		return array
-	}
-	log.Fatalf("Unrecognized tag type '%s'.", t)
-	panic("unreachable")
-}
-
-func in(key string, m map[string]interface{}) bool {
-	_, ok := m[key]
-	return ok
-}

vendor/github.com/BurntSushi/toml/cmd/tomlv/main.go

@@ -1,61 +0,0 @@
-// Command tomlv validates TOML documents and prints each key's type.
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"path"
-	"strings"
-	"text/tabwriter"
-
-	"github.com/BurntSushi/toml"
-)
-
-var (
-	flagTypes = false
-)
-
-func init() {
-	log.SetFlags(0)
-
-	flag.BoolVar(&flagTypes, "types", flagTypes,
-		"When set, the types of every defined key will be shown.")
-
-	flag.Usage = usage
-	flag.Parse()
-}
-
-func usage() {
-	log.Printf("Usage: %s toml-file [ toml-file ... ]\n",
-		path.Base(os.Args[0]))
-	flag.PrintDefaults()
-
-	os.Exit(1)
-}
-
-func main() {
-	if flag.NArg() < 1 {
-		flag.Usage()
-	}
-	for _, f := range flag.Args() {
-		var tmp interface{}
-		md, err := toml.DecodeFile(f, &tmp)
-		if err != nil {
-			log.Fatalf("Error in '%s': %s", f, err)
-		}
-		if flagTypes {
-			printTypes(md)
-		}
-	}
-}
-
-func printTypes(md toml.MetaData) {
-	tabw := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	for _, key := range md.Keys() {
-		fmt.Fprintf(tabw, "%s%s\t%s\n",
-			strings.Repeat("    ", len(key)-1), key, md.Type(key...))
-	}
-	tabw.Flush()
-}

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

@@ -4,7 +4,7 @@ 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/mojombo/toml
+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

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

@@ -241,7 +241,7 @@ func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
 func (enc *Encoder) eTable(key Key, rv reflect.Value) {
 	panicIfInvalidKey(key)
 	if len(key) == 1 {
-		// Output an extra new line between top-level tables.
+		// Output an extra newline between top-level tables.
 		// (The newline isn't written if nothing else has been written though.)
 		enc.newline()
 	}

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

@@ -30,24 +30,28 @@ const (
 	itemArrayTableEnd
 	itemKeyStart
 	itemCommentStart
+	itemInlineTableStart
+	itemInlineTableEnd
 )
 
 const (
-	eof             = 0
-	tableStart      = '['
-	tableEnd        = ']'
-	arrayTableStart = '['
-	arrayTableEnd   = ']'
-	tableSep        = '.'
-	keySep          = '='
-	arrayStart      = '['
-	arrayEnd        = ']'
-	arrayValTerm    = ','
-	commentStart    = '#'
-	stringStart     = '"'
-	stringEnd       = '"'
-	rawStringStart  = '\''
-	rawStringEnd    = '\''
+	eof              = 0
+	comma            = ','
+	tableStart       = '['
+	tableEnd         = ']'
+	arrayTableStart  = '['
+	arrayTableEnd    = ']'
+	tableSep         = '.'
+	keySep           = '='
+	arrayStart       = '['
+	arrayEnd         = ']'
+	commentStart     = '#'
+	stringStart      = '"'
+	stringEnd        = '"'
+	rawStringStart   = '\''
+	rawStringEnd     = '\''
+	inlineTableStart = '{'
+	inlineTableEnd   = '}'
 )
 
 type stateFn func(lx *lexer) stateFn
@@ -56,11 +60,18 @@ type lexer struct {
 	input string
 	start int
 	pos   int
-	width 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
@@ -88,7 +99,7 @@ func (lx *lexer) nextItem() item {
 
 func lex(input string) *lexer {
 	lx := &lexer{
-		input: input + "\n",
+		input: input,
 		state: lexTop,
 		line:  1,
 		items: make(chan item, 10),
@@ -103,7 +114,7 @@ func (lx *lexer) push(state stateFn) {
 
 func (lx *lexer) pop() stateFn {
 	if len(lx.stack) == 0 {
-		return lx.errorf("BUG in lexer: no states to pop.")
+		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]
@@ -125,16 +136,25 @@ func (lx *lexer) emitTrim(typ itemType) {
 }
 
 func (lx *lexer) next() (r rune) {
+	if lx.atEOF {
+		panic("next called after EOF")
+	}
 	if lx.pos >= len(lx.input) {
-		lx.width = 0
+		lx.atEOF = true
 		return eof
 	}
 
 	if lx.input[lx.pos] == '\n' {
 		lx.line++
 	}
-	r, lx.width = utf8.DecodeRuneInString(lx.input[lx.pos:])
-	lx.pos += lx.width
+	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
 }
 
@@ -143,9 +163,20 @@ func (lx *lexer) ignore() {
 	lx.start = lx.pos
 }
 
-// backup steps back one rune. Can be called only once per call of next.
+// backup steps back one rune. Can be called only twice between calls to next.
 func (lx *lexer) backup() {
-	lx.pos -= lx.width
+	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--
 	}
@@ -182,7 +213,7 @@ func (lx *lexer) skip(pred func(rune) bool) {
 
 // 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 (new lines, tabs, etc.).
+// character (newlines, tabs, etc.).
 func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
 	lx.items <- item{
 		itemError,
@@ -198,7 +229,6 @@ func lexTop(lx *lexer) stateFn {
 	if isWhitespace(r) || isNL(r) {
 		return lexSkip(lx, lexTop)
 	}
-
 	switch r {
 	case commentStart:
 		lx.push(lexTop)
@@ -207,7 +237,7 @@ func lexTop(lx *lexer) stateFn {
 		return lexTableStart
 	case eof:
 		if lx.pos > lx.start {
-			return lx.errorf("Unexpected EOF.")
+			return lx.errorf("unexpected EOF")
 		}
 		lx.emit(itemEOF)
 		return nil
@@ -222,12 +252,12 @@ func lexTop(lx *lexer) stateFn {
 
 // 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 new line. If it sees EOF, it will quit the lexer successfully.
+// 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 new line for us.
+		// a comment will read to a newline for us.
 		lx.push(lexTop)
 		return lexCommentStart
 	case isWhitespace(r):
@@ -236,11 +266,11 @@ func lexTopEnd(lx *lexer) stateFn {
 		lx.ignore()
 		return lexTop
 	case r == eof:
-		lx.ignore()
-		return lexTop
+		lx.emit(itemEOF)
+		return nil
 	}
-	return lx.errorf("Expected a top-level item to end with a new line, "+
-		"comment or EOF, but got %q instead.", r)
+	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
@@ -267,8 +297,8 @@ func lexTableEnd(lx *lexer) stateFn {
 
 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)
+		return lx.errorf("expected end of table array name delimiter %q, "+
+			"but got %q instead", arrayTableEnd, r)
 	}
 	lx.emit(itemArrayTableEnd)
 	return lexTopEnd
@@ -278,11 +308,11 @@ 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.)")
+		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.)")
+		return lx.errorf("unexpected table separator " +
+			"(table names cannot be empty)")
 	case r == stringStart || r == rawStringStart:
 		lx.ignore()
 		lx.push(lexTableNameEnd)
@@ -317,8 +347,8 @@ func lexTableNameEnd(lx *lexer) stateFn {
 	case r == tableEnd:
 		return lx.pop()
 	default:
-		return lx.errorf("Expected '.' or ']' to end table name, but got %q "+
-			"instead.", r)
+		return lx.errorf("expected '.' or ']' to end table name, "+
+			"but got %q instead", r)
 	}
 }
 
@@ -328,7 +358,7 @@ func lexKeyStart(lx *lexer) stateFn {
 	r := lx.peek()
 	switch {
 	case r == keySep:
-		return lx.errorf("Unexpected key separator %q.", keySep)
+		return lx.errorf("unexpected key separator %q", keySep)
 	case isWhitespace(r) || isNL(r):
 		lx.next()
 		return lexSkip(lx, lexKeyStart)
@@ -359,7 +389,7 @@ func lexBareKey(lx *lexer) stateFn {
 		lx.emit(itemText)
 		return lexKeyEnd
 	default:
-		return lx.errorf("Bare keys cannot contain %q.", r)
+		return lx.errorf("bare keys cannot contain %q", r)
 	}
 }
 
@@ -372,7 +402,7 @@ func lexKeyEnd(lx *lexer) stateFn {
 	case isWhitespace(r):
 		return lexSkip(lx, lexKeyEnd)
 	default:
-		return lx.errorf("Expected key separator %q, but got %q instead.",
+		return lx.errorf("expected key separator %q, but got %q instead",
 			keySep, r)
 	}
 }
@@ -381,9 +411,8 @@ func lexKeyEnd(lx *lexer) stateFn {
 // 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 new lines.
-	// In array syntax, the array states are responsible for ignoring new
-	// lines.
+	// 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):
@@ -397,6 +426,10 @@ func lexValue(lx *lexer) stateFn {
 		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) {
@@ -420,7 +453,7 @@ func lexValue(lx *lexer) stateFn {
 	case '+', '-':
 		return lexNumberStart
 	case '.': // special error case, be kind to users
-		return lx.errorf("Floats must start with a digit, not '.'.")
+		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
@@ -430,11 +463,11 @@ func lexValue(lx *lexer) stateFn {
 		lx.backup()
 		return lexBool
 	}
-	return lx.errorf("Expected value but found %q instead.", r)
+	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 new lines are ignored.
+// have already been consumed. All whitespace and newlines are ignored.
 func lexArrayValue(lx *lexer) stateFn {
 	r := lx.next()
 	switch {
@@ -443,10 +476,11 @@ func lexArrayValue(lx *lexer) stateFn {
 	case r == commentStart:
 		lx.push(lexArrayValue)
 		return lexCommentStart
-	case r == arrayValTerm:
-		return lx.errorf("Unexpected array value terminator %q.",
-			arrayValTerm)
+	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
 	}
 
@@ -455,8 +489,9 @@ func lexArrayValue(lx *lexer) stateFn {
 	return lexValue
 }
 
-// lexArrayValueEnd consumes the cruft between values of an array. Namely,
-// it ignores whitespace and expects either a ',' or a ']'.
+// 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 {
@@ -465,31 +500,88 @@ func lexArrayValueEnd(lx *lexer) stateFn {
 	case r == commentStart:
 		lx.push(lexArrayValueEnd)
 		return lexCommentStart
-	case r == arrayValTerm:
+	case r == comma:
 		lx.ignore()
 		return lexArrayValue // move on to the next value
 	case r == arrayEnd:
 		return lexArrayEnd
 	}
-	return lx.errorf("Expected an array value terminator %q or an array "+
-		"terminator %q, but got %q instead.", arrayValTerm, arrayEnd, r)
+	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.
+// 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 new lines.")
+		return lx.errorf("strings cannot contain newlines")
 	case r == '\\':
 		lx.push(lexString)
 		return lexStringEscape
@@ -506,11 +598,12 @@ func lexString(lx *lexer) stateFn {
 // lexMultilineString consumes the inner contents of a string. It assumes that
 // the beginning '"""' has already been consumed and ignored.
 func lexMultilineString(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case r == '\\':
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case '\\':
 		return lexMultilineStringEscape
-	case r == stringEnd:
+	case stringEnd:
 		if lx.accept(stringEnd) {
 			if lx.accept(stringEnd) {
 				lx.backup()
@@ -534,8 +627,10 @@ func lexMultilineString(lx *lexer) stateFn {
 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 new lines.")
+		return lx.errorf("strings cannot contain newlines")
 	case r == rawStringEnd:
 		lx.backup()
 		lx.emit(itemRawString)
@@ -547,12 +642,13 @@ func lexRawString(lx *lexer) stateFn {
 }
 
 // lexMultilineRawString consumes a raw string. Nothing can be escaped in such
-// a string. It assumes that the beginning "'" has already been consumed and
+// a string. It assumes that the beginning "'''" has already been consumed and
 // ignored.
 func lexMultilineRawString(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case r == rawStringEnd:
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case rawStringEnd:
 		if lx.accept(rawStringEnd) {
 			if lx.accept(rawStringEnd) {
 				lx.backup()
@@ -605,10 +701,9 @@ func lexStringEscape(lx *lexer) stateFn {
 	case 'U':
 		return lexLongUnicodeEscape
 	}
-	return lx.errorf("Invalid escape character %q. Only the following "+
+	return lx.errorf("invalid escape character %q; only the following "+
 		"escape characters are allowed: "+
-		"\\b, \\t, \\n, \\f, \\r, \\\", \\/, \\\\, "+
-		"\\uXXXX and \\UXXXXXXXX.", r)
+		`\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r)
 }
 
 func lexShortUnicodeEscape(lx *lexer) stateFn {
@@ -616,8 +711,8 @@ func lexShortUnicodeEscape(lx *lexer) stateFn {
 	for i := 0; i < 4; i++ {
 		r = lx.next()
 		if !isHexadecimal(r) {
-			return lx.errorf("Expected four hexadecimal digits after '\\u', "+
-				"but got '%s' instead.", lx.current())
+			return lx.errorf(`expected four hexadecimal digits after '\u', `+
+				"but got %q instead", lx.current())
 		}
 	}
 	return lx.pop()
@@ -628,8 +723,8 @@ func lexLongUnicodeEscape(lx *lexer) stateFn {
 	for i := 0; i < 8; i++ {
 		r = lx.next()
 		if !isHexadecimal(r) {
-			return lx.errorf("Expected eight hexadecimal digits after '\\U', "+
-				"but got '%s' instead.", lx.current())
+			return lx.errorf(`expected eight hexadecimal digits after '\U', `+
+				"but got %q instead", lx.current())
 		}
 	}
 	return lx.pop()
@@ -647,9 +742,9 @@ func lexNumberOrDateStart(lx *lexer) stateFn {
 	case 'e', 'E':
 		return lexFloat
 	case '.':
-		return lx.errorf("Floats must start with a digit, not '.'.")
+		return lx.errorf("floats must start with a digit, not '.'")
 	}
-	return lx.errorf("Expected a digit but got %q.", r)
+	return lx.errorf("expected a digit but got %q", r)
 }
 
 // lexNumberOrDate consumes either an integer, float or datetime.
@@ -697,9 +792,9 @@ func lexNumberStart(lx *lexer) stateFn {
 	r := lx.next()
 	if !isDigit(r) {
 		if r == '.' {
-			return lx.errorf("Floats must start with a digit, not '.'.")
+			return lx.errorf("floats must start with a digit, not '.'")
 		}
-		return lx.errorf("Expected a digit but got %q.", r)
+		return lx.errorf("expected a digit but got %q", r)
 	}
 	return lexNumber
 }
@@ -757,7 +852,7 @@ func lexBool(lx *lexer) stateFn {
 		lx.emit(itemBool)
 		return lx.pop()
 	}
-	return lx.errorf("Expected value but found %q instead.", s)
+	return lx.errorf("expected value but found %q instead", s)
 }
 
 // lexCommentStart begins the lexing of a comment. It will emit
@@ -769,7 +864,7 @@ func lexCommentStart(lx *lexer) stateFn {
 }
 
 // lexComment lexes an entire comment. It assumes that '#' has been consumed.
-// It will consume *up to* the first new line character, and pass control
+// 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()

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

@@ -269,6 +269,41 @@ func (p *parser) value(it item) (interface{}, tomlType) {
 			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")

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

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

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,
+}

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

@@ -0,0 +1,289 @@
+// Code generated by protoc-gen-go.
+// source: content_manifest.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 ContentManifestPayload struct {
+	Mappings         []*ContentManifestPayload_FileMapping `protobuf:"bytes,1,rep,name=mappings" json:"mappings,omitempty"`
+	XXX_unrecognized []byte                                `json:"-"`
+}
+
+func (m *ContentManifestPayload) Reset()                    { *m = ContentManifestPayload{} }
+func (m *ContentManifestPayload) String() string            { return proto.CompactTextString(m) }
+func (*ContentManifestPayload) ProtoMessage()               {}
+func (*ContentManifestPayload) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{0} }
+
+func (m *ContentManifestPayload) GetMappings() []*ContentManifestPayload_FileMapping {
+	if m != nil {
+		return m.Mappings
+	}
+	return nil
+}
+
+type ContentManifestPayload_FileMapping struct {
+	Filename         *string                                         `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
+	Size             *uint64                                         `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
+	Flags            *uint32                                         `protobuf:"varint,3,opt,name=flags" json:"flags,omitempty"`
+	ShaFilename      []byte                                          `protobuf:"bytes,4,opt,name=sha_filename" json:"sha_filename,omitempty"`
+	ShaContent       []byte                                          `protobuf:"bytes,5,opt,name=sha_content" json:"sha_content,omitempty"`
+	Chunks           []*ContentManifestPayload_FileMapping_ChunkData `protobuf:"bytes,6,rep,name=chunks" json:"chunks,omitempty"`
+	Linktarget       *string                                         `protobuf:"bytes,7,opt,name=linktarget" json:"linktarget,omitempty"`
+	XXX_unrecognized []byte                                          `json:"-"`
+}
+
+func (m *ContentManifestPayload_FileMapping) Reset()         { *m = ContentManifestPayload_FileMapping{} }
+func (m *ContentManifestPayload_FileMapping) String() string { return proto.CompactTextString(m) }
+func (*ContentManifestPayload_FileMapping) ProtoMessage()    {}
+func (*ContentManifestPayload_FileMapping) Descriptor() ([]byte, []int) {
+	return content_manifest_fileDescriptor0, []int{0, 0}
+}
+
+func (m *ContentManifestPayload_FileMapping) GetFilename() string {
+	if m != nil && m.Filename != nil {
+		return *m.Filename
+	}
+	return ""
+}
+
+func (m *ContentManifestPayload_FileMapping) GetSize() uint64 {
+	if m != nil && m.Size != nil {
+		return *m.Size
+	}
+	return 0
+}
+
+func (m *ContentManifestPayload_FileMapping) GetFlags() uint32 {
+	if m != nil && m.Flags != nil {
+		return *m.Flags
+	}
+	return 0
+}
+
+func (m *ContentManifestPayload_FileMapping) GetShaFilename() []byte {
+	if m != nil {
+		return m.ShaFilename
+	}
+	return nil
+}
+
+func (m *ContentManifestPayload_FileMapping) GetShaContent() []byte {
+	if m != nil {
+		return m.ShaContent
+	}
+	return nil
+}
+
+func (m *ContentManifestPayload_FileMapping) GetChunks() []*ContentManifestPayload_FileMapping_ChunkData {
+	if m != nil {
+		return m.Chunks
+	}
+	return nil
+}
+
+func (m *ContentManifestPayload_FileMapping) GetLinktarget() string {
+	if m != nil && m.Linktarget != nil {
+		return *m.Linktarget
+	}
+	return ""
+}
+
+type ContentManifestPayload_FileMapping_ChunkData struct {
+	Sha              []byte  `protobuf:"bytes,1,opt,name=sha" json:"sha,omitempty"`
+	Crc              *uint32 `protobuf:"fixed32,2,opt,name=crc" json:"crc,omitempty"`
+	Offset           *uint64 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
+	CbOriginal       *uint32 `protobuf:"varint,4,opt,name=cb_original" json:"cb_original,omitempty"`
+	CbCompressed     *uint32 `protobuf:"varint,5,opt,name=cb_compressed" json:"cb_compressed,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) Reset() {
+	*m = ContentManifestPayload_FileMapping_ChunkData{}
+}
+func (m *ContentManifestPayload_FileMapping_ChunkData) String() string {
+	return proto.CompactTextString(m)
+}
+func (*ContentManifestPayload_FileMapping_ChunkData) ProtoMessage() {}
+func (*ContentManifestPayload_FileMapping_ChunkData) Descriptor() ([]byte, []int) {
+	return content_manifest_fileDescriptor0, []int{0, 0, 0}
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) GetSha() []byte {
+	if m != nil {
+		return m.Sha
+	}
+	return nil
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) GetCrc() uint32 {
+	if m != nil && m.Crc != nil {
+		return *m.Crc
+	}
+	return 0
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) GetOffset() uint64 {
+	if m != nil && m.Offset != nil {
+		return *m.Offset
+	}
+	return 0
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbOriginal() uint32 {
+	if m != nil && m.CbOriginal != nil {
+		return *m.CbOriginal
+	}
+	return 0
+}
+
+func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbCompressed() uint32 {
+	if m != nil && m.CbCompressed != nil {
+		return *m.CbCompressed
+	}
+	return 0
+}
+
+type ContentManifestMetadata struct {
+	DepotId            *uint32 `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"`
+	GidManifest        *uint64 `protobuf:"varint,2,opt,name=gid_manifest" json:"gid_manifest,omitempty"`
+	CreationTime       *uint32 `protobuf:"varint,3,opt,name=creation_time" json:"creation_time,omitempty"`
+	FilenamesEncrypted *bool   `protobuf:"varint,4,opt,name=filenames_encrypted" json:"filenames_encrypted,omitempty"`
+	CbDiskOriginal     *uint64 `protobuf:"varint,5,opt,name=cb_disk_original" json:"cb_disk_original,omitempty"`
+	CbDiskCompressed   *uint64 `protobuf:"varint,6,opt,name=cb_disk_compressed" json:"cb_disk_compressed,omitempty"`
+	UniqueChunks       *uint32 `protobuf:"varint,7,opt,name=unique_chunks" json:"unique_chunks,omitempty"`
+	CrcEncrypted       *uint32 `protobuf:"varint,8,opt,name=crc_encrypted" json:"crc_encrypted,omitempty"`
+	CrcClear           *uint32 `protobuf:"varint,9,opt,name=crc_clear" json:"crc_clear,omitempty"`
+	XXX_unrecognized   []byte  `json:"-"`
+}
+
+func (m *ContentManifestMetadata) Reset()                    { *m = ContentManifestMetadata{} }
+func (m *ContentManifestMetadata) String() string            { return proto.CompactTextString(m) }
+func (*ContentManifestMetadata) ProtoMessage()               {}
+func (*ContentManifestMetadata) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{1} }
+
+func (m *ContentManifestMetadata) GetDepotId() uint32 {
+	if m != nil && m.DepotId != nil {
+		return *m.DepotId
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetGidManifest() uint64 {
+	if m != nil && m.GidManifest != nil {
+		return *m.GidManifest
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetCreationTime() uint32 {
+	if m != nil && m.CreationTime != nil {
+		return *m.CreationTime
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetFilenamesEncrypted() bool {
+	if m != nil && m.FilenamesEncrypted != nil {
+		return *m.FilenamesEncrypted
+	}
+	return false
+}
+
+func (m *ContentManifestMetadata) GetCbDiskOriginal() uint64 {
+	if m != nil && m.CbDiskOriginal != nil {
+		return *m.CbDiskOriginal
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetCbDiskCompressed() uint64 {
+	if m != nil && m.CbDiskCompressed != nil {
+		return *m.CbDiskCompressed
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetUniqueChunks() uint32 {
+	if m != nil && m.UniqueChunks != nil {
+		return *m.UniqueChunks
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetCrcEncrypted() uint32 {
+	if m != nil && m.CrcEncrypted != nil {
+		return *m.CrcEncrypted
+	}
+	return 0
+}
+
+func (m *ContentManifestMetadata) GetCrcClear() uint32 {
+	if m != nil && m.CrcClear != nil {
+		return *m.CrcClear
+	}
+	return 0
+}
+
+type ContentManifestSignature struct {
+	Signature        []byte `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *ContentManifestSignature) Reset()                    { *m = ContentManifestSignature{} }
+func (m *ContentManifestSignature) String() string            { return proto.CompactTextString(m) }
+func (*ContentManifestSignature) ProtoMessage()               {}
+func (*ContentManifestSignature) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{2} }
+
+func (m *ContentManifestSignature) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*ContentManifestPayload)(nil), "ContentManifestPayload")
+	proto.RegisterType((*ContentManifestPayload_FileMapping)(nil), "ContentManifestPayload.FileMapping")
+	proto.RegisterType((*ContentManifestPayload_FileMapping_ChunkData)(nil), "ContentManifestPayload.FileMapping.ChunkData")
+	proto.RegisterType((*ContentManifestMetadata)(nil), "ContentManifestMetadata")
+	proto.RegisterType((*ContentManifestSignature)(nil), "ContentManifestSignature")
+}
+
+var content_manifest_fileDescriptor0 = []byte{
+	// 409 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x91, 0xbd, 0x8e, 0xd4, 0x30,
+	0x14, 0x85, 0xc9, 0xfc, 0x26, 0x37, 0x09, 0x5a, 0xbc, 0xb0, 0x58, 0x43, 0x83, 0x96, 0x66, 0x9b,
+	0x4d, 0x81, 0x44, 0x49, 0xc3, 0x22, 0x44, 0x33, 0x12, 0x12, 0x0f, 0x10, 0x5d, 0x1c, 0x27, 0x6b,
+	0x4d, 0x62, 0x07, 0xdb, 0x29, 0x96, 0x8a, 0x17, 0xe1, 0x0d, 0x91, 0x78, 0x05, 0x6c, 0x27, 0x99,
+	0x1d, 0x8d, 0x28, 0x28, 0xcf, 0xf1, 0xb5, 0xcf, 0x77, 0x8f, 0xe1, 0x8a, 0x29, 0x69, 0xb9, 0xb4,
+	0x65, 0x87, 0x52, 0xd4, 0xdc, 0xd8, 0xa2, 0xd7, 0xca, 0xaa, 0xeb, 0x3f, 0x0b, 0xb8, 0xba, 0x1b,
+	0x8f, 0xf6, 0xd3, 0xc9, 0x17, 0x7c, 0x68, 0x15, 0x56, 0xe4, 0x1d, 0xc4, 0x1d, 0xf6, 0xbd, 0x90,
+	0x8d, 0xa1, 0xd1, 0xeb, 0xe5, 0x4d, 0xfa, 0xf6, 0x4d, 0xf1, 0xef, 0xd1, 0xe2, 0x93, 0x68, 0xf9,
+	0x7e, 0x9c, 0xdd, 0xfd, 0x5a, 0x40, 0x7a, 0xa2, 0xc9, 0x05, 0xc4, 0xb5, 0x93, 0x12, 0x3b, 0xee,
+	0x9e, 0x89, 0x6e, 0x12, 0x92, 0xc1, 0xca, 0x88, 0x1f, 0x9c, 0x2e, 0x9c, 0x5a, 0x91, 0x1c, 0xd6,
+	0x75, 0x8b, 0x2e, 0x63, 0xe9, 0x64, 0x4e, 0x9e, 0x43, 0x66, 0xee, 0xb1, 0x3c, 0x5e, 0x59, 0x39,
+	0x37, 0x23, 0x97, 0x90, 0x7a, 0x77, 0x5a, 0x82, 0xae, 0x83, 0xf9, 0x1e, 0x36, 0xec, 0x7e, 0x90,
+	0x07, 0x43, 0x37, 0x01, 0xef, 0xf6, 0x3f, 0xf0, 0x8a, 0x3b, 0x7f, 0xe3, 0x23, 0x5a, 0x24, 0x04,
+	0xa0, 0x15, 0xf2, 0x60, 0x51, 0x37, 0xdc, 0xd2, 0xad, 0x47, 0xdb, 0x21, 0x24, 0x8f, 0x03, 0x29,
+	0x2c, 0x5d, 0x68, 0x80, 0xce, 0xbc, 0x60, 0x9a, 0x05, 0xe6, 0x2d, 0x79, 0x0a, 0x1b, 0x55, 0xd7,
+	0xc6, 0x5d, 0x5b, 0x86, 0x1d, 0x1c, 0x1e, 0xfb, 0x56, 0x2a, 0x2d, 0x1a, 0x21, 0xb1, 0x0d, 0xcc,
+	0x39, 0x79, 0x01, 0xb9, 0x33, 0x99, 0xea, 0x7a, 0xcd, 0x8d, 0xe1, 0x55, 0xa0, 0xce, 0xaf, 0x7f,
+	0x47, 0xf0, 0xf2, 0x8c, 0x73, 0xcf, 0x2d, 0x56, 0x3e, 0xd1, 0x75, 0x55, 0xf1, 0x5e, 0xd9, 0x52,
+	0x54, 0x21, 0x36, 0xd4, 0xd1, 0x88, 0xea, 0xf8, 0x6b, 0x53, 0x67, 0xfe, 0x69, 0xcd, 0xd1, 0x0a,
+	0x25, 0x4b, 0x2b, 0x5c, 0x4b, 0x63, 0x77, 0xaf, 0xe0, 0x72, 0xee, 0xcd, 0x94, 0x5c, 0x32, 0xfd,
+	0xd0, 0x5b, 0x97, 0xeb, 0x71, 0x62, 0x42, 0xe1, 0xc2, 0xe1, 0x54, 0xc2, 0x1c, 0x1e, 0x41, 0xd7,
+	0xe1, 0xb5, 0x1d, 0x90, 0xf9, 0xe4, 0x84, 0x76, 0x33, 0x27, 0x0d, 0x52, 0x7c, 0x1f, 0x78, 0x39,
+	0x55, 0xbd, 0x3d, 0xee, 0xa6, 0xd9, 0x49, 0x46, 0x1c, 0xec, 0x67, 0x90, 0x78, 0x9b, 0xb5, 0x1c,
+	0x35, 0x4d, 0xc2, 0xba, 0xb7, 0x40, 0xcf, 0xb6, 0xfd, 0x2a, 0x1a, 0x89, 0x76, 0xd0, 0xdc, 0x8f,
+	0x9b, 0x59, 0x8c, 0x35, 0x7f, 0x58, 0x7f, 0x8e, 0x7e, 0x46, 0x4f, 0xfe, 0x06, 0x00, 0x00, 0xff,
+	0xff, 0xc6, 0x87, 0xdb, 0xe6, 0xaf, 0x02, 0x00, 0x00,
+}