Release v1.11.3

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

.github/ISSUE_TEMPLATE.md

@@ -1,20 +1,36 @@
-Please answer the following questions. 
+<!-- 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.
 
-### Which version of matterbridge are you using?
-run ```matterbridge -version```
+You can also preview your report before submitting it.
 
-### If you're having problems with mattermost please specify mattermost version. 
+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.
+<!-- 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))
+<!-- (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="

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,17 +1,28 @@
 # matterbridge
-[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg)](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)](https://webchat.freenode.net/?channels=matterbridgechat) [![Discord](https://img.shields.io/badge/discord-matterbridge-green.svg)](https://discord.gg/AkKPtrQ) [![Matrix](https://img.shields.io/badge/matrix-matterbridge-green.svg)](https://riot.im/app/#/room/#matterbridge:matrix.org)
+Click on one of the badges below to join the chat   
 
-![matterbridge.gif](https://s15.postimg.org/qpjhp6y3f/matterbridge.gif)
+[![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/)
 
-Simple bridge between Mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat(via xmpp) and Matrix with REST API.
+[![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)
+
+![matterbridge.gif](https://github.com/42wim/matterbridge/blob/master/img/matterbridge.gif)
+
+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](#features)
+ * [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)
@@ -20,15 +31,25 @@ Simple bridge between Mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, R
  * [Thanks](#thanks)
 
 # Features
-* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat (via xmpp) and Matrix. Pick and mix.
-* Matterbridge can also work with private groups on your mattermost/slack.
-* 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).
-* REST API to read/post messages to bridges (WIP).
+* [Support bridging between any protocols](https://github.com/42wim/matterbridge/wiki/Features#support-bridging-between-any-protocols)
+* [Support multiple gateways(bridges) for your protocols](https://github.com/42wim/matterbridge/wiki/Features#support-multiple-gatewaysbridges-for-your-protocols)
+* [Message edits and deletes](https://github.com/42wim/matterbridge/wiki/Features#message-edits-and-deletes)
+* [Attachment / files handling](https://github.com/42wim/matterbridge/wiki/Features#attachment--files-handling)
+* [Username and avatar spoofing](https://github.com/42wim/matterbridge/wiki/Features#username-and-avatar-spoofing)
+* [Private groups](https://github.com/42wim/matterbridge/wiki/Features#private-groups)
+* [API](https://github.com/42wim/matterbridge/wiki/Features#api)
+
+## API
+The API is very basic at the moment and rather undocumented.
+
+Used by at least 2 projects. Feel free to make a PR to add your project to this list.
+
+* [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
+* [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
 
 # Requirements
 Accounts to one of the supported bridges
-* [Mattermost](https://github.com/mattermost/platform/) 3.5.x - 3.10.x
+* [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)
@@ -38,14 +59,23 @@ Accounts to one of the supported bridges
 * [Hipchat](https://www.hipchat.com)
 * [Rocket.chat](https://rocket.chat)
 * [Matrix](https://matrix.org)
+* [Steam](https://store.steampowered.com/)
+* [Twitch](https://twitch.tv)
+* [Ssh-chat](https://github.com/shazow/ssh-chat)
+* [Zulip](https://zulipchat.com)
+
+# Screenshots
+See https://github.com/42wim/matterbridge/wiki
 
 # Installing
 ## Binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* Latest stable release [v0.15.0](https://github.com/42wim/matterbridge/releases/latest)
+* Latest stable release [v1.11.3](https://github.com/42wim/matterbridge/releases/latest)
+* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)  
 
 ## Building
-Go 1.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)
+Go 1.8+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH](https://golang.org/doc/code.html#GOPATH).
+
+After Go is setup, download matterbridge to your $GOPATH directory. 
 
 ```
 cd $GOPATH
@@ -60,8 +90,11 @@ 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.
-* [matterbridge.toml.simple](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.simple) for a simple example.
 
 ## Examples 
 ### Bridge mattermost (off-topic) - irc (#testing)
@@ -73,12 +106,12 @@ matterbridge
 
 [mattermost]
     [mattermost.work]
-    useAPI=true
     Server="yourmattermostserver.tld"
     Team="yourteam"
     Login="yourlogin"
     Password="yourpass"
     PrefixMessagesWithNick=true
+    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
 [[gateway]]
 name="mygateway"
@@ -96,7 +129,6 @@ enable=true
 ```
 [slack]
 [slack.test]
-useAPI=true
 Token="yourslacktoken"
 PrefixMessagesWithNick=true
 
@@ -122,11 +154,8 @@ RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
 ```
 
 # Running
-1) Copy the matterbridge.toml.sample to matterbridge.toml 
-2) Edit matterbridge.toml with the settings for your environment. 
-3) Now you can run matterbridge.  (```./matterbridge```)   
 
-(Matterbridge will only look for the config file in your current directory, if it isn't there specify -conf "/path/toyour/matterbridge.toml")
+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:
@@ -151,29 +180,26 @@ See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.m
 
 # 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 API version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
-
-Also look at the ```RemoteNickFormat``` setting.
+See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
 
+Want to tip ? 
+* eth: 0xb3f9b5387c66ad6be892bcb7bbc67862f3abc16f
+* btc: 1N7cKHj5SfqBHBzDJ6kad4BzeqUBBS2zhs
 
 # Thanks
+[![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
+
 Matterbridge wouldn't exist without these libraries:
 * discord - https://github.com/bwmarrin/discordgo
 * echo - https://github.com/labstack/echo
 * gitter - https://github.com/sromku/go-gitter
 * gops - https://github.com/google/gops
-* irc - https://github.com/thoj/go-ircevent
+* 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

@@ -1,21 +1,22 @@
 package api
 
 import (
+	"encoding/json"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
 	"github.com/labstack/echo"
 	"github.com/labstack/echo/middleware"
 	"github.com/zfjagann/golang-ring"
-	"net/http"
-	"sync"
 )
 
 type Api struct {
-	Config   *config.Protocol
-	Remote   chan config.Message
-	Account  string
 	Messages ring.Ring
 	sync.RWMutex
+	*bridge.Config
 }
 
 type ApiMessage struct {
@@ -26,30 +27,27 @@ type ApiMessage struct {
 	Gateway  string `json:"gateway"`
 }
 
-var flog *log.Entry
-var protocol = "api"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, account string, c chan config.Message) *Api {
-	b := &Api{}
+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(cfg.Buffer)
-	b.Config = &cfg
-	b.Account = account
-	b.Remote = c
-	if b.Config.Token != "" {
+	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.Config.Token, nil
+			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() {
-		flog.Fatal(e.Start(cfg.BindAddress))
+		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
 }
@@ -61,34 +59,35 @@ func (b *Api) Disconnect() error {
 	return nil
 
 }
-func (b *Api) JoinChannel(channel string) error {
+func (b *Api) JoinChannel(channel config.ChannelInfo) error {
 	return nil
 
 }
 
-func (b *Api) Send(msg config.Message) error {
+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
+	return "", nil
 }
 
 func (b *Api) handlePostMessage(c echo.Context) error {
-	message := &ApiMessage{}
-	if err := c.Bind(message); err != nil {
+	message := config.Message{}
+	if err := c.Bind(&message); err != nil {
 		return err
 	}
-	flog.Debugf("Sending message from %s on %s to gateway", message.Username, "api")
-	b.Remote <- config.Message{
-		Text:     message.Text,
-		Username: message.Username,
-		UserID:   message.UserID,
-		Channel:  "api",
-		Avatar:   message.Avatar,
-		Account:  b.Account,
-		Gateway:  message.Gateway,
-		Protocol: "api",
-	}
+	// 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)
 }
 
@@ -99,3 +98,24 @@ func (b *Api) handleMessages(c echo.Context) error {
 	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

@@ -1,40 +1,42 @@
 package bridge
 
 import (
-	"github.com/42wim/matterbridge/bridge/api"
 	"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/matrix"
-	"github.com/42wim/matterbridge/bridge/mattermost"
-	"github.com/42wim/matterbridge/bridge/rocketchat"
-	"github.com/42wim/matterbridge/bridge/slack"
-	"github.com/42wim/matterbridge/bridge/telegram"
-	"github.com/42wim/matterbridge/bridge/xmpp"
-	log "github.com/Sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 
 	"strings"
 )
 
 type Bridger interface {
-	Send(msg config.Message) error
+	Send(msg config.Message) (string, error)
 	Connect() error
-	JoinChannel(channel string) error
+	JoinChannel(channel config.ChannelInfo) error
 	Disconnect() error
 }
 
 type Bridge struct {
-	Config config.Protocol
 	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
 }
 
-func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) *Bridge {
+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, ".")
@@ -44,63 +46,19 @@ func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) *Brid
 	b.Protocol = protocol
 	b.Account = bridge.Account
 	b.Joined = make(map[string]bool)
-
-	// override config from environment
-	config.OverrideCfgFromEnv(cfg, protocol, name)
-	switch protocol {
-	case "mattermost":
-		b.Config = cfg.Mattermost[name]
-		b.Bridger = bmattermost.New(cfg.Mattermost[name], bridge.Account, c)
-	case "irc":
-		b.Config = cfg.IRC[name]
-		b.Bridger = birc.New(cfg.IRC[name], bridge.Account, c)
-	case "gitter":
-		b.Config = cfg.Gitter[name]
-		b.Bridger = bgitter.New(cfg.Gitter[name], bridge.Account, c)
-	case "slack":
-		b.Config = cfg.Slack[name]
-		b.Bridger = bslack.New(cfg.Slack[name], bridge.Account, c)
-	case "xmpp":
-		b.Config = cfg.Xmpp[name]
-		b.Bridger = bxmpp.New(cfg.Xmpp[name], bridge.Account, c)
-	case "discord":
-		b.Config = cfg.Discord[name]
-		b.Bridger = bdiscord.New(cfg.Discord[name], bridge.Account, c)
-	case "telegram":
-		b.Config = cfg.Telegram[name]
-		b.Bridger = btelegram.New(cfg.Telegram[name], bridge.Account, c)
-	case "rocketchat":
-		b.Config = cfg.Rocketchat[name]
-		b.Bridger = brocketchat.New(cfg.Rocketchat[name], bridge.Account, c)
-	case "matrix":
-		b.Config = cfg.Matrix[name]
-		b.Bridger = bmatrix.New(cfg.Matrix[name], bridge.Account, c)
-	case "api":
-		b.Config = cfg.Api[name]
-		b.Bridger = api.New(cfg.Api[name], bridge.Account, c)
-	}
 	return b
 }
 
 func (b *Bridge) JoinChannels() error {
 	err := b.joinChannels(b.Channels, b.Joined)
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 
 func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map[string]bool) error {
-	mychannel := ""
 	for ID, channel := range channels {
 		if !exists[ID] {
-			mychannel = channel.Name
-			log.Infof("%s: joining %s (%s)", b.Account, channel.Name, ID)
-			if b.Protocol == "irc" && channel.Options.Key != "" {
-				log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
-				mychannel = mychannel + " " + channel.Options.Key
-			}
-			err := b.JoinChannel(mychannel)
+			b.Log.Infof("%s: joining %s (ID: %s)", b.Account, channel.Name, ID)
+			err := b.JoinChannel(channel)
 			if err != nil {
 				return err
 			}
@@ -109,3 +67,38 @@ func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map
 	}
 	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,18 +1,27 @@
 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_FAILURE         = "failure"
-	EVENT_REJOIN_CHANNELS = "rejoin_channels"
+	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 {
@@ -26,6 +35,18 @@ type Message struct {
 	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 {
@@ -33,52 +54,80 @@ type ChannelInfo struct {
 	Account     string
 	Direction   string
 	ID          string
-	GID         map[string]bool
 	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
+	Label                  string // all protocols
 	Login                  string // mattermost, matrix
-	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
-	NoHomeServerSuffix     bool   // matrix
-	NoTLS                  bool   // mattermost
-	Password               string // IRC,mattermost,XMPP,matrix
-	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
-	MessageLength          int    // IRC, max length of a message allowed
-	MessageFormat          string // telegram
-	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, api
-	URL                    string // mattermost, slack, matrix
-	UseAPI                 bool   // mattermost, slack
-	UseSASL                bool   // IRC
-	UseTLS                 bool   // IRC
-	UseFirstName           bool   // telegram
+	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
+	Key        string // irc, xmpp
+	WebhookURL string // discord
 }
 
 type Bridge struct {
@@ -103,69 +152,130 @@ type SameChannelGateway struct {
 	Accounts []string
 }
 
-type Config struct {
+type ConfigValues struct {
 	Api                map[string]Protocol
-	IRC                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]

bridge/discord/discord.go

@@ -1,161 +1,302 @@
 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
-	Account       string
-	Channels      []*discordgo.Channel
-	Nick          string
-	UseChannelID  bool
-	userMemberMap map[string]*discordgo.Member
-	guildID       string
+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, account string, c chan config.Message) *bdiscord {
-	b := &bdiscord{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
+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")
-	if !strings.HasPrefix(b.Config.Token, "Bot ") {
-		b.Config.Token = "Bot " + 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")
 	}
-	b.c, err = discordgo.New(b.Config.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) Disconnect() error {
-	return nil
+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) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
+func (b *Bdiscord) Send(msg config.Message) (string, error) {
+	b.Log.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)
 	}
-	b.c.ChannelMessageSend(channelID, msg.Username+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) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
-	if b.Config.EditDisable {
+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 != "" {
-		flog.Debugf("Sending edit message")
-		m.Content = m.Content + b.Config.EditSuffix
+		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) {
+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.Account)
-	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
 	}
-	username := b.getNick(m.Author)
-	if len(m.MentionRoles) > 0 {
-		m.Message.Content = b.replaceRoleMentions(m.Message.Content)
-	}
-	m.Message.Content = b.stripCustomoji(m.Message.Content)
-	m.Message.Content = b.replaceChannelMentions(m.Message.Content)
-	b.Remote <- config.Message{Username: username, Text: m.ContentWithMentionsReplaced(), Channel: channelName,
-		Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg",
-		UserID: m.Author.ID}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
 }
 
-func (b *bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
+func (b *Bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
 	b.Lock()
 	if _, ok := b.userMemberMap[m.Member.User.ID]; ok {
-		flog.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.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 {
+func (b *Bdiscord) getNick(user *discordgo.User) string {
 	var err error
 	b.Lock()
 	defer b.Unlock()
@@ -182,7 +323,7 @@ func (b *bdiscord) getNick(user *discordgo.User) string {
 	return user.Username
 }
 
-func (b *bdiscord) getChannelID(name string) string {
+func (b *Bdiscord) getChannelID(name string) string {
 	idcheck := strings.Split(name, "ID:")
 	if len(idcheck) > 1 {
 		return idcheck[1]
@@ -195,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
@@ -204,19 +345,7 @@ func (b *bdiscord) getChannelName(id string) string {
 	return ""
 }
 
-func (b *bdiscord) replaceRoleMentions(text string) string {
-	roles, err := b.c.GuildRoles(b.guildID)
-	if err != nil {
-		flog.Debugf("%#v", string(err.(*discordgo.RESTError).ResponseBody))
-		return text
-	}
-	for _, role := range roles {
-		text = strings.Replace(text, "<@&"+role.ID+">", "@"+role.Name, -1)
-	}
-	return text
-}
-
-func (b *bdiscord) replaceChannelMentions(text string) string {
+func (b *Bdiscord) replaceChannelMentions(text string) string {
 	var err error
 	re := regexp.MustCompile("<#[0-9]+>")
 	text = re.ReplaceAllStringFunc(text, func(m string) string {
@@ -235,8 +364,71 @@ func (b *bdiscord) replaceChannelMentions(text string) string {
 	return text
 }
 
-func (b *bdiscord) stripCustomoji(text string) string {
+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

@@ -2,47 +2,39 @@ package bgitter
 
 import (
 	"fmt"
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	"github.com/sromku/go-gitter"
 	"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
-	Account 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, account string, c chan config.Message) *Bgitter {
-	b := &Bgitter{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
-	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
 }
 
@@ -51,10 +43,10 @@ func (b *Bgitter) Disconnect() error {
 
 }
 
-func (b *Bgitter) JoinChannel(channel string) error {
-	roomID, err := b.c.GetRoomId(channel)
+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)
+		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 {
@@ -78,29 +70,74 @@ func (b *Bgitter) JoinChannel(channel string) error {
 		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.Account)
-					b.Remote <- 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}
+				// 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.Name)
+	}(stream, room.URI)
 	return nil
 }
 
-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
 	}
-	// add ZWSP because gitter echoes our own messages
-	return b.c.SendMessage(roomID, msg.Username+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 {
@@ -123,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,54 +1,62 @@
 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
-	Remote          chan config.Message
-	connected       chan struct{}
-	Local           chan config.Message // local queue for flood control
-	Account         string
-	FirstConnection bool
+	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, account 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.Account = account
 	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")
 	}
-	if b.Config.MessageLength == 0 {
-		b.Config.MessageLength = 400
+	if b.GetInt("MessageLength") == 0 {
+		b.MessageLength = 400
+	} else {
+		b.MessageLength = b.GetInt("MessageLength")
 	}
 	b.FirstConnection = true
 	return b
@@ -57,101 +65,207 @@ func New(cfg config.Protocol, account string, c chan config.Message) *Birc {
 func (b *Birc) Command(msg *config.Message) string {
 	switch msg.Text {
 	case "!users":
-		b.i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
-		b.i.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
-		b.i.SendRaw("NAMES " + msg.Channel)
+		b.i.Handlers.Add(girc.RPL_NAMREPLY, b.storeNames)
+		b.i.Handlers.Add(girc.RPL_ENDOFNAMES, b.endNames)
+		b.i.Cmd.SendRaw("NAMES " + msg.Channel)
 	}
 	return ""
 }
 
 func (b *Birc) Connect() error {
-	b.Local = make(chan config.Message, b.Config.MessageQueue+10)
-	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}
-	i.KeepAlive = time.Minute
-	i.PingFreq = time.Minute
-	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
-	// clear on reconnects
-	i.ClearCallback(ircm.RPL_WELCOME)
-	i.AddCallback(ircm.RPL_WELCOME, func(event *irc.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.Nick
-	})
-	go i.Loop()
+	//i.Debug = false
+	if b.GetInt("DebugLevel") == 0 {
+		i.Handlers.Clear(girc.ALL_EVENTS)
+	}
 	go b.doSend()
 	return nil
 }
 
 func (b *Birc) Disconnect() error {
-	//b.i.Disconnect()
+	b.i.Close()
 	close(b.Local)
 	return nil
 }
 
-func (b *Birc) JoinChannel(channel string) error {
-	b.i.Join(channel)
+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) error {
-	flog.Debugf("Receiving %#v", msg)
-	if msg.Account == b.Account {
-		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)
 	}
-	for _, text := range strings.Split(msg.Text, "\n") {
-		if len(text) > b.Config.MessageLength {
-			text = text[:b.Config.MessageLength] + " <message clipped>"
-		}
-		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: msg.Username, 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
@@ -164,135 +278,189 @@ func (b *Birc) endNames(event *irc.Event) {
 	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.ClearCallback(ircm.RPL_NAMREPLY)
-	b.i.ClearCallback(ircm.RPL_ENDOFNAMES)
+	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.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("JOIN", b.handleJoinPart)
-	i.AddCallback("PART", b.handleJoinPart)
-	i.AddCallback("QUIT", b.handleJoinPart)
-	i.AddCallback("KICK", b.handleJoinPart)
-	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) handleJoinPart(event *irc.Event) {
-	channel := event.Arguments[0]
-	if event.Code == "KICK" {
-		flog.Infof("Got kicked from %s by %s", channel, event.Nick)
+func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
+	if len(event.Params) == 0 {
+		b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
+		return
+	}
+	channel := strings.ToLower(event.Params[0])
+	if event.Command == "KICK" && event.Params[1] == b.Nick {
+		b.Log.Infof("Got kicked from %s by %s", channel, event.Source.Name)
+		time.Sleep(time.Duration(b.GetInt("RejoinDelay")) * time.Second)
 		b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: channel, Account: b.Account, Event: config.EVENT_REJOIN_CHANNELS}
 		return
 	}
-	if event.Code == "QUIT" {
-		if event.Nick == b.Nick && strings.Contains(event.Raw, "Ping timeout") {
-			flog.Infof("%s reconnecting ..", b.Account)
+	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.Nick != b.Nick {
-		flog.Debugf("Sending JOIN_LEAVE event from %s to gateway", b.Account)
-		b.Remote <- config.Message{Username: "system", Text: event.Nick + " " + strings.ToLower(event.Code) + "s", Channel: channel, Account: b.Account, Event: config.EVENT_JOIN_LEAVE}
+	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
 	}
-	flog.Debugf("handle %#v", event)
+	b.Log.Debugf("handle %#v", event)
 }
 
-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) 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.Code == "NOTICE" {
-		return
+	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.Account)
-	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Account: b.Account, UserID: event.User + "@" + event.Host}
+	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

@@ -1,60 +1,51 @@
 package bmatrix
 
 import (
+	"bytes"
+	"fmt"
+	"mime"
 	"regexp"
+	"strings"
 	"sync"
 
+	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	matrix "github.com/matrix-org/gomatrix"
+	"github.com/42wim/matterbridge/bridge/helper"
+	matrix "github.com/matterbridge/gomatrix"
 )
 
 type Bmatrix struct {
 	mc      *matrix.Client
-	Config  *config.Protocol
-	Remote  chan config.Message
-	Account string
 	UserID  string
 	RoomMap map[string]string
 	sync.RWMutex
+	*bridge.Config
 }
 
-var flog *log.Entry
-var protocol = "matrix"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, account string, c chan config.Message) *Bmatrix {
-	b := &Bmatrix{}
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmatrix{Config: cfg}
 	b.RoomMap = make(map[string]string)
-	b.Config = &cfg
-	b.Account = account
-	b.Remote = c
 	return b
 }
 
 func (b *Bmatrix) Connect() error {
 	var err error
-	flog.Infof("Connecting %s", b.Config.Server)
-	b.mc, err = matrix.NewClient(b.Config.Server, "", "")
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	b.mc, err = matrix.NewClient(b.GetString("Server"), "", "")
 	if err != nil {
-		flog.Debugf("%#v", err)
 		return err
 	}
 	resp, err := b.mc.Login(&matrix.ReqLogin{
 		Type:     "m.login.password",
-		User:     b.Config.Login,
-		Password: b.Config.Password,
+		User:     b.GetString("Login"),
+		Password: b.GetString("Password"),
 	})
 	if err != nil {
-		flog.Debugf("%#v", err)
 		return err
 	}
 	b.mc.SetCredentials(resp.UserID, resp.AccessToken)
 	b.UserID = resp.UserID
-	flog.Info("Connection succeeded")
+	b.Log.Info("Connection succeeded")
 	go b.handlematrix()
 	return nil
 }
@@ -63,23 +54,65 @@ func (b *Bmatrix) Disconnect() error {
 	return nil
 }
 
-func (b *Bmatrix) JoinChannel(channel string) error {
-	resp, err := b.mc.JoinRoom(channel, "", 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
+	b.RoomMap[resp.RoomID] = channel.Name
 	b.Unlock()
 	return err
 }
 
-func (b *Bmatrix) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
+func (b *Bmatrix) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
 	channel := b.getRoomID(msg.Channel)
-	flog.Debugf("Sending to channel %s", channel)
-	b.mc.SendText(channel, msg.Username+msg.Text)
-	return nil
+	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 {
@@ -92,33 +125,188 @@ func (b *Bmatrix) getRoomID(channel string) string {
 	}
 	return ""
 }
+
 func (b *Bmatrix) handlematrix() error {
 	syncer := b.mc.Syncer.(*matrix.DefaultSyncer)
-	syncer.OnEventType("m.room.message", func(ev *matrix.Event) {
-		if ev.Content["msgtype"].(string) == "m.text" && ev.Sender != b.UserID {
-			b.RLock()
-			channel, ok := b.RoomMap[ev.RoomID]
-			b.RUnlock()
-			if !ok {
-				flog.Debugf("Unknown room %s", ev.RoomID)
-				return
-			}
-			username := ev.Sender[1:]
-			if b.Config.NoHomeServerSuffix {
-				re := regexp.MustCompile("(.*?):.*")
-				username = re.ReplaceAllString(username, `$1`)
-			}
-			flog.Debugf("Sending message from %s on %s to gateway", ev.Sender, b.Account)
-			b.Remote <- config.Message{Username: username, Text: ev.Content["body"].(string), Channel: channel, Account: b.Account, UserID: ev.Sender}
-		}
-		flog.Debugf("Received: %#v", ev)
-	})
+	syncer.OnEventType("m.room.redaction", b.handleEvent)
+	syncer.OnEventType("m.room.message", b.handleEvent)
 	go func() {
 		for {
 			if err := b.mc.Sync(); err != nil {
-				flog.Println("Sync() returned ", err)
+				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,52 +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
-	UserID   string
-}
-
 type Bmattermost struct {
-	MMhook
-	MMapi
-	Config  *config.Protocol
-	Remote  chan config.Message
-	name    string
-	TeamId  string
-	Account 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, account string, c chan config.Message) *Bmattermost {
-	b := &Bmattermost{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
-	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
 }
 
@@ -55,27 +33,72 @@ 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 b.GetString("WebhookBindAddress") != "" {
+		if b.GetString("WebhookURL") != "" {
+			b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.GetString("WebhookURL"),
+				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		} else if b.GetString("Token") != "" {
+			b.Log.Info("Connecting using token (sending)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+		} else if b.GetString("Login") != "" {
+			b.Log.Info("Connecting using login/password (sending)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+		} else {
+			b.Log.Info("Connecting using webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.GetString("WebhookURL"),
+				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+					BindAddress: b.GetString("WebhookBindAddress")})
+		}
+		go b.handleMatter()
+		return nil
+	}
+	if b.GetString("WebhookURL") != "" {
+		b.Log.Info("Connecting using webhookurl (sending)")
+		b.mh = matterhook.New(b.GetString("WebhookURL"),
+			matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+				DisableServer: true})
+		if b.GetString("Token") != "" {
+			b.Log.Info("Connecting using token (receiving)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+			go b.handleMatter()
+		} else if b.GetString("Login") != "" {
+			b.Log.Info("Connecting using login/password (receiving)")
+			err := b.apiLogin()
+			if err != nil {
+				return err
+			}
+			go b.handleMatter()
+		}
+		return nil
+	} else if b.GetString("Token") != "" {
+		b.Log.Info("Connecting using token (sending and receiving)")
+		err := b.apiLogin()
 		if err != nil {
 			return err
 		}
-		flog.Info("Connection succeeded")
-		b.TeamId = b.mc.GetTeamId()
-		go b.mc.WsReceiver()
-		go b.mc.StatusLoop()
+		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")
 	}
-	go b.handleMatter()
 	return nil
 }
 
@@ -83,100 +106,362 @@ func (b *Bmattermost) Disconnect() error {
 	return nil
 }
 
-func (b *Bmattermost) JoinChannel(channel string) error {
+func (b *Bmattermost) JoinChannel(channel config.ChannelInfo) error {
 	// we can only join channels using the API
-	if b.Config.UseAPI {
-		return b.mc.JoinChannel(b.mc.GetChannelId(channel, ""))
+	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) error {
-	flog.Debugf("Receiving %#v", msg)
-	nick := msg.Username
-	message := msg.Text
-	channel := msg.Channel
+func (b *Bmattermost) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
 
-	if b.Config.PrefixMessagesWithNick {
-		message = nick + message
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "*" + msg.Text + "*"
 	}
-	if !b.Config.UseAPI {
-		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
-		matterMessage.IconURL = msg.Avatar
-		matterMessage.Channel = channel
-		matterMessage.UserName = nick
-		matterMessage.Type = ""
-		matterMessage.Text = message
-		err := b.mh.Send(matterMessage)
-		if err != nil {
-			flog.Info(err)
-			return err
+
+	// 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 nil
+		return msg.ID, b.mc.DeleteMessage(msg.ID)
 	}
-	b.mc.PostMessage(b.mc.GetChannelId(channel, ""), message)
-	return nil
+
+	// 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.Account)
-		b.Remote <- config.Message{Text: message.Text, Username: message.Username, Channel: message.Channel, Account: b.Account, UserID: message.UserID}
+	var ok bool
+	for message := range messages {
+		message.Avatar = helper.GetAvatar(b.avatarMap, message.UserID, b.General)
+		message.Account = b.Account
+		message.Text, ok = b.replaceAction(message.Text)
+		if ok {
+			message.Event = config.EVENT_USER_ACTION
+		}
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
+		b.Log.Debugf("<= Message is %#v", message)
+		b.Remote <- *message
 	}
 }
 
-func (b *Bmattermost) handleMatterClient(mchan chan *MMMessage) {
+func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 	for message := range b.mc.MessageChan {
-		flog.Debugf("%#v", message.Raw.Data)
-		if message.Type == "system_join_leave" ||
-			message.Type == "system_join_channel" ||
-			message.Type == "system_leave_channel" {
-			flog.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}
+		b.Log.Debugf("%#v", message.Raw.Data)
+
+		if b.skipMessage(message) {
+			b.Log.Debugf("Skipped message: %#v", message)
 			continue
 		}
-		if (message.Raw.Event == "post_edited") && b.Config.EditDisable {
-			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)
 		}
-		// do not post our own messages back to irc
-		// only listen to message from our team
-		if (message.Raw.Event == "posted" || message.Raw.Event == "post_edited") &&
-			b.mc.User.Username != message.Username && message.Raw.Data["team_id"].(string) == b.TeamId {
-			flog.Debugf("Receiving from matterclient %#v", message)
-			m := &MMMessage{}
-			m.UserID = message.UserID
-			m.Username = message.Username
-			m.Channel = message.Channel
-			m.Text = message.Text
-			if message.Raw.Event == "post_edited" && !b.Config.EditDisable {
-				m.Text = message.Text + b.Config.EditSuffix
+
+		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 len(message.Post.FileIds) > 0 {
-				for _, link := range b.mc.GetPublicLinks(message.Post.FileIds) {
-					m.Text = m.Text + "\n" + link
+			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)
+				}
+			}
+		}
+		// Use nickname instead of username if defined
+		if nick := b.mc.GetNickName(rmsg.UserID); nick != "" {
+			rmsg.Username = nick
+		}
+
+		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.UserID = message.UserID
-		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

@@ -1,10 +1,11 @@
 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"
-	log "github.com/Sirupsen/logrus"
 )
 
 type MMhook struct {
@@ -14,25 +15,11 @@ type MMhook struct {
 
 type Brocketchat struct {
 	MMhook
-	Config  *config.Protocol
-	Remote  chan config.Message
-	name    string
-	Account string
+	*bridge.Config
 }
 
-var flog *log.Entry
-var protocol = "rocketchat"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, account string, c chan config.Message) *Brocketchat {
-	b := &Brocketchat{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
-	return b
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Brocketchat{Config: cfg}
 }
 
 func (b *Brocketchat) Command(cmd string) string {
@@ -40,11 +27,11 @@ func (b *Brocketchat) Command(cmd string) string {
 }
 
 func (b *Brocketchat) Connect() error {
-	flog.Info("Connecting webhooks")
-	b.mh = matterhook.New(b.Config.URL,
-		matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
+	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.Config.URL, rockethook.Config{BindAddress: b.Config.BindAddress})
+	b.rh = rockethook.New(b.GetString("WebhookURL"), rockethook.Config{BindAddress: b.GetString("WebhookBindAddress")})
 	go b.handleRocketHook()
 	return nil
 }
@@ -54,34 +41,55 @@ func (b *Brocketchat) Disconnect() error {
 
 }
 
-func (b *Brocketchat) JoinChannel(channel string) error {
+func (b *Brocketchat) JoinChannel(channel config.ChannelInfo) error {
 	return nil
 }
 
-func (b *Brocketchat) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+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 {
-		flog.Info(err)
-		return err
+		b.Log.Info(err)
+		return "", err
 	}
-	return nil
+	return "", nil
 }
 
 func (b *Brocketchat) handleRocketHook() {
 	for {
 		message := b.rh.Receive()
-		flog.Debugf("Receiving from rockethook %#v", message)
+		b.Log.Debugf("Receiving from rockethook %#v", message)
 		// do not loop
-		if message.UserName == b.Config.Nick {
+		if message.UserName == b.GetString("Nick") {
 			continue
 		}
-		flog.Debugf("Sending message from %s on %s to gateway", message.UserName, b.Account)
+		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
-	UserID   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
-	Account  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, account string, c chan config.Message) *Bslack {
-	b := &Bslack{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bslack{Config: cfg, uuid: xid.New().String()}
+	b.cache, _ = lru.New(5000)
 	return b
 }
 
@@ -52,91 +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) Disconnect() error {
-	return nil
-
+	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 {
-		if strings.HasPrefix(b.Config.Token, "xoxb") {
+	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)
+		_, err := b.sc.JoinChannel(channel.Name)
 		if err != nil {
-			if err.Error() != "name_taken" {
-				return err
+			switch err.Error() {
+			case "name_taken", "restricted_action":
+			case "default":
+				{
+					return err
+				}
 			}
 		}
 	}
 	return nil
 }
 
-func (b *Bslack) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
-	nick := msg.Username
-	message := msg.Text
-	channel := msg.Channel
-	if b.Config.PrefixMessagesWithNick {
-		message = nick + " " + message
+func (b *Bslack) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Make a action /me of the message
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
 	}
-	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
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return b.sendWebhook(msg)
+	}
+
+	channelID := b.getChannelID(msg.Channel)
+
+	// Delete message
+	if msg.Event == config.EVENT_MSG_DELETE {
+		// some protocols echo deletes, but with empty ID
+		if msg.ID == "" {
+			return "", nil
 		}
-		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
 			}
 		}
@@ -144,6 +239,7 @@ 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.Account, name)
@@ -155,6 +251,7 @@ func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
 	}
 	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 {
@@ -169,113 +266,479 @@ func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
 }
 
 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 b.Config.UseAPI && 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.Account)
-			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Account: b.Account, Avatar: b.getAvatar(message.Username), UserID: message.UserID}
-		}
+	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)
-				if !b.Config.EditDisable && ev.SubMessage != nil {
-					flog.Debugf("SubMessage %#v", ev.SubMessage)
-					ev.User = ev.SubMessage.User
-					ev.Text = ev.SubMessage.Text + b.Config.EditSuffix
-				}
-				// use our own func because rtm.GetChannelInfo doesn't work for private channels
-				channel, err := b.getChannelByID(ev.Channel)
-				if err != nil {
-					continue
-				}
-				user, err := b.rtm.GetUserInfo(ev.User)
-				if err != nil {
-					continue
-				}
-				m := &MMMessage{}
-				m.UserID = user.ID
-				m.Username = user.Name
-				m.Channel = channel.Name
-				m.Text = ev.Text
-				m.Raw = ev
-				m.Text = b.replaceMention(m.Text)
-				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{Limit: 1000, Types: []string{"public_channel,private_channel,mpim,im"}})
+			if err != nil {
+				b.Log.Errorf("Channel list failed: %#v", err)
+			}
 			b.si = ev.Info
 			b.Users, _ = b.sc.GetUsers()
-			// add private channels
-			groups, _ := b.sc.GetGroups(true)
-			for _, g := range groups {
-				channel := new(slack.Channel)
-				channel.ID = g.ID
-				channel.Name = g.Name
-				b.channels = append(b.channels, *channel)
-			}
+			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.Text = b.replaceMention(m.Text)
-		m.Channel = message.ChannelName
-		if m.Username == "slackbot" {
+		b.Log.Debugf("receiving from matterhook (slack) %#v", message)
+		if message.UserName == "slackbot" {
 			continue
 		}
-		mchan <- m
+		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)
+	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

@@ -2,15 +2,16 @@ package btelegram
 
 import (
 	"bytes"
-	"github.com/russross/blackfriday"
 	"html"
+
+	"github.com/russross/blackfriday"
 )
 
-type customHtml struct {
+type customHTML struct {
 	blackfriday.Renderer
 }
 
-func (options *customHtml) Paragraph(out *bytes.Buffer, text func() bool) {
+func (options *customHTML) Paragraph(out *bytes.Buffer, text func() bool) {
 	marker := out.Len()
 
 	if !text() {
@@ -20,32 +21,32 @@ func (options *customHtml) Paragraph(out *bytes.Buffer, text func() bool) {
 	out.WriteString("\n")
 }
 
-func (options *customHtml) BlockCode(out *bytes.Buffer, text []byte, lang string) {
+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) {
+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) {
+func (options *customHTML) HRule(out *bytes.Buffer) {
 	out.WriteByte('\n')
 }
 
-func (options *customHtml) BlockQuote(out *bytes.Buffer, text []byte) {
+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) {
+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) {
+func (options *customHTML) ListItem(out *bytes.Buffer, text []byte, flags int) {
 	out.WriteString("- ")
 	out.Write(text)
 	out.WriteByte('\n')
@@ -53,7 +54,7 @@ func (options *customHtml) ListItem(out *bytes.Buffer, text []byte, flags int) {
 
 func makeHTML(input string) string {
 	return string(blackfriday.Markdown([]byte(input),
-		&customHtml{blackfriday.HtmlRenderer(blackfriday.HTML_USE_XHTML|blackfriday.HTML_SKIP_IMAGES, "", "")},
+		&customHTML{blackfriday.HtmlRenderer(blackfriday.HTML_USE_XHTML|blackfriday.HTML_SKIP_IMAGES, "", "")},
 		blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
 			blackfriday.EXTENSION_FENCED_CODE|
 			blackfriday.EXTENSION_AUTOLINK|

bridge/telegram/telegram.go

@@ -1,136 +1,251 @@
 package btelegram
 
 import (
+	"html"
+	"regexp"
 	"strconv"
+	"strings"
 
+	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
+	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/go-telegram-bot-api/telegram-bot-api"
 )
 
 type Btelegram struct {
-	c       *tgbotapi.BotAPI
-	Config  *config.Protocol
-	Remote  chan config.Message
-	Account string
+	c *tgbotapi.BotAPI
+	*bridge.Config
+	avatarMap map[string]string // keep cache of userid and avatar sha
 }
 
-var flog *log.Entry
-var protocol = "telegram"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, account string, c chan config.Message) *Btelegram {
-	b := &Btelegram{}
-	b.Config = &cfg
-	b.Remote = c
-	b.Account = account
-	return b
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Btelegram{Config: cfg, avatarMap: make(map[string]string)}
 }
 
 func (b *Btelegram) Connect() error {
 	var err error
-	flog.Info("Connecting")
-	b.c, err = tgbotapi.NewBotAPI(b.Config.Token)
+	b.Log.Info("Connecting")
+	b.c, err = tgbotapi.NewBotAPI(b.GetString("Token"))
 	if err != nil {
-		flog.Debugf("%#v", err)
+		b.Log.Debugf("%#v", err)
 		return err
 	}
-	updates, err := b.c.GetUpdatesChan(tgbotapi.NewUpdate(0))
+	u := tgbotapi.NewUpdate(0)
+	u.Timeout = 60
+	updates, err := b.c.GetUpdatesChan(u)
 	if err != nil {
-		flog.Debugf("%#v", err)
+		b.Log.Debugf("%#v", err)
 		return err
 	}
-	flog.Info("Connection succeeded")
+	b.Log.Info("Connection succeeded")
 	go b.handleRecv(updates)
 	return nil
 }
 
 func (b *Btelegram) Disconnect() error {
 	return nil
-
 }
 
-func (b *Btelegram) JoinChannel(channel string) error {
+func (b *Btelegram) JoinChannel(channel config.ChannelInfo) error {
 	return nil
 }
 
-func (b *Btelegram) Send(msg config.Message) error {
-	flog.Debugf("Receiving %#v", msg)
+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
+		return "", err
 	}
 
-	if b.Config.MessageFormat == "HTML" {
+	// 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)
 	}
-	m := tgbotapi.NewMessage(chatid, msg.Username+msg.Text)
-	if b.Config.MessageFormat == "HTML" {
-		m.ParseMode = tgbotapi.ModeHTML
+
+	// 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
 	}
-	_, err = b.c.Send(m)
-	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
-		username := ""
-		channel := ""
-		text := ""
+
+		rmsg := config.Message{Account: b.Account, Extra: make(map[string][]interface{})}
+
 		// handle channels
 		if update.ChannelPost != nil {
 			message = update.ChannelPost
+			rmsg.Text = message.Text
 		}
-		if update.EditedChannelPost != nil && !b.Config.EditDisable {
+
+		// edited channel message
+		if update.EditedChannelPost != nil && !b.GetBool("EditDisable") {
 			message = update.EditedChannelPost
-			message.Text = message.Text + b.Config.EditSuffix
+			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
 		}
+
 		// handle groups
 		if update.Message != nil {
 			message = update.Message
-		}
-		if update.EditedMessage != nil && !b.Config.EditDisable {
-			message = update.EditedMessage
-			message.Text = message.Text + b.Config.EditSuffix
-		}
-		if message.From != nil {
-			if b.Config.UseFirstName {
-				username = message.From.FirstName
-			}
-			if username == "" {
-				username = message.From.UserName
-				if username == "" {
-					username = message.From.FirstName
-				}
-			}
-			text = message.Text
-			channel = strconv.FormatInt(message.Chat.ID, 10)
+			rmsg.Text = message.Text
 		}
 
-		if username == "" {
-			username = "unknown"
+		// edited group message
+		if update.EditedMessage != nil && !b.GetBool("EditDisable") {
+			message = update.EditedMessage
+			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
 		}
-		if message.Sticker != nil {
-			text = text + " " + b.getFileDirectURL(message.Sticker.FileID)
+
+		// 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 message.Video != nil {
-			text = text + " " + b.getFileDirectURL(message.Video.FileID)
+
+		// if we really didn't find a username, set it to unknown
+		if rmsg.Username == "" {
+			rmsg.Username = "unknown"
 		}
-		if message.Photo != nil {
-			photos := *message.Photo
-			// last photo is the biggest
-			text = text + " " + b.getFileDirectURL(photos[len(photos)-1].FileID)
+
+		// handle any downloads
+		err := b.handleDownload(message, &rmsg)
+		if err != nil {
+			b.Log.Errorf("download failed: %s", err)
 		}
-		if message.Document != nil {
-			text = text + " " + message.Document.FileName + " : " + b.getFileDirectURL(message.Document.FileID)
+
+		// 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
 		}
-		if text != "" {
-			flog.Debugf("Sending message from %s on %s to gateway", username, b.Account)
-			b.Remote <- config.Message{Username: username, Text: text, Channel: channel, Account: b.Account, UserID: strconv.Itoa(message.From.ID)}
+
+		// 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
 		}
 	}
 }
@@ -142,3 +257,185 @@ func (b *Btelegram) getFileDirectURL(id string) string {
 	}
 	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

@@ -2,48 +2,61 @@ package bxmpp
 
 import (
 	"crypto/tls"
-	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/Sirupsen/logrus"
-	"github.com/mattn/go-xmpp"
-
 	"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
-	Remote  chan config.Message
-	Account string
+	*bridge.Config
 }
 
-var flog *log.Entry
-var protocol = "xmpp"
-
-func init() {
-	flog = log.WithFields(log.Fields{"module": protocol})
-}
-
-func New(cfg config.Protocol, account 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.Account = account
-	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
 }
 
@@ -51,37 +64,66 @@ func (b *Bxmpp) Disconnect() error {
 	return nil
 }
 
-func (b *Bxmpp) JoinChannel(channel string) error {
-	b.xc.JoinMUCNoHistory(channel+"@"+b.Config.Muc, b.Config.Nick)
+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) error {
-	flog.Debugf("Receiving %#v", msg)
-	b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.Config.Muc, Text: msg.Username + msg.Text})
-	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.Config.SkipTLSVerify
-	tc.ServerName = strings.Split(b.Config.Server, ":")[0]
+	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,
-		TLSConfig: tc,
-
-		//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()
@@ -96,7 +138,11 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 		for {
 			select {
 			case <-ticker.C:
-				b.xc.PingC2S("", "")
+				b.Log.Debugf("PING")
+				err := b.xc.PingC2S("", "")
+				if err != nil {
+					b.Log.Debugf("PING failed %#v", err)
+				}
 			case <-done:
 				return
 			}
@@ -105,10 +151,11 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 	return done
 }
 
-func (b *Bxmpp) handleXmpp() error {
+func (b *Bxmpp) handleXMPP() error {
+	var ok bool
+	var msgid string
 	done := b.xmppKeepAlive()
 	defer close(done)
-	nodelay := time.Time{}
 	for {
 		m, err := b.xc.Recv()
 		if err != nil {
@@ -116,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 && v.Stamp == nodelay && v.Text != "" {
-					flog.Debugf("Sending message from %s on %s to gateway", nick, b.Account)
-					b.Remote <- config.Message{Username: nick, Text: v.Text, Channel: channel, Account: b.Account, UserID: v.Remote}
+				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,3 +1,410 @@
+# v1.11.3
+
+## Bugfix
+* mattermost: fix panic when using webhooks #491
+* slack: fix issues regarding API changes and lots of channels #489
+* irc: fix rejoin on kick problem #488
+
+# v1.11.2
+
+## Bugfix
+* slack: fix slack API changes regarding to files/images
+
+# v1.11.1
+
+## New features
+* slack: Add support for slack channels by ID. Closes #436
+* discord: Clip too long messages sent to discord (discord). Closes #440
+
+## Bugfix
+* general: fix possible panic on downloads that are too big #448
+* general: Fix avatar uploads to work with MediaDownloadPath. Closes #454
+* discord: allow receiving of topic changes/channel leave/joins from other bridges through the webhook
+* discord: Add a space before url in file uploads (discord). Closes #461
+* discord:  Skip empty messages being sent with the webhook (discord). #469
+* mattermost: Use nickname instead of username if defined (mattermost). Closes #452
+* irc: Stop numbers being stripped after non-color control codes (irc) (#465)
+* slack: Use UserID to look for avatar instead of username (slack). Closes #472
+
+# v1.11.0
+
+## New features
+* general: Add config option MediaDownloadPath (#443). See `MediaDownloadPath` in matterbridge.toml.sample
+* general: Add MediaDownloadBlacklist option. Closes #442. See `MediaDownloadBlacklist` in matterbridge.toml.sample
+* xmpp: Add channel password support for XMPP (#451)
+* xmpp: Add message correction support for XMPP (#437)
+* telegram: Add support for MessageFormat=htmlnick (telegram). #444
+* mattermost: Add support for mattermost 5.x
+
+## Enhancements
+* slack: Add Title from attachment slack message (#446)
+* irc: Prevent white or black color codes (irc) (#434)
+
+## Bugfix
+* slack: Fix regexp in replaceMention (slack). (#435)
+* irc: Reconnect on quit. (irc) See #431 (#445)
+* sshchat: Ignore messages from ourself. (sshchat) Closes #439
+
+# v1.10.1
+## New features
+* irc: Colorize username sent to IRC using its crc32 IEEE checksum (#423). See `ColorNicks` in matterbridge.toml.sample
+* irc: Add support for CJK to/from utf-8 (irc). #400
+* telegram: Add QuoteFormat option (telegram). Closes #413. See `QuoteFormat` in matterbridge.toml.sample
+* xmpp: Send attached files to XMPP in different message with OOB data and without body (#421)
+
+## Bugfix
+* general: updated irc/xmpp/telegram libraries
+* mattermost/slack/rocketchat: Fix iconurl regression. Closes #430
+* mattermost/slack: Use uuid instead of userid. Fixes #429
+* slack: Avatar spoofing from Slack to Discord with uppercase in nick doesn't work (#433)
+* irc: Fix format string bug (irc) (#428)
+
+# v1.10.0
+## New features
+* general: Add support for reloading all settings automatically after changing config except connection and gateway configuration. Closes #373
+* zulip: New protocol support added (https://zulipchat.com)
+
+## Enhancements
+* general: Handle file comment better
+* steam: Handle file uploads to mediaserver (steam)
+* slack: Properly set Slack user who initiated slash command (#394)
+
+## Bugfix
+* general: Use only alphanumeric for file uploads to mediaserver. Closes #416
+* general: Fix crash on invalid filenames
+* general: Fix regression in ReplaceMessages and ReplaceNicks. Closes #407
+* telegram: Fix possible nil when using channels (telegram). #410
+* telegram: Fix panic (telegram). Closes #410
+* telegram: Handle channel posts correctly
+* mattermost: Update GetFileLinks to API_V4
+
+# v1.9.1
+## New features
+* telegram: Add QuoteDisable option (telegram). Closes #399. See QuoteDisable in matterbridge.toml.sample
+## Enhancements
+* discord: Send mediaserver link to Discord in Webhook mode (discord) (#405)
+* mattermost: Print list of valid team names when team not found (#390)
+* slack: Strip markdown URLs with blank text (slack) (#392)
+## Bugfix
+* slack/mattermost: Make our callbackid more unique. Fixes issue with running multiple matterbridge on the same channel (slack,mattermost)
+* telegram: fix newlines in multiline messages #399
+* telegram: Revert #378
+
+# v1.9.0 (the refactor release)
+## New features
+* general: better debug messages
+* general: better support for environment variables override
+* general: Ability to disable sending join/leave messages to other gateways. #382
+* slack: Allow Slack @usergroups to be parsed as human-friendly names #379
+* slack: Provide better context for shared posts from Slack<=>Slack enhancement #369
+* telegram: Convert nicks automatically into HTML when MessageFormat is set to HTML #378
+* irc: Add DebugLevel option 
+
+## Bugfix
+* slack: Ignore restricted_action on channel join (slack). Closes #387
+* slack: Add slack attachment support to matterhook
+* slack: Update userlist on join (slack). Closes #372
+
+# v1.8.0
+## New features
+* general: Send chat notification if media is too big to be re-uploaded to MediaServer. See #359
+* general: Download (and upload) avatar images from mattermost and telegram when mediaserver is configured. Closes #362
+* general: Add label support in RemoteNickFormat
+* general: Prettier info/debug log output
+* mattermost: Download files and reupload to supported bridges (mattermost). Closes #357
+* slack: Add ShowTopicChange option. Allow/disable topic change messages (currently only from slack). Closes #353
+* slack: Add support for file comments (slack). Closes #346
+* telegram: Add comment to file upload from telegram. Show comments on all bridges. Closes #358
+* telegram: Add markdown support (telegram). #355
+* api: Give api access to whole config.Message (and events). Closes #374
+
+## Bugfix
+* discord: Check for a valid WebhookURL (discord). Closes #367
+* discord: Fix role mention replace issues
+* irc: Truncate messages sent to IRC based on byte count (#368)
+* mattermost: Add file download urls also to mattermost webhooks #356
+* telegram: Fix panic on nil messages (telegram). Closes #366
+* telegram: Fix the UseInsecureURL text (telegram). Closes #184
+
+# v1.7.1
+## Bugfix
+* telegram: Enable Long Polling for Telegram. Reduces bandwidth consumption. (#350)
+
+# v1.7.0
+## New features
+* matrix: Add support for deleting messages from/to matrix (matrix). Closes #320
+* xmpp: Ignore <subject> messages (xmpp). #272
+* irc: Add twitch support (irc) to README / wiki
+
+## Bugfix
+* general: Change RemoteNickFormat replacement order. Closes #336
+* general: Make edits/delete work for bridges that gets reused. Closes #342
+* general: Lowercase irc channels in config. Closes #348
+* matrix: Fix possible panics (matrix). Closes #333
+* matrix: Add an extension to images without one (matrix). #331
+* api: Obey the Gateway value from the json (api). Closes #344
+* xmpp: Print only debug messages when specified (xmpp). Closes #345
+* xmpp: Allow xmpp to receive the extra messages (file uploads) when text is empty. #295
+
+# v1.6.3
+## Bugfix
+* slack: Fix connection issues
+* slack: Add more debug messages
+* irc: Convert received IRC channel names to lowercase. Fixes #329 (#330)
+
+# v1.6.2
+## Bugfix
+* mattermost: Crashes while connecting to Mattermost (regression). Closes #327
+
+# v1.6.1
+## Bugfix
+* general: Display of nicks not longer working (regression). Closes #323
+
+# v1.6.0
+## New features
+* sshchat: New protocol support added (https://github.com/shazow/ssh-chat)
+* general: Allow specifying maximum download size of media using MediaDownloadSize (slack,telegram,matrix)
+* api: Add (simple, one listener) long-polling support (api). Closes #307
+* telegram: Add support for forwarded messages. Closes #313
+* telegram: Add support for Audio/Voice files (telegram). Closes #314
+* irc: Add RejoinDelay option. Delay to rejoin after channel kick (irc). Closes #322
+
+## Bugfix
+* telegram: Also use HTML in edited messages (telegram). Closes #315
+* matrix: Fix panic (matrix). Closes #316
+
+# v1.5.1
+
+## Bugfix
+* irc: Fix irc ACTION regression (irc). Closes #306
+* irc: Split on UTF-8 for MessageSplit (irc). Closes #308
+
+# v1.5.0
+## New features
+* general: remote mediaserver support. See MediaServerDownload and MediaServerUpload in matterbridge.toml.sample
+  more information on https://github.com/42wim/matterbridge/wiki/Mediaserver-setup-%5Badvanced%5D
+* general: Add support for ReplaceNicks using regexp to replace nicks. Closes #269 (see matterbridge.toml.sample)
+* general: Add support for ReplaceMessages using regexp to replace messages. #269 (see matterbridge.toml.sample)
+* irc: Add MessageSplit option to split messages on MessageLength (irc). Closes #281
+* matrix: Add support for uploading images/video (matrix). Closes #302
+* matrix: Add support for uploaded images/video (matrix) 
+
+## Bugfix
+* telegram: Add webp extension to stickers if necessary (telegram)
+* mattermost: Break when re-login fails (mattermost)
+
+# v1.4.1
+## Bugfix
+* telegram: fix issue with uploading for images/documents/stickers
+* slack: remove double messages sent to other bridges when uploading files
+* irc: Fix strict user handling of girc (irc). Closes #298 
+
+# v1.4.0
+## Breaking changes
+* general: `[general]` settings don't override the specific bridge settings
+
+## New features
+* irc: Replace sorcix/irc and go-ircevent with girc, this should be give better reconnects
+* steam: Add support for bridging to individual steam chats. (steam) (#294)
+* telegram: Download files from telegram and reupload to supported bridges (telegram). #278
+* slack: Add support to upload files to slack, from bridges with private urls like slack/mattermost/telegram. (slack)
+* discord: Add support to upload files to discord, from bridges with private urls like slack/mattermost/telegram. (discord)
+* general: Add systemd service file (#291)
+* general: Add support for DEBUG=1 envvar to enable debug. Closes #283
+* general: Add StripNick option, only allow alphanumerical nicks. Closes #285
+
+## Bugfix
+* gitter: Use room.URI instead of room.Name. (gitter) (#293)
+* slack: Allow slack messages with variables (eg. @here) to be formatted correctly. (slack) (#288)
+* slack: Resolve slack channel to human-readable name. (slack) (#282)
+* slack: Use DisplayName instead of deprecated username (slack). Closes #276
+* slack: Allowed Slack bridge to extract simpler link format. (#287)
+* irc: Strip irc colors correct, strip also ctrl chars (irc)
+
+# v1.3.1
+## New features
+* Support mattermost 4.3.0 and every other 4.x as api4 should be stable (mattermost)
+## Bugfix
+* Use bot username if specified (slack). Closes #273
+
+# v1.3.0
+## New features
+* Relay slack_attachments from mattermost to slack (slack). Closes #260
+* Add support for quoting previous message when replying (telegram). #237
+* Add support for Quakenet auth (irc). Closes #263
+* Download files (max size 1MB) from slack and reupload to mattermost (slack/mattermost). Closes #255
+
+## Enhancements
+* Backoff for 60 seconds when reconnecting too fast (irc) #267
+* Use override username if specified (mattermost). #260
+
+## Bugfix
+* Try to not forward slack unfurls. Closes #266
+
+# v1.2.0
+## Breaking changes
+* If you're running a discord bridge, update to this release before 16 october otherwise
+it will stop working. (see https://discordapp.com/developers/docs/reference)
+
+## New features
+* general: Add delete support. (actually delete the messages on bridges that support it)
+    (mattermost,discord,gitter,slack,telegram)
+
+## Bugfix
+* Do not break messages on newline (slack). Closes #258 
+* Update telegram library
+* Update discord library (supports v6 API now). Old API is deprecated on 16 October
+
+# v1.1.2
+## New features
+* general: also build darwin binaries
+* mattermost: add support for mattermost 4.2.x
+
+## Bugfix 
+* mattermost: Send images when text is empty regression. (mattermost). Closes #254
+* slack: also send the first messsage after connect. #252
+
+# v1.1.1
+## Bugfix
+* mattermost: fix public links
+
+# v1.1.0
+## New features
+* general: Add better editing support. (actually edit the messages on bridges that support it)
+	(mattermost,discord,gitter,slack,telegram)
+* mattermost: use API v4 (removes support for mattermost < 3.8)
+* mattermost: add support for personal access tokens (since mattermost 4.1)
+	Use ```Token="yourtoken"``` in mattermost config
+	See https://docs.mattermost.com/developer/personal-access-tokens.html for more info
+* matrix: Relay notices (matrix). Closes #243
+* irc: Add a charset option. Closes #247
+
+## Bugfix
+* slack: Handle leave/join events (slack). Closes #246
+* slack: Replace mentions from other bridges. (slack). Closes #233
+* gitter: remove ZWSP after messages
+
+# v1.0.1
+## New features
+* mattermost: add support for mattermost 4.1.x
+* discord: allow a webhookURL per channel #239
+
+# v1.0.0
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+* discord: Shows the username instead of the server nickname #234
+
+# v1.0.0-rc1
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+
+## Bugfix
+* general: Handle same account in multiple gateways better
+* mattermost: ignore edited messages with reactions
+* mattermost: Fix double posting of edited messages by using lru cache
+* irc: update vendor
+
+# v0.16.3
+## Bugfix
+* general: Fix in/out logic. Closes #224 
+* general: Fix message modification
+* slack: Disable message from other bots when using webhooks (slack)
+* mattermost: Return better error messages on mattermost connect
+
+# v0.16.2
+## New features
+* general: binary builds against latest commit are now available on https://bintray.com/42wim/nightly/Matterbridge/_latestVersion
+
+## Bugfix
+* slack: fix loop introduced by relaying message of other bots #219
+* slack: Suppress parent message when child message is received #218
+* mattermost: fix regression when using webhookurl and webhookbindaddress #221
+
+# v0.16.1
+## New features
+* slack: also relay messages of other bots #213
+* mattermost: show also links if public links have not been enabled.
+
+## Bugfix
+* mattermost, slack: fix connecting logic #216
+
+# v0.16.0
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## New features
+* mattermost: add support for mattermost 4.0
+* steam: New protocol support added (http://store.steampowered.com/)
+* discord: Support for embedded messages (sent by other bots)
+  Shows title, description and URL of embedded messages (sent by other bots)
+  To enable add ```ShowEmbeds=true``` to your discord config 
+* discord: ```WebhookURL``` posting support added (thanks @saury07) #204
+  Discord API does not allow to change the name of the user posting, but webhooks does.
+
+## Changes
+* general: all :emoji: will be converted to unicode, providing consistent emojis across all bridges
+* telegram: Add ```UseInsecureURL``` option for telegram (default false)
+  WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+  Those URLs will contain your bot-token. This may not be what you want.
+  For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+
+## Bugfix
+* irc: detect charset and try to convert it to utf-8 before sending it to other bridges. #209 #210
+* slack: Remove label from URLs (slack). #205
+* slack: Relay <>& correctly to other bridges #215
+* steam: Fix channel id bug in steam (channels are off by 0x18000000000000)
+* general: various improvements
+* general: samechannelgateway now relays messages correct again #207
+
+
+# v0.16.0-rc2
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## Bugfix since rc1
+* steam: Fix channel id bug in steam (channels are off by 0x18000000000000)
+* telegram: Add UseInsecureURL option for telegram (default false)
+  WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+  Those URLs will contain your bot-token. This may not be what you want.
+  For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+* irc: detect charset and try to convert it to utf-8 before sending it to other bridges. #209 #210
+* general: various improvements
+
+
+# v0.16.0-rc1
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## New features
+* steam: New protocol support added (http://store.steampowered.com/)
+* discord: WebhookURL posting support added (thanks @saury07) #204
+  Discord API does not allow to change the name of the user posting, but webhooks does.
+
+## Bugfix
+* general: samechannelgateway now relays messages correct again #207
+* slack: Remove label from URLs (slack). #205
+
 # v0.15.0
 ## New features
 * general: add option IgnoreMessages for all protocols (see mattebridge.toml.sample)

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,73 +1,106 @@
 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"
+	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         map[string]*bridge.Bridge
-	Channels        map[string]*config.ChannelInfo
-	ChannelOptions  map[string]config.ChannelOptions
-	Names           map[string]bool
-	Name            string
-	Message         chan config.Message
-	DestChannelFunc func(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo
+	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 {
-	gw := &Gateway{}
-	gw.Config = cfg
-	gw.Channels = make(map[string]*config.ChannelInfo)
-	gw.Message = make(chan config.Message)
-	gw.Bridges = make(map[string]*bridge.Bridge)
-	gw.Names = make(map[string]bool)
-	gw.DestChannelFunc = gw.getDestChannel
+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 {
-	for _, br := range gw.Bridges {
-		if br.Account == cfg.Account {
-			gw.mapChannelsToBridge(br)
-			err := br.JoinChannels()
-			if err != nil {
-				return fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
-			}
-			return nil
-		}
+	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)
 	}
-	log.Infof("Starting bridge: %s ", cfg.Account)
-	br := bridge.New(gw.Config, cfg, gw.Message)
 	gw.mapChannelsToBridge(br)
 	gw.Bridges[cfg.Account] = br
-	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)
-	}
 	return nil
 }
 
 func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
-	if gw.Names[cfg.Name] {
-		return fmt.Errorf("Gateway with name %s already exists", cfg.Name)
-	}
-	if cfg.Name == "" {
-		return fmt.Errorf("%s", "Gateway without name found")
-	}
-	log.Infof("Starting gateway: %s", cfg.Name)
-	gw.Names[cfg.Name] = true
 	gw.Name = cfg.Name
 	gw.MyConfig = cfg
 	gw.mapChannels()
@@ -88,49 +121,14 @@ func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
 	}
 }
 
-func (gw *Gateway) Start() error {
-	go gw.handleReceive()
-	return nil
-}
-
-func (gw *Gateway) handleReceive() {
-	for {
-		select {
-		case msg := <-gw.Message:
-			if msg.Event == config.EVENT_FAILURE {
-				for _, br := range gw.Bridges {
-					if msg.Account == br.Account {
-						go gw.reconnectBridge(br)
-					}
-				}
-			}
-			if msg.Event == config.EVENT_REJOIN_CHANNELS {
-				for _, br := range gw.Bridges {
-					if msg.Account == br.Account {
-						br.Joined = make(map[string]bool)
-						br.JoinChannels()
-					}
-				}
-				continue
-			}
-			if !gw.ignoreMessage(&msg) {
-				msg.Timestamp = time.Now()
-				for _, br := range gw.Bridges {
-					gw.handleMessage(msg, br)
-				}
-			}
-		}
-	}
-}
-
 func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
 	br.Disconnect()
 	time.Sleep(time.Second * 5)
 RECONNECT:
-	log.Infof("Reconnecting %s", br.Account)
+	flog.Infof("Reconnecting %s", br.Account)
 	err := br.Connect()
 	if err != nil {
-		log.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
+		flog.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
 		time.Sleep(time.Second * 60)
 		goto RECONNECT
 	}
@@ -138,109 +136,197 @@ RECONNECT:
 	br.JoinChannels()
 }
 
-func (gw *Gateway) mapChannels() error {
-	for _, br := range append(gw.MyConfig.Out, gw.MyConfig.InOut...) {
+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
-		_, ok := gw.Channels[ID]
-		if !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: "out", ID: ID, Options: br.Options, Account: br.Account,
-				GID: make(map[string]bool), SameChannel: make(map[string]bool)}
-			channel.GID[gw.Name] = true
+		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].GID[gw.Name] = true
 		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
 	}
+}
 
-	for _, br := range append(gw.MyConfig.In, gw.MyConfig.InOut...) {
-		if isApi(br.Account) {
-			br.Channel = "api"
-		}
-		ID := br.Channel + br.Account
-		_, ok := gw.Channels[ID]
-		if !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: "in", ID: ID, Options: br.Options, Account: br.Account,
-				GID: make(map[string]bool), SameChannel: make(map[string]bool)}
-			channel.GID[gw.Name] = true
-			channel.SameChannel[gw.Name] = br.SameChannel
-			gw.Channels[channel.ID] = channel
-		}
-		gw.Channels[ID].GID[gw.Name] = true
-		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
-	}
+func (gw *Gateway) mapChannels() error {
+	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
 	return nil
 }
 
 func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
 	var channels []config.ChannelInfo
+
+	// for messages received from the api check that the gateway is the specified one
+	if msg.Protocol == "api" && gw.Name != msg.Gateway {
+		return channels
+	}
+
+	// if source channel is in only, do nothing
+	for _, channel := range gw.Channels {
+		// lookup the channel from the message
+		if channel.ID == getChannelID(*msg) {
+			// we only have destinations if the original message is from an "in" (sending) channel
+			if !strings.Contains(channel.Direction, "in") {
+				return channels
+			}
+			continue
+		}
+	}
 	for _, channel := range gw.Channels {
 		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
 			continue
 		}
-		if channel.Direction == "out" && channel.Account == dest.Account && gw.validGatewayDest(msg, channel) {
+
+		// 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) {
-	// only relay join/part when configged
-	if msg.Event == config.EVENT_JOIN_LEAVE && !gw.Bridges[dest.Account].Config.ShowJoinPart {
-		return
+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 {
-		log.Debug("empty channel")
-		return
+		flog.Debug("empty channel")
+		return brMsgIDs
 	}
+
 	originchannel := msg.Channel
 	origmsg := msg
-	for _, channel := range gw.DestChannelFunc(&msg, *dest) {
-		// do not send to ourself
-		if channel.ID == getChannelID(origmsg) {
-			continue
+	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
+			}
 		}
-		log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel.Name)
+		flog.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel.Name)
 		msg.Channel = channel.Name
-		gw.modifyAvatar(&msg, dest)
-		gw.modifyUsername(&msg, dest)
+		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
 		}
-		err := dest.Send(msg)
+		mID, err := dest.Send(msg)
 		if err != nil {
-			fmt.Println(err)
+			flog.Error(err)
+		}
+		// append the message ID (mID) from this bridge (dest) to our brMsgIDs slice
+		if mID != "" {
+			flog.Debugf("mID %s: %s", dest.Account, mID)
+			brMsgIDs = append(brMsgIDs, &BrMsgID{dest, mID, channel.ID})
 		}
 	}
+	return brMsgIDs
 }
 
 func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
-	if msg.Text == "" {
-		log.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
+	// if we don't have the bridge, ignore it
+	if _, ok := gw.Bridges[msg.Account]; !ok {
 		return true
 	}
-	for _, entry := range strings.Fields(gw.Bridges[msg.Account].Config.IgnoreNicks) {
+
+	// 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 {
-			log.Debugf("ignoring %s from %s", msg.Username, msg.Account)
+			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].Config.IgnoreMessages) {
+	for _, entry := range strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreMessages")) {
 		if entry != "" {
 			re, err := regexp.Compile(entry)
 			if err != nil {
-				log.Errorf("incorrect regexp %s for %s", entry, msg.Account)
+				flog.Errorf("incorrect regexp %s for %s", entry, msg.Account)
 				continue
 			}
 			if re.MatchString(msg.Text) {
-				log.Debugf("matching %s. ignoring %s from %s", entry, msg.Text, msg.Account)
+				flog.Debugf("matching %s. ignoring %s from %s", entry, msg.Text, msg.Account)
 				return true
 			}
 		}
@@ -248,13 +334,31 @@ func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
 	return false
 }
 
-func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
+func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) string {
 	br := gw.Bridges[msg.Account]
 	msg.Protocol = br.Protocol
-	nick := gw.Config.General.RemoteNickFormat
-	if nick == "" {
-		nick = dest.Config.RemoteNickFormat
+	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
@@ -267,62 +371,138 @@ func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
 		}
 		nick = strings.Replace(nick, "{NOPINGNICK}", msg.Username[:i]+"​"+msg.Username[i:], -1)
 	}
-	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
+
 	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
 	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
-	msg.Username = nick
+	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) {
+func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string {
 	iconurl := gw.Config.General.IconURL
 	if iconurl == "" {
-		iconurl = dest.Config.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 (gw *Gateway) validGatewayDest(msg *config.Message, channel *config.ChannelInfo) bool {
-	GIDmap := gw.Channels[getChannelID(*msg)].GID
-
-	// gateway is specified in message (probably from api)
-	if msg.Gateway != "" {
-		return channel.GID[msg.Gateway]
-	}
-
-	// check if we are running a samechannelgateway.
-	// if it is and the channel name matches it's ok, otherwise we shouldn't use this channel.
-	for k, _ := range GIDmap {
-		if channel.SameChannel[k] == true {
-			if msg.Channel == channel.Name {
-				// add the gateway to our message
-				msg.Gateway = k
-				return true
-			} else {
-				return false
-			}
-		}
-	}
-	// check if we are in the correct gateway
-	for k, _ := range GIDmap {
-		if channel.GID[k] == true {
-			// add the gateway to our message
-			msg.Gateway = k
-			return true
-		}
-	}
-	return false
-}
-
 func isApi(account string) bool {
-	if strings.HasPrefix(account, "api.") {
-		return true
-	}
-	return false
+	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_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

@@ -99,10 +99,9 @@ func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 // Receive returns an incoming message from mattermost outgoing webhooks URL.
 func (c *Client) Receive() Message {
-	for {
-		select {
-		case msg := <-c.In:
-			return msg
-		}
+	var msg Message
+	for msg = range c.In {
+		return msg
 	}
+	return msg
 }

matterbridge.go

@@ -3,24 +3,24 @@ 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"
-	"strings"
+	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/sirupsen/logrus"
 )
 
 var (
-	version = "0.15.0"
+	version = "1.11.3"
 	githash string
 )
 
-func init() {
-	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
-}
-
 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")
@@ -34,32 +34,25 @@ func main() {
 		fmt.Printf("version: %s %s\n", version, githash)
 		return
 	}
-	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)
 	}
-	log.Printf("Running version %s %s", version, githash)
+	flog.Printf("Running version %s %s", version, githash)
 	if strings.Contains(version, "-dev") {
-		log.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
+		flog.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
 	}
 	cfg := config.NewConfig(*flagConfig)
-
-	g := gateway.New(cfg)
-	sgw := samechannelgateway.New(cfg)
-	gwconfigs := sgw.GetConfig()
-	for _, gw := range append(gwconfigs, cfg.Gateway...) {
-		if !gw.Enable {
-			continue
-		}
-		err := g.AddConfig(&gw)
-		if err != nil {
-			log.Fatalf("Starting gateway failed: %s", err)
-		}
-	}
-	err := g.Start()
+	cfg.General.Debug = *flagDebug
+	r, err := gateway.NewRouter(cfg)
 	if err != nil {
-		log.Fatalf("Starting gateway failed: %s", err)
+		flog.Fatalf("Starting gateway failed: %s", err)
 	}
-	log.Printf("Gateway(s) started succesfully. Now relaying messages")
+	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

@@ -6,7 +6,6 @@
 
 [mattermost]
     [mattermost.work]
-    useAPI=true
     #do not prefix it wit http:// or https://
     Server="yourmattermostserver.domain" 
     Team="yourteam"

matterclient/matterclient.go

@@ -1,6 +1,7 @@
 package matterclient
 
 import (
+	"crypto/md5"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -8,14 +9,15 @@ import (
 	"net/http"
 	"net/http/cookiejar"
 	"net/url"
-	"strconv"
 	"strings"
 	"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"
 )
@@ -43,8 +45,8 @@ type Message struct {
 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
 }
 
@@ -53,7 +55,7 @@ type MMClient struct {
 	*Credentials
 	Team          *Team
 	OtherTeams    []*Team
-	Client        *model.Client
+	Client        *model.Client4
 	User          *model.User
 	Users         map[string]*model.User
 	MessageChan   chan *Message
@@ -65,16 +67,23 @@ type MMClient struct {
 	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 {
@@ -87,7 +96,7 @@ 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 == true {
+	if m.WsConnected {
 		firstConnection = false
 	}
 	m.WsConnected = false
@@ -100,24 +109,25 @@ 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 = 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
-		m.Client.GetClientProperties()
-		if firstConnection && !supportedVersion(m.Client.ServerVersion) {
-			return fmt.Errorf("unsupported mattermost version: %s", m.Client.ServerVersion)
+		_, resp := m.Client.Logout()
+		if resp.Error != nil {
+			return fmt.Errorf("%#v", resp.Error.Error())
 		}
-		m.ServerVersion = m.Client.ServerVersion
+		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)
@@ -128,30 +138,33 @@ func (m *MMClient) Login() error {
 	}
 	b.Reset()
 
-	var myinfo *model.Result
+	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)
@@ -177,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_V3 + "/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.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()
@@ -199,15 +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 {
@@ -215,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
 }
@@ -240,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
 		}
@@ -263,8 +308,13 @@ func (m *MMClient) WsReceiver() {
 
 func (m *MMClient) parseMessage(rmsg *Message) {
 	switch rmsg.Raw.Event {
-	case model.WEBSOCKET_EVENT_POSTED, model.WEBSOCKET_EVENT_POST_EDITED:
+	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)
@@ -284,10 +334,18 @@ 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.GetUserName(data.UserId)
 	rmsg.Channel = m.GetChannelName(data.ChannelId)
@@ -309,37 +367,37 @@ func (m *MMClient) parseActionPost(rmsg *Message) {
 	}
 	rmsg.Text = data.Message
 	rmsg.Post = data
-	return
 }
 
 func (m *MMClient) UpdateUsers() error {
-	mmusers, err := m.Client.GetProfiles(0, 50000, "")
-	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)
-	}
-	var mmchannels2 *model.Result
-	if m.mmVersion() >= 3.08 {
-		mmchannels2, err = m.Client.GetMoreChannelsPage(0, 5000)
-	} else {
-		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
 }
@@ -348,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
+				}
 			}
 		}
 	}
@@ -365,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
 				}
@@ -379,7 +449,7 @@ 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...) {
+		for _, channel := range append(t.Channels, t.MoreChannels...) {
 			if channel.Id == id {
 				return channel.TeamId
 			}
@@ -392,7 +462,7 @@ 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
 			}
@@ -402,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
@@ -459,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)
@@ -469,44 +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)
-	if m.mmVersion() >= 3.08 {
-		view := model.ChannelView{ChannelId: channelId}
-		res, _ := m.Client.ViewChannel(view)
-		if res == false {
-			m.log.Errorf("ChannelView update for %s failed", channelId)
-		}
-		return
-	}
-	_, 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
 }
@@ -530,22 +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, err := m.Client.GetChannels("")
-	if err != nil {
-		m.log.Debug("SendDirectMessage: Couldn't update channels")
-		return
-	}
-	m.Lock()
-	m.Team.Channels = mmchannels.Data.(*model.ChannelList)
-	m.Unlock()
+	m.UpdateChannels()
 
 	// build & send the message
 	msg = strings.Replace(msg, "\r", "", -1)
@@ -571,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
@@ -586,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
 }
@@ -597,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
@@ -611,12 +724,11 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 func (m *MMClient) GetLastViewedAt(channelId string) int64 {
 	m.RLock()
 	defer m.RUnlock()
-	res, err := m.Client.GetChannel(channelId, "")
-	if err != nil {
+	res, resp := m.Client.GetChannelMember(channelId, m.User.Id, "")
+	if resp.Error != nil {
 		return model.GetMillis()
 	}
-	data := res.Data.(*model.ChannelData)
-	return data.Member.LastViewedAt
+	return res.LastViewedAt
 }
 
 func (m *MMClient) GetUsers() map[string]*model.User {
@@ -630,11 +742,29 @@ 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 {
@@ -643,37 +773,53 @@ func (m *MMClient) GetUserName(userId string) string {
 	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 ok bool
+	var ids []string
 	statuses := make(map[string]string)
-	res, err := m.Client.GetStatuses()
-	if err != nil {
+	for id := range m.Users {
+		ids = append(ids, id)
+	}
+	res, resp := m.Client.GetUsersStatusesByIds(ids)
+	if resp.Error != nil {
 		return statuses
 	}
-	if statuses, ok = res.Data.(map[string]string); ok {
-		for userId, status := range statuses {
-			statuses[userId] = "offline"
-			if status == model.STATUS_AWAY {
-				statuses[userId] = "away"
-			}
-			if status == model.STATUS_ONLINE {
-				statuses[userId] = "online"
-			}
+	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
@@ -683,7 +829,21 @@ 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
@@ -694,14 +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()
-				go m.WsReceiver()
+				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)
 	}
 }
 
@@ -709,40 +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, err := m.Client.GetProfiles(0, 50000, "")
-		if err != nil {
-			return errors.New(err.DetailedError)
+	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)
 		}
-		t := &Team{Team: v, Users: mmusers.Data.(map[string]*model.User), Id: v.Id}
-		mmchannels, err := m.Client.GetChannels("")
-		if err != nil {
-			return errors.New(err.DetailedError)
+		usermap := make(map[string]*model.User)
+		for _, user := range mmusers {
+			usermap[user.Id] = user
 		}
-		t.Channels = mmchannels.Data.(*model.ChannelList)
-		if m.mmVersion() >= 3.08 {
-			mmchannels, err = m.Client.GetMoreChannelsPage(0, 5000)
-		} else {
-			mmchannels, err = m.Client.GetMoreChannels("")
+
+		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
 		}
-		if err != nil {
-			return errors.New(err.DetailedError)
+		t.Channels = mmchannels
+		mmchannels, resp = m.Client.GetPublicChannelsForTeam(team.Id, 0, 5000, "")
+		if resp.Error != nil {
+			return resp.Error
 		}
-		t.MoreChannels = mmchannels.Data.(*model.ChannelList)
+		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 {
@@ -763,22 +936,17 @@ func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) err
 	return nil
 }
 
-func (m *MMClient) mmVersion() float64 {
-	v, _ := strconv.ParseFloat(string(m.ServerVersion[0:2])+"0"+string(m.ServerVersion[2]), 64)
-	if string(m.ServerVersion[4]) == "." {
-		v, _ = strconv.ParseFloat(m.ServerVersion[0:4], 64)
-	}
-	return v
-}
-
 func supportedVersion(version string) bool {
-	if strings.HasPrefix(version, "3.5.0") ||
-		strings.HasPrefix(version, "3.6.0") ||
-		strings.HasPrefix(version, "3.7.0") ||
-		strings.HasPrefix(version, "3.8.0") ||
+	if strings.HasPrefix(version, "3.8.0") ||
 		strings.HasPrefix(version, "3.9.0") ||
-		strings.HasPrefix(version, "3.10.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,24 +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)
@@ -43,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.
@@ -134,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

@@ -205,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
@@ -265,7 +291,7 @@ func (gitter *Gitter) SearchRooms(room string) ([]Room, error) {
 		Results []Room `json:"results"`
 	}
 
-	response, err := gitter.get(gitter.config.apiBaseURL + "rooms?q=" + room )
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms?q=" + room)
 
 	if err != nil {
 		gitter.log(err)
@@ -414,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/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/session.vim

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

vendor/github.com/GeertJohan/go.rice/appended.go

@@ -1,138 +0,0 @@
-package rice
-
-import (
-	"archive/zip"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/daaku/go.zipexe"
-	"github.com/kardianos/osext"
-)
-
-// appendedBox defines an appended box
-type appendedBox struct {
-	Name  string                   // box name
-	Files map[string]*appendedFile // appended files (*zip.File) by full path
-}
-
-type appendedFile struct {
-	zipFile  *zip.File
-	dir      bool
-	dirInfo  *appendedDirInfo
-	children []*appendedFile
-	content  []byte
-}
-
-// appendedBoxes is a public register of appendes boxes
-var appendedBoxes = make(map[string]*appendedBox)
-
-func init() {
-	// find if exec is appended
-	thisFile, err := osext.Executable()
-	if err != nil {
-		return // not appended or cant find self executable
-	}
-	closer, rd, err := zipexe.OpenCloser(thisFile)
-	if err != nil {
-		return // not appended
-	}
-	defer closer.Close()
-
-	for _, f := range rd.File {
-		// get box and file name from f.Name
-		fileParts := strings.SplitN(strings.TrimLeft(filepath.ToSlash(f.Name), "/"), "/", 2)
-		boxName := fileParts[0]
-		var fileName string
-		if len(fileParts) > 1 {
-			fileName = fileParts[1]
-		}
-
-		// find box or create new one if doesn't exist
-		box := appendedBoxes[boxName]
-		if box == nil {
-			box = &appendedBox{
-				Name:  boxName,
-				Files: make(map[string]*appendedFile),
-			}
-			appendedBoxes[boxName] = box
-		}
-
-		// create and add file to box
-		af := &appendedFile{
-			zipFile: f,
-		}
-		if f.Comment == "dir" {
-			af.dir = true
-			af.dirInfo = &appendedDirInfo{
-				name: filepath.Base(af.zipFile.Name),
-				//++ TODO: use zip modtime when that is set correctly: af.zipFile.ModTime()
-				time: time.Now(),
-			}
-		} else {
-			// this is a file, we need it's contents so we can create a bytes.Reader when the file is opened
-			// make a new byteslice
-			af.content = make([]byte, af.zipFile.FileInfo().Size())
-			// ignore reading empty files from zip (empty file still is a valid file to be read though!)
-			if len(af.content) > 0 {
-				// open io.ReadCloser
-				rc, err := af.zipFile.Open()
-				if err != nil {
-					af.content = nil // this will cause an error when the file is being opened or seeked (which is good)
-					// TODO: it's quite blunt to just log this stuff. but this is in init, so rice.Debug can't be changed yet..
-					log.Printf("error opening appended file %s: %v", af.zipFile.Name, err)
-				} else {
-					_, err = rc.Read(af.content)
-					rc.Close()
-					if err != nil {
-						af.content = nil // this will cause an error when the file is being opened or seeked (which is good)
-						// TODO: it's quite blunt to just log this stuff. but this is in init, so rice.Debug can't be changed yet..
-						log.Printf("error reading data for appended file %s: %v", af.zipFile.Name, err)
-					}
-				}
-			}
-		}
-
-		// add appendedFile to box file list
-		box.Files[fileName] = af
-
-		// add to parent dir (if any)
-		dirName := filepath.Dir(fileName)
-		if dirName == "." {
-			dirName = ""
-		}
-		if fileName != "" { // don't make box root dir a child of itself
-			if dir := box.Files[dirName]; dir != nil {
-				dir.children = append(dir.children, af)
-			}
-		}
-	}
-}
-
-// implements os.FileInfo.
-// used for Readdir()
-type appendedDirInfo struct {
-	name string
-	time time.Time
-}
-
-func (adi *appendedDirInfo) Name() string {
-	return adi.name
-}
-func (adi *appendedDirInfo) Size() int64 {
-	return 0
-}
-func (adi *appendedDirInfo) Mode() os.FileMode {
-	return os.ModeDir
-}
-func (adi *appendedDirInfo) ModTime() time.Time {
-	return adi.time
-}
-func (adi *appendedDirInfo) IsDir() bool {
-	return true
-}
-func (adi *appendedDirInfo) Sys() interface{} {
-	return nil
-}

vendor/github.com/GeertJohan/go.rice/box.go

@@ -1,337 +0,0 @@
-package rice
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/GeertJohan/go.rice/embedded"
-)
-
-// Box abstracts a directory for resources/files.
-// It can either load files from disk, or from embedded code (when `rice --embed` was ran).
-type Box struct {
-	name         string
-	absolutePath string
-	embed        *embedded.EmbeddedBox
-	appendd      *appendedBox
-}
-
-var defaultLocateOrder = []LocateMethod{LocateEmbedded, LocateAppended, LocateFS}
-
-func findBox(name string, order []LocateMethod) (*Box, error) {
-	b := &Box{name: name}
-
-	// no support for absolute paths since gopath can be different on different machines.
-	// therefore, required box must be located relative to package requiring it.
-	if filepath.IsAbs(name) {
-		return nil, errors.New("given name/path is absolute")
-	}
-
-	var err error
-	for _, method := range order {
-		switch method {
-		case LocateEmbedded:
-			if embed := embedded.EmbeddedBoxes[name]; embed != nil {
-				b.embed = embed
-				return b, nil
-			}
-
-		case LocateAppended:
-			appendedBoxName := strings.Replace(name, `/`, `-`, -1)
-			if appendd := appendedBoxes[appendedBoxName]; appendd != nil {
-				b.appendd = appendd
-				return b, nil
-			}
-
-		case LocateFS:
-			// resolve absolute directory path
-			err := b.resolveAbsolutePathFromCaller()
-			if err != nil {
-				continue
-			}
-			// check if absolutePath exists on filesystem
-			info, err := os.Stat(b.absolutePath)
-			if err != nil {
-				continue
-			}
-			// check if absolutePath is actually a directory
-			if !info.IsDir() {
-				err = errors.New("given name/path is not a directory")
-				continue
-			}
-			return b, nil
-		case LocateWorkingDirectory:
-			// resolve absolute directory path
-			err := b.resolveAbsolutePathFromWorkingDirectory()
-			if err != nil {
-				continue
-			}
-			// check if absolutePath exists on filesystem
-			info, err := os.Stat(b.absolutePath)
-			if err != nil {
-				continue
-			}
-			// check if absolutePath is actually a directory
-			if !info.IsDir() {
-				err = errors.New("given name/path is not a directory")
-				continue
-			}
-			return b, nil
-		}
-	}
-
-	if err == nil {
-		err = fmt.Errorf("could not locate box %q", name)
-	}
-
-	return nil, err
-}
-
-// FindBox returns a Box instance for given name.
-// When the given name is a relative path, it's base path will be the calling pkg/cmd's source root.
-// When the given name is absolute, it's absolute. derp.
-// Make sure the path doesn't contain any sensitive information as it might be placed into generated go source (embedded).
-func FindBox(name string) (*Box, error) {
-	return findBox(name, defaultLocateOrder)
-}
-
-// MustFindBox returns a Box instance for given name, like FindBox does.
-// It does not return an error, instead it panics when an error occurs.
-func MustFindBox(name string) *Box {
-	box, err := findBox(name, defaultLocateOrder)
-	if err != nil {
-		panic(err)
-	}
-	return box
-}
-
-// This is injected as a mutable function literal so that we can mock it out in
-// tests and return a fixed test file.
-var resolveAbsolutePathFromCaller = func(name string, nStackFrames int) (string, error) {
-	_, callingGoFile, _, ok := runtime.Caller(nStackFrames)
-	if !ok {
-		return "", errors.New("couldn't find caller on stack")
-	}
-
-	// resolve to proper path
-	pkgDir := filepath.Dir(callingGoFile)
-	// fix for go cover
-	const coverPath = "_test/_obj_test"
-	if !filepath.IsAbs(pkgDir) {
-		if i := strings.Index(pkgDir, coverPath); i >= 0 {
-			pkgDir = pkgDir[:i] + pkgDir[i+len(coverPath):]            // remove coverPath
-			pkgDir = filepath.Join(os.Getenv("GOPATH"), "src", pkgDir) // make absolute
-		}
-	}
-	return filepath.Join(pkgDir, name), nil
-}
-
-func (b *Box) resolveAbsolutePathFromCaller() error {
-	path, err := resolveAbsolutePathFromCaller(b.name, 4)
-	if err != nil {
-		return err
-	}
-	b.absolutePath = path
-	return nil
-
-}
-
-func (b *Box) resolveAbsolutePathFromWorkingDirectory() error {
-	path, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-	b.absolutePath = filepath.Join(path, b.name)
-	return nil
-}
-
-// IsEmbedded indicates wether this box was embedded into the application
-func (b *Box) IsEmbedded() bool {
-	return b.embed != nil
-}
-
-// IsAppended indicates wether this box was appended to the application
-func (b *Box) IsAppended() bool {
-	return b.appendd != nil
-}
-
-// Time returns how actual the box is.
-// When the box is embedded, it's value is saved in the embedding code.
-// When the box is live, this methods returns time.Now()
-func (b *Box) Time() time.Time {
-	if b.IsEmbedded() {
-		return b.embed.Time
-	}
-
-	//++ TODO: return time for appended box
-
-	return time.Now()
-}
-
-// Open opens a File from the box
-// If there is an error, it will be of type *os.PathError.
-func (b *Box) Open(name string) (*File, error) {
-	if Debug {
-		fmt.Printf("Open(%s)\n", name)
-	}
-
-	if b.IsEmbedded() {
-		if Debug {
-			fmt.Println("Box is embedded")
-		}
-
-		// trim prefix (paths are relative to box)
-		name = strings.TrimLeft(name, "/")
-		if Debug {
-			fmt.Printf("Trying %s\n", name)
-		}
-
-		// search for file
-		ef := b.embed.Files[name]
-		if ef == nil {
-			if Debug {
-				fmt.Println("Didn't find file in embed")
-			}
-			// file not found, try dir
-			ed := b.embed.Dirs[name]
-			if ed == nil {
-				if Debug {
-					fmt.Println("Didn't find dir in embed")
-				}
-				// dir not found, error out
-				return nil, &os.PathError{
-					Op:   "open",
-					Path: name,
-					Err:  os.ErrNotExist,
-				}
-			}
-			if Debug {
-				fmt.Println("Found dir. Returning virtual dir")
-			}
-			vd := newVirtualDir(ed)
-			return &File{virtualD: vd}, nil
-		}
-
-		// box is embedded
-		if Debug {
-			fmt.Println("Found file. Returning virtual file")
-		}
-		vf := newVirtualFile(ef)
-		return &File{virtualF: vf}, nil
-	}
-
-	if b.IsAppended() {
-		// trim prefix (paths are relative to box)
-		name = strings.TrimLeft(name, "/")
-
-		// search for file
-		appendedFile := b.appendd.Files[name]
-		if appendedFile == nil {
-			return nil, &os.PathError{
-				Op:   "open",
-				Path: name,
-				Err:  os.ErrNotExist,
-			}
-		}
-
-		// create new file
-		f := &File{
-			appendedF: appendedFile,
-		}
-
-		// if this file is a directory, we want to be able to read and seek
-		if !appendedFile.dir {
-			// looks like malformed data in zip, error now
-			if appendedFile.content == nil {
-				return nil, &os.PathError{
-					Op:   "open",
-					Path: "name",
-					Err:  errors.New("error reading data from zip file"),
-				}
-			}
-			// create new bytes.Reader
-			f.appendedFileReader = bytes.NewReader(appendedFile.content)
-		}
-
-		// all done
-		return f, nil
-	}
-
-	// perform os open
-	if Debug {
-		fmt.Printf("Using os.Open(%s)", filepath.Join(b.absolutePath, name))
-	}
-	file, err := os.Open(filepath.Join(b.absolutePath, name))
-	if err != nil {
-		return nil, err
-	}
-	return &File{realF: file}, nil
-}
-
-// Bytes returns the content of the file with given name as []byte.
-func (b *Box) Bytes(name string) ([]byte, error) {
-	file, err := b.Open(name)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	content, err := ioutil.ReadAll(file)
-	if err != nil {
-		return nil, err
-	}
-
-	return content, nil
-}
-
-// MustBytes returns the content of the file with given name as []byte.
-// panic's on error.
-func (b *Box) MustBytes(name string) []byte {
-	bts, err := b.Bytes(name)
-	if err != nil {
-		panic(err)
-	}
-	return bts
-}
-
-// String returns the content of the file with given name as string.
-func (b *Box) String(name string) (string, error) {
-	// check if box is embedded, optimized fast path
-	if b.IsEmbedded() {
-		// find file in embed
-		ef := b.embed.Files[name]
-		if ef == nil {
-			return "", os.ErrNotExist
-		}
-		// return as string
-		return ef.Content, nil
-	}
-
-	bts, err := b.Bytes(name)
-	if err != nil {
-		return "", err
-	}
-	return string(bts), nil
-}
-
-// MustString returns the content of the file with given name as string.
-// panic's on error.
-func (b *Box) MustString(name string) string {
-	str, err := b.String(name)
-	if err != nil {
-		panic(err)
-	}
-	return str
-}
-
-// Name returns the name of the box
-func (b *Box) Name() string {
-	return b.name
-}

vendor/github.com/GeertJohan/go.rice/config.go

@@ -1,39 +0,0 @@
-package rice
-
-// LocateMethod defines how a box is located.
-type LocateMethod int
-
-const (
-	LocateFS               = LocateMethod(iota) // Locate on the filesystem according to package path.
-	LocateAppended                              // Locate boxes appended to the executable.
-	LocateEmbedded                              // Locate embedded boxes.
-	LocateWorkingDirectory                      // Locate on the binary working directory
-)
-
-// Config allows customizing the box lookup behavior.
-type Config struct {
-	// LocateOrder defines the priority order that boxes are searched for. By
-	// default, the package global FindBox searches for embedded boxes first,
-	// then appended boxes, and then finally boxes on the filesystem.  That
-	// search order may be customized by provided the ordered list here. Leaving
-	// out a particular method will omit that from the search space. For
-	// example, []LocateMethod{LocateEmbedded, LocateAppended} will never search
-	// the filesystem for boxes.
-	LocateOrder []LocateMethod
-}
-
-// FindBox searches for boxes using the LocateOrder of the config.
-func (c *Config) FindBox(boxName string) (*Box, error) {
-	return findBox(boxName, c.LocateOrder)
-}
-
-// MustFindBox searches for boxes using the LocateOrder of the config, like
-// FindBox does.  It does not return an error, instead it panics when an error
-// occurs.
-func (c *Config) MustFindBox(boxName string) *Box {
-	box, err := findBox(boxName, c.LocateOrder)
-	if err != nil {
-		panic(err)
-	}
-	return box
-}

vendor/github.com/GeertJohan/go.rice/debug.go

@@ -1,4 +0,0 @@
-package rice
-
-// Debug can be set to true to enable debugging.
-var Debug = false

vendor/github.com/GeertJohan/go.rice/embedded.go

@@ -1,90 +0,0 @@
-package rice
-
-import (
-	"os"
-	"time"
-
-	"github.com/GeertJohan/go.rice/embedded"
-)
-
-// re-type to make exported methods invisible to user (godoc)
-// they're not required for the user
-// embeddedDirInfo implements os.FileInfo
-type embeddedDirInfo embedded.EmbeddedDir
-
-// Name returns the base name of the directory
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) Name() string {
-	return ed.Filename
-}
-
-// Size always returns 0
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) Size() int64 {
-	return 0
-}
-
-// Mode returns the file mode bits
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) Mode() os.FileMode {
-	return os.FileMode(0555 | os.ModeDir) // dr-xr-xr-x
-}
-
-// ModTime returns the modification time
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) ModTime() time.Time {
-	return ed.DirModTime
-}
-
-// IsDir returns the abbreviation for Mode().IsDir() (always true)
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) IsDir() bool {
-	return true
-}
-
-// Sys returns the underlying data source (always nil)
-// (implementing os.FileInfo)
-func (ed *embeddedDirInfo) Sys() interface{} {
-	return nil
-}
-
-// re-type to make exported methods invisible to user (godoc)
-// they're not required for the user
-// embeddedFileInfo implements os.FileInfo
-type embeddedFileInfo embedded.EmbeddedFile
-
-// Name returns the base name of the file
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) Name() string {
-	return ef.Filename
-}
-
-// Size returns the length in bytes for regular files; system-dependent for others
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) Size() int64 {
-	return int64(len(ef.Content))
-}
-
-// Mode returns the file mode bits
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) Mode() os.FileMode {
-	return os.FileMode(0555) // r-xr-xr-x
-}
-
-// ModTime returns the modification time
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) ModTime() time.Time {
-	return ef.FileModTime
-}
-
-// IsDir returns the abbreviation for Mode().IsDir() (always false)
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) IsDir() bool {
-	return false
-}
-
-// Sys returns the underlying data source (always nil)
-// (implementing os.FileInfo)
-func (ef *embeddedFileInfo) Sys() interface{} {
-	return nil
-}

vendor/github.com/GeertJohan/go.rice/embedded/embedded.go

@@ -1,80 +0,0 @@
-// Package embedded defines embedded data types that are shared between the go.rice package and generated code.
-package embedded
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-const (
-	EmbedTypeGo   = 0
-	EmbedTypeSyso = 1
-)
-
-// EmbeddedBox defines an embedded box
-type EmbeddedBox struct {
-	Name      string                   // box name
-	Time      time.Time                // embed time
-	EmbedType int                      // kind of embedding
-	Files     map[string]*EmbeddedFile // ALL embedded files by full path
-	Dirs      map[string]*EmbeddedDir  // ALL embedded dirs by full path
-}
-
-// Link creates the ChildDirs and ChildFiles links in all EmbeddedDir's
-func (e *EmbeddedBox) Link() {
-	for path, ed := range e.Dirs {
-		fmt.Println(path)
-		ed.ChildDirs = make([]*EmbeddedDir, 0)
-		ed.ChildFiles = make([]*EmbeddedFile, 0)
-	}
-	for path, ed := range e.Dirs {
-		parentDirpath, _ := filepath.Split(path)
-		if strings.HasSuffix(parentDirpath, "/") {
-			parentDirpath = parentDirpath[:len(parentDirpath)-1]
-		}
-		parentDir := e.Dirs[parentDirpath]
-		if parentDir == nil {
-			panic("parentDir `" + parentDirpath + "` is missing in embedded box")
-		}
-		parentDir.ChildDirs = append(parentDir.ChildDirs, ed)
-	}
-	for path, ef := range e.Files {
-		dirpath, _ := filepath.Split(path)
-		if strings.HasSuffix(dirpath, "/") {
-			dirpath = dirpath[:len(dirpath)-1]
-		}
-		dir := e.Dirs[dirpath]
-		if dir == nil {
-			panic("dir `" + dirpath + "` is missing in embedded box")
-		}
-		dir.ChildFiles = append(dir.ChildFiles, ef)
-	}
-}
-
-// EmbeddedDir is instanced in the code generated by the rice tool and contains all necicary information about an embedded file
-type EmbeddedDir struct {
-	Filename   string
-	DirModTime time.Time
-	ChildDirs  []*EmbeddedDir  // direct childs, as returned by virtualDir.Readdir()
-	ChildFiles []*EmbeddedFile // direct childs, as returned by virtualDir.Readdir()
-}
-
-// EmbeddedFile is instanced in the code generated by the rice tool and contains all necicary information about an embedded file
-type EmbeddedFile struct {
-	Filename    string // filename
-	FileModTime time.Time
-	Content     string
-}
-
-// EmbeddedBoxes is a public register of embedded boxes
-var EmbeddedBoxes = make(map[string]*EmbeddedBox)
-
-// RegisterEmbeddedBox registers an EmbeddedBox
-func RegisterEmbeddedBox(name string, box *EmbeddedBox) {
-	if _, exists := EmbeddedBoxes[name]; exists {
-		panic(fmt.Sprintf("EmbeddedBox with name `%s` exists already", name))
-	}
-	EmbeddedBoxes[name] = box
-}

vendor/github.com/GeertJohan/go.rice/example/example.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"encoding/hex"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"text/template"
-
-	"github.com/GeertJohan/go.rice"
-	"github.com/davecgh/go-spew/spew"
-)
-
-func main() {
-	conf := rice.Config{
-		LocateOrder: []rice.LocateMethod{rice.LocateEmbedded, rice.LocateAppended, rice.LocateFS},
-	}
-	box, err := conf.FindBox("example-files")
-	if err != nil {
-		log.Fatalf("error opening rice.Box: %s\n", err)
-	}
-	// spew.Dump(box)
-
-	contentString, err := box.String("file.txt")
-	if err != nil {
-		log.Fatalf("could not read file contents as string: %s\n", err)
-	}
-	log.Printf("Read some file contents as string:\n%s\n", contentString)
-
-	contentBytes, err := box.Bytes("file.txt")
-	if err != nil {
-		log.Fatalf("could not read file contents as byteSlice: %s\n", err)
-	}
-	log.Printf("Read some file contents as byteSlice:\n%s\n", hex.Dump(contentBytes))
-
-	file, err := box.Open("file.txt")
-	if err != nil {
-		log.Fatalf("could not open file: %s\n", err)
-	}
-	spew.Dump(file)
-
-	// find/create a rice.Box
-	templateBox, err := rice.FindBox("example-templates")
-	if err != nil {
-		log.Fatal(err)
-	}
-	// get file contents as string
-	templateString, err := templateBox.String("message.tmpl")
-	if err != nil {
-		log.Fatal(err)
-	}
-	// parse and execute the template
-	tmplMessage, err := template.New("message").Parse(templateString)
-	if err != nil {
-		log.Fatal(err)
-	}
-	tmplMessage.Execute(os.Stdout, map[string]string{"Message": "Hello, world!"})
-
-	http.Handle("/", http.FileServer(box.HTTPBox()))
-	go func() {
-		fmt.Println("Serving files on :8080, press ctrl-C to exit")
-		err := http.ListenAndServe(":8080", nil)
-		if err != nil {
-			log.Fatalf("error serving files: %v", err)
-		}
-	}()
-	select {}
-}

vendor/github.com/GeertJohan/go.rice/file.go

@@ -1,144 +0,0 @@
-package rice
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-)
-
-// File implements the io.Reader, io.Seeker, io.Closer and http.File interfaces
-type File struct {
-	// File abstracts file methods so the user doesn't see the difference between rice.virtualFile, rice.virtualDir and os.File
-	// TODO: maybe use internal File interface and four implementations: *os.File, appendedFile, virtualFile, virtualDir
-
-	// real file on disk
-	realF *os.File
-
-	// when embedded (go)
-	virtualF *virtualFile
-	virtualD *virtualDir
-
-	// when appended (zip)
-	appendedF          *appendedFile
-	appendedFileReader *bytes.Reader
-	// TODO: is appendedFileReader subject of races? Might need a lock here..
-}
-
-// Close is like (*os.File).Close()
-// Visit http://golang.org/pkg/os/#File.Close for more information
-func (f *File) Close() error {
-	if f.appendedF != nil {
-		if f.appendedFileReader == nil {
-			return errors.New("already closed")
-		}
-		f.appendedFileReader = nil
-		return nil
-	}
-	if f.virtualF != nil {
-		return f.virtualF.close()
-	}
-	if f.virtualD != nil {
-		return f.virtualD.close()
-	}
-	return f.realF.Close()
-}
-
-// Stat is like (*os.File).Stat()
-// Visit http://golang.org/pkg/os/#File.Stat for more information
-func (f *File) Stat() (os.FileInfo, error) {
-	if f.appendedF != nil {
-		if f.appendedF.dir {
-			return f.appendedF.dirInfo, nil
-		}
-		if f.appendedFileReader == nil {
-			return nil, errors.New("file is closed")
-		}
-		return f.appendedF.zipFile.FileInfo(), nil
-	}
-	if f.virtualF != nil {
-		return f.virtualF.stat()
-	}
-	if f.virtualD != nil {
-		return f.virtualD.stat()
-	}
-	return f.realF.Stat()
-}
-
-// Readdir is like (*os.File).Readdir()
-// Visit http://golang.org/pkg/os/#File.Readdir for more information
-func (f *File) Readdir(count int) ([]os.FileInfo, error) {
-	if f.appendedF != nil {
-		if f.appendedF.dir {
-			fi := make([]os.FileInfo, 0, len(f.appendedF.children))
-			for _, childAppendedFile := range f.appendedF.children {
-				if childAppendedFile.dir {
-					fi = append(fi, childAppendedFile.dirInfo)
-				} else {
-					fi = append(fi, childAppendedFile.zipFile.FileInfo())
-				}
-			}
-			return fi, nil
-		}
-		//++ TODO: is os.ErrInvalid the correct error for Readdir on file?
-		return nil, os.ErrInvalid
-	}
-	if f.virtualF != nil {
-		return f.virtualF.readdir(count)
-	}
-	if f.virtualD != nil {
-		return f.virtualD.readdir(count)
-	}
-	return f.realF.Readdir(count)
-}
-
-// Read is like (*os.File).Read()
-// Visit http://golang.org/pkg/os/#File.Read for more information
-func (f *File) Read(bts []byte) (int, error) {
-	if f.appendedF != nil {
-		if f.appendedFileReader == nil {
-			return 0, &os.PathError{
-				Op:   "read",
-				Path: filepath.Base(f.appendedF.zipFile.Name),
-				Err:  errors.New("file is closed"),
-			}
-		}
-		if f.appendedF.dir {
-			return 0, &os.PathError{
-				Op:   "read",
-				Path: filepath.Base(f.appendedF.zipFile.Name),
-				Err:  errors.New("is a directory"),
-			}
-		}
-		return f.appendedFileReader.Read(bts)
-	}
-	if f.virtualF != nil {
-		return f.virtualF.read(bts)
-	}
-	if f.virtualD != nil {
-		return f.virtualD.read(bts)
-	}
-	return f.realF.Read(bts)
-}
-
-// Seek is like (*os.File).Seek()
-// Visit http://golang.org/pkg/os/#File.Seek for more information
-func (f *File) Seek(offset int64, whence int) (int64, error) {
-	if f.appendedF != nil {
-		if f.appendedFileReader == nil {
-			return 0, &os.PathError{
-				Op:   "seek",
-				Path: filepath.Base(f.appendedF.zipFile.Name),
-				Err:  errors.New("file is closed"),
-			}
-		}
-		return f.appendedFileReader.Seek(offset, whence)
-	}
-	if f.virtualF != nil {
-		return f.virtualF.seek(offset, whence)
-	}
-	if f.virtualD != nil {
-		return f.virtualD.seek(offset, whence)
-	}
-	return f.realF.Seek(offset, whence)
-}

vendor/github.com/GeertJohan/go.rice/http.go

@@ -1,21 +0,0 @@
-package rice
-
-import (
-	"net/http"
-)
-
-// HTTPBox implements http.FileSystem which allows the use of Box with a http.FileServer.
-//   e.g.: http.Handle("/", http.FileServer(rice.MustFindBox("http-files").HTTPBox()))
-type HTTPBox struct {
-	*Box
-}
-
-// HTTPBox creates a new HTTPBox from an existing Box
-func (b *Box) HTTPBox() *HTTPBox {
-	return &HTTPBox{b}
-}
-
-// Open returns a File using the http.File interface
-func (hb *HTTPBox) Open(name string) (http.File, error) {
-	return hb.Box.Open(name)
-}

vendor/github.com/GeertJohan/go.rice/rice/append.go

@@ -1,172 +0,0 @@
-package main
-
-import (
-	"archive/zip"
-	"fmt"
-	"go/build"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/daaku/go.zipexe"
-)
-
-func operationAppend(pkgs []*build.Package) {
-	if runtime.GOOS == "windows" {
-		_, err := exec.LookPath("zip")
-		if err != nil {
-			fmt.Println("#### WARNING ! ####")
-			fmt.Println("`rice append` is known not to work under windows because the `zip` command is not available. Please let me know if you got this to work (and how).")
-		}
-	}
-
-	// MARKED FOR DELETION
-	// This is actually not required, the append command now has the option --exec required.
-	// // check if package is a command
-	// if !pkg.IsCommand() {
-	// 	fmt.Println("Error: can not append to non-main package. Please follow instructions at github.com/GeertJohan/go.rice")
-	// 	os.Exit(1)
-	// }
-
-	// create tmp zipfile
-	tmpZipfileName := filepath.Join(os.TempDir(), fmt.Sprintf("ricebox-%d-%s.zip", time.Now().Unix(), randomString(10)))
-	verbosef("Will create tmp zipfile: %s\n", tmpZipfileName)
-	tmpZipfile, err := os.Create(tmpZipfileName)
-	if err != nil {
-		fmt.Printf("Error creating tmp zipfile: %s\n", err)
-		os.Exit(1)
-	}
-	defer func() {
-		tmpZipfile.Close()
-		os.Remove(tmpZipfileName)
-	}()
-
-	// find abs path for binary file
-	binfileName, err := filepath.Abs(flags.Append.Executable)
-	if err != nil {
-		fmt.Printf("Error finding absolute path for executable to append: %s\n", err)
-		os.Exit(1)
-	}
-	verbosef("Will append to file: %s\n", binfileName)
-
-	// check that command doesn't already have zip appended
-	if rd, _ := zipexe.Open(binfileName); rd != nil {
-		fmt.Printf("Cannot append to already appended executable. Please remove %s and build a fresh one.\n", binfileName)
-		os.Exit(1)
-	}
-
-	// open binfile
-	binfile, err := os.OpenFile(binfileName, os.O_WRONLY, os.ModeAppend)
-	if err != nil {
-		fmt.Printf("Error: unable to open executable file: %s\n", err)
-		os.Exit(1)
-	}
-
-	// create zip.Writer
-	zipWriter := zip.NewWriter(tmpZipfile)
-
-	for _, pkg := range pkgs {
-		// find boxes for this command
-		boxMap := findBoxes(pkg)
-
-		// notify user when no calls to rice.FindBox are made (is this an error and therefore os.Exit(1) ?
-		if len(boxMap) == 0 {
-			fmt.Printf("no calls to rice.FindBox() or rice.MustFindBox() found in import path `%s`\n", pkg.ImportPath)
-			continue
-		}
-
-		verbosef("\n")
-
-		for boxname := range boxMap {
-			appendedBoxName := strings.Replace(boxname, `/`, `-`, -1)
-
-			// walk box path's and insert files
-			boxPath := filepath.Clean(filepath.Join(pkg.Dir, boxname))
-			filepath.Walk(boxPath, func(path string, info os.FileInfo, err error) error {
-				if info == nil {
-					fmt.Printf("Error: box \"%s\" not found on disk\n", path)
-					os.Exit(1)
-				}
-				// create zipFilename
-				zipFileName := filepath.Join(appendedBoxName, strings.TrimPrefix(path, boxPath))
-				// write directories as empty file with comment "dir"
-				if info.IsDir() {
-					_, err := zipWriter.CreateHeader(&zip.FileHeader{
-						Name:    zipFileName,
-						Comment: "dir",
-					})
-					if err != nil {
-						fmt.Printf("Error creating dir in tmp zip: %s\n", err)
-						os.Exit(1)
-					}
-					return nil
-				}
-
-				// create zipFileWriter
-				zipFileHeader, err := zip.FileInfoHeader(info)
-				if err != nil {
-					fmt.Printf("Error creating zip FileHeader: %v\n", err)
-					os.Exit(1)
-				}
-				zipFileHeader.Name = zipFileName
-				zipFileWriter, err := zipWriter.CreateHeader(zipFileHeader)
-				if err != nil {
-					fmt.Printf("Error creating file in tmp zip: %s\n", err)
-					os.Exit(1)
-				}
-				srcFile, err := os.Open(path)
-				if err != nil {
-					fmt.Printf("Error opening file to append: %s\n", err)
-					os.Exit(1)
-				}
-				_, err = io.Copy(zipFileWriter, srcFile)
-				if err != nil {
-					fmt.Printf("Error copying file contents to zip: %s\n", err)
-					os.Exit(1)
-				}
-				srcFile.Close()
-
-				return nil
-			})
-		}
-	}
-
-	err = zipWriter.Close()
-	if err != nil {
-		fmt.Printf("Error closing tmp zipfile: %s\n", err)
-		os.Exit(1)
-	}
-
-	err = tmpZipfile.Sync()
-	if err != nil {
-		fmt.Printf("Error syncing tmp zipfile: %s\n", err)
-		os.Exit(1)
-	}
-	_, err = tmpZipfile.Seek(0, 0)
-	if err != nil {
-		fmt.Printf("Error seeking tmp zipfile: %s\n", err)
-		os.Exit(1)
-	}
-	_, err = binfile.Seek(0, 2)
-	if err != nil {
-		fmt.Printf("Error seeking bin file: %s\n", err)
-		os.Exit(1)
-	}
-
-	_, err = io.Copy(binfile, tmpZipfile)
-	if err != nil {
-		fmt.Printf("Error appending zipfile to executable: %s\n", err)
-		os.Exit(1)
-	}
-
-	zipA := exec.Command("zip", "-A", binfileName)
-	err = zipA.Run()
-	if err != nil {
-		fmt.Printf("Error setting zip offset: %s\n", err)
-		os.Exit(1)
-	}
-}

vendor/github.com/GeertJohan/go.rice/rice/clean.go

@@ -1,33 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"go/build"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func operationClean(pkg *build.Package) {
-	filepath.Walk(pkg.Dir, func(filename string, info os.FileInfo, err error) error {
-		if err != nil {
-			fmt.Printf("error walking pkg dir to clean files: %v\n", err)
-			os.Exit(1)
-		}
-		if info.IsDir() {
-			return nil
-		}
-		verbosef("checking file '%s'\n", filename)
-		if filepath.Base(filename) == "rice-box.go" ||
-			strings.HasSuffix(filename, ".rice-box.go") ||
-			strings.HasSuffix(filename, ".rice-box.syso") {
-			err := os.Remove(filename)
-			if err != nil {
-				fmt.Printf("error removing file (%s): %s\n", filename, err)
-				os.Exit(-1)
-			}
-			verbosef("removed file '%s'\n", filename)
-		}
-		return nil
-	})
-}

vendor/github.com/GeertJohan/go.rice/rice/embed-go.go

@@ -1,158 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/build"
-	"go/format"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-const boxFilename = "rice-box.go"
-
-func operationEmbedGo(pkg *build.Package) {
-
-	boxMap := findBoxes(pkg)
-
-	// notify user when no calls to rice.FindBox are made (is this an error and therefore os.Exit(1) ?
-	if len(boxMap) == 0 {
-		fmt.Println("no calls to rice.FindBox() found")
-		return
-	}
-
-	verbosef("\n")
-	var boxes []*boxDataType
-
-	for boxname := range boxMap {
-		// find path and filename for this box
-		boxPath := filepath.Join(pkg.Dir, boxname)
-
-		// Check to see if the path for the box is a symbolic link.  If so, simply
-		// box what the symbolic link points to.  Note: the filepath.Walk function
-		// will NOT follow any nested symbolic links.  This only handles the case
-		// where the root of the box is a symbolic link.
-		symPath, serr := os.Readlink(boxPath)
-		if serr == nil {
-			boxPath = symPath
-		}
-
-		// verbose info
-		verbosef("embedding box '%s' to '%s'\n", boxname, boxFilename)
-
-		// read box metadata
-		boxInfo, ierr := os.Stat(boxPath)
-		if ierr != nil {
-			fmt.Printf("Error: unable to access box at %s\n", boxPath)
-			os.Exit(1)
-		}
-
-		// create box datastructure (used by template)
-		box := &boxDataType{
-			BoxName: boxname,
-			UnixNow: boxInfo.ModTime().Unix(),
-			Files:   make([]*fileDataType, 0),
-			Dirs:    make(map[string]*dirDataType),
-		}
-
-		if !boxInfo.IsDir() {
-			fmt.Printf("Error: Box %s must point to a directory but points to %s instead\n",
-				boxname, boxPath)
-			os.Exit(1)
-		}
-
-		// fill box datastructure with file data
-		filepath.Walk(boxPath, func(path string, info os.FileInfo, err error) error {
-			if err != nil {
-				fmt.Printf("error walking box: %s\n", err)
-				os.Exit(1)
-			}
-
-			filename := strings.TrimPrefix(path, boxPath)
-			filename = strings.Replace(filename, "\\", "/", -1)
-			filename = strings.TrimPrefix(filename, "/")
-			if info.IsDir() {
-				dirData := &dirDataType{
-					Identifier: "dir" + nextIdentifier(),
-					FileName:   filename,
-					ModTime:    info.ModTime().Unix(),
-					ChildFiles: make([]*fileDataType, 0),
-					ChildDirs:  make([]*dirDataType, 0),
-				}
-				verbosef("\tincludes dir: '%s'\n", dirData.FileName)
-				box.Dirs[dirData.FileName] = dirData
-
-				// add tree entry (skip for root, it'll create a recursion)
-				if dirData.FileName != "" {
-					pathParts := strings.Split(dirData.FileName, "/")
-					parentDir := box.Dirs[strings.Join(pathParts[:len(pathParts)-1], "/")]
-					parentDir.ChildDirs = append(parentDir.ChildDirs, dirData)
-				}
-			} else {
-				fileData := &fileDataType{
-					Identifier: "file" + nextIdentifier(),
-					FileName:   filename,
-					ModTime:    info.ModTime().Unix(),
-				}
-				verbosef("\tincludes file: '%s'\n", fileData.FileName)
-				fileData.Content, err = ioutil.ReadFile(path)
-				if err != nil {
-					fmt.Printf("error reading file content while walking box: %s\n", err)
-					os.Exit(1)
-				}
-				box.Files = append(box.Files, fileData)
-
-				// add tree entry
-				pathParts := strings.Split(fileData.FileName, "/")
-				parentDir := box.Dirs[strings.Join(pathParts[:len(pathParts)-1], "/")]
-				if parentDir == nil {
-					fmt.Printf("Error: parent of %s is not within the box\n", path)
-					os.Exit(1)
-				}
-				parentDir.ChildFiles = append(parentDir.ChildFiles, fileData)
-			}
-			return nil
-		})
-		boxes = append(boxes, box)
-
-	}
-
-	embedSourceUnformated := bytes.NewBuffer(make([]byte, 0))
-
-	// execute template to buffer
-	err := tmplEmbeddedBox.Execute(
-		embedSourceUnformated,
-		embedFileDataType{pkg.Name, boxes},
-	)
-	if err != nil {
-		log.Printf("error writing embedded box to file (template execute): %s\n", err)
-		os.Exit(1)
-	}
-
-	// format the source code
-	embedSource, err := format.Source(embedSourceUnformated.Bytes())
-	if err != nil {
-		log.Printf("error formatting embedSource: %s\n", err)
-		os.Exit(1)
-	}
-
-	// create go file for box
-	boxFile, err := os.Create(filepath.Join(pkg.Dir, boxFilename))
-	if err != nil {
-		log.Printf("error creating embedded box file: %s\n", err)
-		os.Exit(1)
-	}
-	defer boxFile.Close()
-
-	// write source to file
-	_, err = io.Copy(boxFile, bytes.NewBuffer(embedSource))
-	if err != nil {
-		log.Printf("error writing embedSource to file: %s\n", err)
-		os.Exit(1)
-	}
-
-}

vendor/github.com/GeertJohan/go.rice/rice/embed-syso.go

@@ -1,204 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/gob"
-	"fmt"
-	"go/build"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"text/template"
-
-	"github.com/GeertJohan/go.rice/embedded"
-	"github.com/akavel/rsrc/coff"
-)
-
-type sizedReader struct {
-	*bytes.Reader
-}
-
-func (s sizedReader) Size() int64 {
-	return int64(s.Len())
-}
-
-var tmplEmbeddedSysoHelper *template.Template
-
-func init() {
-	var err error
-	tmplEmbeddedSysoHelper, err = template.New("embeddedSysoHelper").Parse(`package {{.Package}}
-// ############# GENERATED CODE #####################
-// ## This file was generated by the rice tool.
-// ## Do not edit unless you know what you're doing.
-// ##################################################
-
-// extern char _bricebox_{{.Symname}}[], _ericebox_{{.Symname}};
-// int get_{{.Symname}}_length() {
-// 	return &_ericebox_{{.Symname}} - _bricebox_{{.Symname}};
-// }
-import "C"
-import (
-	"bytes"
-	"encoding/gob"
-	"github.com/GeertJohan/go.rice/embedded"
-	"unsafe"
-)
-
-func init() {
-	ptr := unsafe.Pointer(&C._bricebox_{{.Symname}})
-	bts := C.GoBytes(ptr, C.get_{{.Symname}}_length())
-	embeddedBox := &embedded.EmbeddedBox{}
-	err := gob.NewDecoder(bytes.NewReader(bts)).Decode(embeddedBox)
-	if err != nil {
-		panic("error decoding embedded box: "+err.Error())
-	}
-	embeddedBox.Link()
-	embedded.RegisterEmbeddedBox(embeddedBox.Name, embeddedBox)
-}`)
-	if err != nil {
-		panic("could not parse template embeddedSysoHelper: " + err.Error())
-	}
-}
-
-type embeddedSysoHelperData struct {
-	Package string
-	Symname string
-}
-
-func operationEmbedSyso(pkg *build.Package) {
-
-	regexpSynameReplacer := regexp.MustCompile(`[^a-z0-9_]`)
-
-	boxMap := findBoxes(pkg)
-
-	// notify user when no calls to rice.FindBox are made (is this an error and therefore os.Exit(1) ?
-	if len(boxMap) == 0 {
-		fmt.Println("no calls to rice.FindBox() found")
-		return
-	}
-
-	verbosef("\n")
-
-	for boxname := range boxMap {
-		// find path and filename for this box
-		boxPath := filepath.Join(pkg.Dir, boxname)
-		boxFilename := strings.Replace(boxname, "/", "-", -1)
-		boxFilename = strings.Replace(boxFilename, "..", "back", -1)
-		boxFilename = strings.Replace(boxFilename, ".", "-", -1)
-
-		// verbose info
-		verbosef("embedding box '%s'\n", boxname)
-		verbosef("\tto file %s\n", boxFilename)
-
-		// read box metadata
-		boxInfo, ierr := os.Stat(boxPath)
-		if ierr != nil {
-			fmt.Printf("Error: unable to access box at %s\n", boxPath)
-			os.Exit(1)
-		}
-
-		// create box datastructure (used by template)
-		box := &embedded.EmbeddedBox{
-			Name:      boxname,
-			Time:      boxInfo.ModTime(),
-			EmbedType: embedded.EmbedTypeSyso,
-			Files:     make(map[string]*embedded.EmbeddedFile),
-			Dirs:      make(map[string]*embedded.EmbeddedDir),
-		}
-
-		// fill box datastructure with file data
-		filepath.Walk(boxPath, func(path string, info os.FileInfo, err error) error {
-			if err != nil {
-				fmt.Printf("error walking box: %s\n", err)
-				os.Exit(1)
-			}
-
-			filename := strings.TrimPrefix(path, boxPath)
-			filename = strings.Replace(filename, "\\", "/", -1)
-			filename = strings.TrimPrefix(filename, "/")
-			if info.IsDir() {
-				embeddedDir := &embedded.EmbeddedDir{
-					Filename:   filename,
-					DirModTime: info.ModTime(),
-				}
-				verbosef("\tincludes dir: '%s'\n", embeddedDir.Filename)
-				box.Dirs[embeddedDir.Filename] = embeddedDir
-
-				// add tree entry (skip for root, it'll create a recursion)
-				if embeddedDir.Filename != "" {
-					pathParts := strings.Split(embeddedDir.Filename, "/")
-					parentDir := box.Dirs[strings.Join(pathParts[:len(pathParts)-1], "/")]
-					parentDir.ChildDirs = append(parentDir.ChildDirs, embeddedDir)
-				}
-			} else {
-				embeddedFile := &embedded.EmbeddedFile{
-					Filename:    filename,
-					FileModTime: info.ModTime(),
-					Content:     "",
-				}
-				verbosef("\tincludes file: '%s'\n", embeddedFile.Filename)
-				contentBytes, err := ioutil.ReadFile(path)
-				if err != nil {
-					fmt.Printf("error reading file content while walking box: %s\n", err)
-					os.Exit(1)
-				}
-				embeddedFile.Content = string(contentBytes)
-				box.Files[embeddedFile.Filename] = embeddedFile
-			}
-			return nil
-		})
-
-		// encode embedded box to gob file
-		boxGobBuf := &bytes.Buffer{}
-		err := gob.NewEncoder(boxGobBuf).Encode(box)
-		if err != nil {
-			fmt.Printf("error encoding box to gob: %v\n", err)
-			os.Exit(1)
-		}
-
-		verbosef("gob-encoded embeddedBox is %d bytes large\n", boxGobBuf.Len())
-
-		// write coff
-		symname := regexpSynameReplacer.ReplaceAllString(boxname, "_")
-		createCoffSyso(boxname, symname, "386", boxGobBuf.Bytes())
-		createCoffSyso(boxname, symname, "amd64", boxGobBuf.Bytes())
-
-		// write go
-		sysoHelperData := embeddedSysoHelperData{
-			Package: pkg.Name,
-			Symname: symname,
-		}
-		fileSysoHelper, err := os.Create(boxFilename + ".rice-box.go")
-		if err != nil {
-			fmt.Printf("error creating syso helper: %v\n", err)
-			os.Exit(1)
-		}
-		err = tmplEmbeddedSysoHelper.Execute(fileSysoHelper, sysoHelperData)
-		if err != nil {
-			fmt.Printf("error executing tmplEmbeddedSysoHelper: %v\n", err)
-			os.Exit(1)
-		}
-	}
-}
-
-func createCoffSyso(boxFilename string, symname string, arch string, data []byte) {
-	boxCoff := coff.NewRDATA()
-	switch arch {
-	case "386":
-	case "amd64":
-		boxCoff.FileHeader.Machine = 0x8664
-	default:
-		panic("invalid arch")
-	}
-	boxCoff.AddData("_bricebox_"+symname, sizedReader{bytes.NewReader(data)})
-	boxCoff.AddData("_ericebox_"+symname, io.NewSectionReader(strings.NewReader("\000\000"), 0, 2)) // TODO: why? copied from rsrc, which copied it from as-generated
-	boxCoff.Freeze()
-	err := writeCoff(boxCoff, boxFilename+"_"+arch+".rice-box.syso")
-	if err != nil {
-		fmt.Printf("error writing %s coff/.syso: %v\n", arch, err)
-		os.Exit(1)
-	}
-}

vendor/github.com/GeertJohan/go.rice/rice/find.go

@@ -1,150 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/parser"
-	"go/token"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func badArgument(fileset *token.FileSet, p token.Pos) {
-	pos := fileset.Position(p)
-	filename := pos.Filename
-	base, err := os.Getwd()
-	if err == nil {
-		rpath, perr := filepath.Rel(base, pos.Filename)
-		if perr == nil {
-			filename = rpath
-		}
-	}
-	msg := fmt.Sprintf("%s:%d: Error: found call to rice.FindBox, "+
-		"but argument must be a string literal.\n", filename, pos.Line)
-	fmt.Println(msg)
-	os.Exit(1)
-}
-
-func findBoxes(pkg *build.Package) map[string]bool {
-	// create map of boxes to embed
-	var boxMap = make(map[string]bool)
-
-	// create one list of files for this package
-	filenames := make([]string, 0, len(pkg.GoFiles)+len(pkg.CgoFiles))
-	filenames = append(filenames, pkg.GoFiles...)
-	filenames = append(filenames, pkg.CgoFiles...)
-
-	// loop over files, search for rice.FindBox(..) calls
-	for _, filename := range filenames {
-		// find full filepath
-		fullpath := filepath.Join(pkg.Dir, filename)
-		if strings.HasSuffix(filename, "rice-box.go") {
-			// Ignore *.rice-box.go files
-			verbosef("skipping file %q\n", fullpath)
-			continue
-		}
-		verbosef("scanning file %q\n", fullpath)
-
-		fset := token.NewFileSet()
-		f, err := parser.ParseFile(fset, fullpath, nil, 0)
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-
-		var riceIsImported bool
-		ricePkgName := "rice"
-		for _, imp := range f.Imports {
-			if strings.HasSuffix(imp.Path.Value, "go.rice\"") {
-				if imp.Name != nil {
-					ricePkgName = imp.Name.Name
-				}
-				riceIsImported = true
-				break
-			}
-		}
-		if !riceIsImported {
-			// Rice wasn't imported, so we won't find a box.
-			continue
-		}
-		if ricePkgName == "_" {
-			// Rice pkg is unnamed, so we won't find a box.
-			continue
-		}
-
-		// Inspect AST, looking for calls to (Must)?FindBox.
-		// First parameter of the func must be a basic literal.
-		// Identifiers won't be resolved.
-		var nextIdentIsBoxFunc bool
-		var nextBasicLitParamIsBoxName bool
-		var boxCall token.Pos
-		var variableToRemember string
-		var validVariablesForBoxes map[string]bool = make(map[string]bool)
-
-		ast.Inspect(f, func(node ast.Node) bool {
-			if node == nil {
-				return false
-			}
-			switch x := node.(type) {
-			// this case fixes the var := func() style assignments, not assignments to vars declared separately from the assignment.
-			case *ast.AssignStmt:
-				var assign = node.(*ast.AssignStmt)
-				name, found := assign.Lhs[0].(*ast.Ident)
-				if found {
-					variableToRemember = name.Name
-					composite, first := assign.Rhs[0].(*ast.CompositeLit)
-					if first {
-						riceSelector, second := composite.Type.(*ast.SelectorExpr)
-
-						if second {
-							callCorrect := riceSelector.Sel.Name == "Config"
-							packageName, third := riceSelector.X.(*ast.Ident)
-
-							if third && callCorrect && packageName.Name == ricePkgName {
-								validVariablesForBoxes[name.Name] = true
-								verbosef("\tfound variable, saving to scan for boxes: %q\n", name.Name)
-							}
-						}
-					}
-				}
-			case *ast.Ident:
-				if nextIdentIsBoxFunc || ricePkgName == "." {
-					nextIdentIsBoxFunc = false
-					if x.Name == "FindBox" || x.Name == "MustFindBox" {
-						nextBasicLitParamIsBoxName = true
-						boxCall = x.Pos()
-					}
-				} else {
-					if x.Name == ricePkgName || validVariablesForBoxes[x.Name] {
-						nextIdentIsBoxFunc = true
-					}
-				}
-			case *ast.BasicLit:
-				if nextBasicLitParamIsBoxName {
-					if x.Kind == token.STRING {
-						nextBasicLitParamIsBoxName = false
-						// trim "" or ``
-						name := x.Value[1 : len(x.Value)-1]
-						boxMap[name] = true
-						verbosef("\tfound box %q\n", name)
-					} else {
-						badArgument(fset, boxCall)
-					}
-				}
-
-			default:
-				if nextIdentIsBoxFunc {
-					nextIdentIsBoxFunc = false
-				}
-				if nextBasicLitParamIsBoxName {
-					badArgument(fset, boxCall)
-				}
-			}
-			return true
-		})
-	}
-
-	return boxMap
-}

vendor/github.com/GeertJohan/go.rice/rice/flags.go

@@ -1,80 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"go/build"
-	"os"
-
-	goflags "github.com/jessevdk/go-flags" // rename import to `goflags` (file scope) so we can use `var flags` (package scope)
-)
-
-// flags
-var flags struct {
-	Verbose     bool     `long:"verbose" short:"v" description:"Show verbose debug information"`
-	ImportPaths []string `long:"import-path" short:"i" description:"Import path(s) to use. Using PWD when left empty. Specify multiple times for more import paths to append"`
-
-	Append struct {
-		Executable string `long:"exec" description:"Executable to append" required:"true"`
-	} `command:"append"`
-
-	EmbedGo   struct{} `command:"embed-go" alias:"embed"`
-	EmbedSyso struct{} `command:"embed-syso"`
-	Clean     struct{} `command:"clean"`
-}
-
-// flags parser
-var flagsParser *goflags.Parser
-
-// initFlags parses the given flags.
-// when the user asks for help (-h or --help): the application exists with status 0
-// when unexpected flags is given: the application exits with status 1
-func parseArguments() {
-	// create flags parser in global var, for flagsParser.Active.Name (operation)
-	flagsParser = goflags.NewParser(&flags, goflags.Default)
-
-	// parse flags
-	args, err := flagsParser.Parse()
-	if err != nil {
-		// assert the err to be a flags.Error
-		flagError := err.(*goflags.Error)
-		if flagError.Type == goflags.ErrHelp {
-			// user asked for help on flags.
-			// program can exit successfully
-			os.Exit(0)
-		}
-		if flagError.Type == goflags.ErrUnknownFlag {
-			fmt.Println("Use --help to view available options.")
-			os.Exit(1)
-		}
-		if flagError.Type == goflags.ErrRequired {
-			os.Exit(1)
-		}
-		fmt.Printf("Error parsing flags: %s\n", err)
-		os.Exit(1)
-	}
-
-	// error on left-over arguments
-	if len(args) > 0 {
-		fmt.Printf("Unexpected arguments: %s\nUse --help to view available options.", args)
-		os.Exit(1)
-	}
-
-	// default ImportPath to pwd when not set
-	if len(flags.ImportPaths) == 0 {
-		pwd, err := os.Getwd()
-		if err != nil {
-			fmt.Printf("error getting pwd: %s\n", err)
-			os.Exit(1)
-		}
-		verbosef("using pwd as import path\n")
-		// find non-absolute path for this pwd
-		pkg, err := build.ImportDir(pwd, build.FindOnly)
-		if err != nil {
-			fmt.Printf("error using current directory as import path: %s\n", err)
-			os.Exit(1)
-		}
-		flags.ImportPaths = append(flags.ImportPaths, pkg.ImportPath)
-		verbosef("using import paths: %s\n", flags.ImportPaths)
-		return
-	}
-}

vendor/github.com/GeertJohan/go.rice/rice/identifier.go

@@ -1,14 +0,0 @@
-package main
-
-import (
-	"strconv"
-
-	"github.com/GeertJohan/go.incremental"
-)
-
-var identifierCount incremental.Uint64
-
-func nextIdentifier() string {
-	num := identifierCount.Next()
-	return strconv.FormatUint(num, 36) // 0123456789abcdefghijklmnopqrstuvwxyz
-}

vendor/github.com/GeertJohan/go.rice/rice/main.go

@@ -1,68 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"go/build"
-	"log"
-	"os"
-)
-
-func main() {
-	// parser arguments
-	parseArguments()
-
-	// find package for path
-	var pkgs []*build.Package
-	for _, importPath := range flags.ImportPaths {
-		pkg := pkgForPath(importPath)
-		pkgs = append(pkgs, pkg)
-	}
-
-	// switch on the operation to perform
-	switch flagsParser.Active.Name {
-	case "embed", "embed-go":
-		for _, pkg := range pkgs {
-			operationEmbedGo(pkg)
-		}
-	case "embed-syso":
-		log.Println("WARNING: embedding .syso is experimental..")
-		for _, pkg := range pkgs {
-			operationEmbedSyso(pkg)
-		}
-	case "append":
-		operationAppend(pkgs)
-	case "clean":
-		for _, pkg := range pkgs {
-			operationClean(pkg)
-		}
-	}
-
-	// all done
-	verbosef("\n")
-	verbosef("rice finished successfully\n")
-}
-
-// helper function to get *build.Package for given path
-func pkgForPath(path string) *build.Package {
-	// get pwd for relative imports
-	pwd, err := os.Getwd()
-	if err != nil {
-		fmt.Printf("error getting pwd (required for relative imports): %s\n", err)
-		os.Exit(1)
-	}
-
-	// read full package information
-	pkg, err := build.Import(path, pwd, 0)
-	if err != nil {
-		fmt.Printf("error reading package: %s\n", err)
-		os.Exit(1)
-	}
-
-	return pkg
-}
-
-func verbosef(format string, stuff ...interface{}) {
-	if flags.Verbose {
-		log.Printf(format, stuff...)
-	}
-}

vendor/github.com/GeertJohan/go.rice/rice/templates.go

@@ -1,98 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"text/template"
-)
-
-var tmplEmbeddedBox *template.Template
-
-func init() {
-	var err error
-
-	// parse embedded box template
-	tmplEmbeddedBox, err = template.New("embeddedBox").Parse(`package {{.Package}}
-
-import (
-	"github.com/GeertJohan/go.rice/embedded"
-	"time"
-)
-
-{{range .Boxes}}
-func init() {
-
-	// define files
-	{{range .Files}}{{.Identifier}} := &embedded.EmbeddedFile{
-		Filename:    ` + "`" + `{{.FileName}}` + "`" + `,
-		FileModTime: time.Unix({{.ModTime}}, 0),
-		Content:     string({{.Content | printf "%q"}}), 
-	}
-	{{end}}
-
-	// define dirs
-	{{range .Dirs}}{{.Identifier}} := &embedded.EmbeddedDir{
-		Filename:    ` + "`" + `{{.FileName}}` + "`" + `,
-		DirModTime: time.Unix({{.ModTime}}, 0),
-		ChildFiles:  []*embedded.EmbeddedFile{
-			{{range .ChildFiles}}{{.Identifier}}, // {{.FileName}}
-			{{end}}
-		},
-	}
-	{{end}}
-
-	// link ChildDirs
-	{{range .Dirs}}{{.Identifier}}.ChildDirs = []*embedded.EmbeddedDir{
-		{{range .ChildDirs}}{{.Identifier}}, // {{.FileName}}
-		{{end}}
-	}
-	{{end}}
-
-	// register embeddedBox
-	embedded.RegisterEmbeddedBox(` + "`" + `{{.BoxName}}` + "`" + `, &embedded.EmbeddedBox{
-		Name: ` + "`" + `{{.BoxName}}` + "`" + `,
-		Time: time.Unix({{.UnixNow}}, 0),
-		Dirs: map[string]*embedded.EmbeddedDir{
-			{{range .Dirs}}"{{.FileName}}": {{.Identifier}},
-			{{end}}
-		},
-		Files: map[string]*embedded.EmbeddedFile{
-			{{range .Files}}"{{.FileName}}": {{.Identifier}},
-			{{end}}
-		},
-	})
-}
-{{end}}`)
-	if err != nil {
-		fmt.Printf("error parsing embedded box template: %s\n", err)
-		os.Exit(-1)
-	}
-}
-
-type embedFileDataType struct {
-	Package string
-	Boxes   []*boxDataType
-}
-
-type boxDataType struct {
-	BoxName string
-	UnixNow int64
-	Files   []*fileDataType
-	Dirs    map[string]*dirDataType
-}
-
-type fileDataType struct {
-	Identifier string
-	FileName   string
-	Content    []byte
-	ModTime    int64
-}
-
-type dirDataType struct {
-	Identifier string
-	FileName   string
-	Content    []byte
-	ModTime    int64
-	ChildDirs  []*dirDataType
-	ChildFiles []*fileDataType
-}

vendor/github.com/GeertJohan/go.rice/rice/util.go

@@ -1,22 +0,0 @@
-package main
-
-import (
-	"math/rand"
-	"time"
-)
-
-// randomString generates a pseudo-random alpha-numeric string with given length.
-func randomString(length int) string {
-	rand.Seed(time.Now().UnixNano())
-	k := make([]rune, length)
-	for i := 0; i < length; i++ {
-		c := rand.Intn(35)
-		if c < 10 {
-			c += 48 // numbers (0-9) (0+48 == 48 == '0', 9+48 == 57 == '9')
-		} else {
-			c += 87 // lower case alphabets (a-z) (10+87 == 97 == 'a', 35+87 == 122 = 'z')
-		}
-		k[i] = rune(c)
-	}
-	return string(k)
-}

vendor/github.com/GeertJohan/go.rice/rice/writecoff.go

@@ -1,42 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"reflect"
-
-	"github.com/akavel/rsrc/binutil"
-	"github.com/akavel/rsrc/coff"
-)
-
-// copied from github.com/akavel/rsrc
-// LICENSE: MIT
-// Copyright 2013-2014 The rsrc Authors. (https://github.com/akavel/rsrc/blob/master/AUTHORS)
-func writeCoff(coff *coff.Coff, fnameout string) error {
-	out, err := os.Create(fnameout)
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-	w := binutil.Writer{W: out}
-
-	// write the resulting file to disk
-	binutil.Walk(coff, func(v reflect.Value, path string) error {
-		if binutil.Plain(v.Kind()) {
-			w.WriteLE(v.Interface())
-			return nil
-		}
-		vv, ok := v.Interface().(binutil.SizedReader)
-		if ok {
-			w.WriteFromSized(vv)
-			return binutil.WALK_SKIP
-		}
-		return nil
-	})
-
-	if w.Err != nil {
-		return fmt.Errorf("Error writing output file: %s", w.Err)
-	}
-
-	return nil
-}

vendor/github.com/GeertJohan/go.rice/sort.go

@@ -1,19 +0,0 @@
-package rice
-
-import "os"
-
-// SortByName allows an array of os.FileInfo objects
-// to be easily sorted by filename using sort.Sort(SortByName(array))
-type SortByName []os.FileInfo
-
-func (f SortByName) Len() int           { return len(f) }
-func (f SortByName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
-func (f SortByName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
-
-// SortByModified allows an array of os.FileInfo objects
-// to be easily sorted by modified date using sort.Sort(SortByModified(array))
-type SortByModified []os.FileInfo
-
-func (f SortByModified) Len() int           { return len(f) }
-func (f SortByModified) Less(i, j int) bool { return f[i].ModTime().Unix() > f[j].ModTime().Unix() }
-func (f SortByModified) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }

vendor/github.com/GeertJohan/go.rice/virtual.go

@@ -1,252 +0,0 @@
-package rice
-
-import (
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-
-	"github.com/GeertJohan/go.rice/embedded"
-)
-
-//++ TODO: IDEA: merge virtualFile and virtualDir, this decreases work done by rice.File
-
-// Error indicating some function is not implemented yet (but available to satisfy an interface)
-var ErrNotImplemented = errors.New("not implemented yet")
-
-// virtualFile is a 'stateful' virtual file.
-// virtualFile wraps an *EmbeddedFile for a call to Box.Open() and virtualizes 'read cursor' (offset) and 'closing'.
-// virtualFile is only internally visible and should be exposed through rice.File
-type virtualFile struct {
-	*embedded.EmbeddedFile       // the actual embedded file, embedded to obtain methods
-	offset                 int64 // read position on the virtual file
-	closed                 bool  // closed when true
-}
-
-// create a new virtualFile for given EmbeddedFile
-func newVirtualFile(ef *embedded.EmbeddedFile) *virtualFile {
-	vf := &virtualFile{
-		EmbeddedFile: ef,
-		offset:       0,
-		closed:       false,
-	}
-	return vf
-}
-
-//++ TODO check for nil pointers in all these methods. When so: return os.PathError with Err: os.ErrInvalid
-
-func (vf *virtualFile) close() error {
-	if vf.closed {
-		return &os.PathError{
-			Op:   "close",
-			Path: vf.EmbeddedFile.Filename,
-			Err:  errors.New("already closed"),
-		}
-	}
-	vf.EmbeddedFile = nil
-	vf.closed = true
-	return nil
-}
-
-func (vf *virtualFile) stat() (os.FileInfo, error) {
-	if vf.closed {
-		return nil, &os.PathError{
-			Op:   "stat",
-			Path: vf.EmbeddedFile.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	return (*embeddedFileInfo)(vf.EmbeddedFile), nil
-}
-
-func (vf *virtualFile) readdir(count int) ([]os.FileInfo, error) {
-	if vf.closed {
-		return nil, &os.PathError{
-			Op:   "readdir",
-			Path: vf.EmbeddedFile.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	//TODO: return proper error for a readdir() call on a file
-	return nil, ErrNotImplemented
-}
-
-func (vf *virtualFile) read(bts []byte) (int, error) {
-	if vf.closed {
-		return 0, &os.PathError{
-			Op:   "read",
-			Path: vf.EmbeddedFile.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-
-	end := vf.offset + int64(len(bts))
-
-	if end >= int64(len(vf.Content)) {
-		// end of file, so return what we have + EOF
-		n := copy(bts, vf.Content[vf.offset:])
-		vf.offset = 0
-		return n, io.EOF
-	}
-
-	n := copy(bts, vf.Content[vf.offset:end])
-	vf.offset += int64(n)
-	return n, nil
-
-}
-
-func (vf *virtualFile) seek(offset int64, whence int) (int64, error) {
-	if vf.closed {
-		return 0, &os.PathError{
-			Op:   "seek",
-			Path: vf.EmbeddedFile.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	var e error
-
-	//++ TODO: check if this is correct implementation for seek
-	switch whence {
-	case os.SEEK_SET:
-		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
-		vf.offset = offset
-	case os.SEEK_CUR:
-		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
-		vf.offset += offset
-	case os.SEEK_END:
-		//++ check if new offset isn't out of bounds, set e when it is, then break out of switch
-		vf.offset = int64(len(vf.EmbeddedFile.Content)) - offset
-	}
-
-	if e != nil {
-		return 0, &os.PathError{
-			Op:   "seek",
-			Path: vf.Filename,
-			Err:  e,
-		}
-	}
-
-	return vf.offset, nil
-}
-
-// virtualDir is a 'stateful' virtual directory.
-// virtualDir wraps an *EmbeddedDir for a call to Box.Open() and virtualizes 'closing'.
-// virtualDir is only internally visible and should be exposed through rice.File
-type virtualDir struct {
-	*embedded.EmbeddedDir
-	offset int // readdir position on the directory
-	closed bool
-}
-
-// create a new virtualDir for given EmbeddedDir
-func newVirtualDir(ed *embedded.EmbeddedDir) *virtualDir {
-	vd := &virtualDir{
-		EmbeddedDir: ed,
-		offset:      0,
-		closed:      false,
-	}
-	return vd
-}
-
-func (vd *virtualDir) close() error {
-	//++ TODO: needs sync mutex?
-	if vd.closed {
-		return &os.PathError{
-			Op:   "close",
-			Path: vd.EmbeddedDir.Filename,
-			Err:  errors.New("already closed"),
-		}
-	}
-	vd.closed = true
-	return nil
-}
-
-func (vd *virtualDir) stat() (os.FileInfo, error) {
-	if vd.closed {
-		return nil, &os.PathError{
-			Op:   "stat",
-			Path: vd.EmbeddedDir.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	return (*embeddedDirInfo)(vd.EmbeddedDir), nil
-}
-
-func (vd *virtualDir) readdir(n int) (fi []os.FileInfo, err error) {
-
-	if vd.closed {
-		return nil, &os.PathError{
-			Op:   "readdir",
-			Path: vd.EmbeddedDir.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-
-	// Build up the array of our contents
-	var files []os.FileInfo
-
-	// Add the child directories
-	for _, child := range vd.ChildDirs {
-		child.Filename = filepath.Base(child.Filename)
-		files = append(files, (*embeddedDirInfo)(child))
-	}
-
-	// Add the child files
-	for _, child := range vd.ChildFiles {
-		child.Filename = filepath.Base(child.Filename)
-		files = append(files, (*embeddedFileInfo)(child))
-	}
-
-	// Sort it by filename (lexical order)
-	sort.Sort(SortByName(files))
-
-	// Return all contents if that's what is requested
-	if n <= 0 {
-		vd.offset = 0
-		return files, nil
-	}
-
-	// If user has requested past the end of our list
-	// return what we can and send an EOF
-	if vd.offset+n >= len(files) {
-		offset := vd.offset
-		vd.offset = 0
-		return files[offset:], io.EOF
-	}
-
-	offset := vd.offset
-	vd.offset += n
-	return files[offset : offset+n], nil
-
-}
-
-func (vd *virtualDir) read(bts []byte) (int, error) {
-	if vd.closed {
-		return 0, &os.PathError{
-			Op:   "read",
-			Path: vd.EmbeddedDir.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	return 0, &os.PathError{
-		Op:   "read",
-		Path: vd.EmbeddedDir.Filename,
-		Err:  errors.New("is a directory"),
-	}
-}
-
-func (vd *virtualDir) seek(offset int64, whence int) (int64, error) {
-	if vd.closed {
-		return 0, &os.PathError{
-			Op:   "seek",
-			Path: vd.EmbeddedDir.Filename,
-			Err:  errors.New("bad file descriptor"),
-		}
-	}
-	return 0, &os.PathError{
-		Op:   "seek",
-		Path: vd.Filename,
-		Err:  errors.New("is a directory"),
-	}
-}

vendor/github.com/GeertJohan/go.rice/walk.go

@@ -1,122 +0,0 @@
-package rice
-
-import (
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-// Walk is like filepath.Walk()
-// Visit http://golang.org/pkg/path/filepath/#Walk for more information
-func (b *Box) Walk(path string, walkFn filepath.WalkFunc) error {
-
-	pathFile, err := b.Open(path)
-	if err != nil {
-		return err
-	}
-	defer pathFile.Close()
-
-	pathInfo, err := pathFile.Stat()
-	if err != nil {
-		return err
-	}
-
-	if b.IsAppended() || b.IsEmbedded() {
-		return b.walk(path, pathInfo, walkFn)
-	}
-
-	// We don't have any embedded or appended box so use live filesystem mode
-	return filepath.Walk(b.absolutePath+string(os.PathSeparator)+path, func(path string, info os.FileInfo, err error) error {
-
-		// Strip out the box name from the returned paths
-		path = strings.TrimPrefix(path, b.absolutePath+string(os.PathSeparator))
-		return walkFn(path, info, err)
-
-	})
-
-}
-
-// walk recursively descends path.
-// See walk() in $GOROOT/src/pkg/path/filepath/path.go
-func (b *Box) walk(path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
-
-	err := walkFn(path, info, nil)
-	if err != nil {
-		if info.IsDir() && err == filepath.SkipDir {
-			return nil
-		}
-		return err
-	}
-
-	if !info.IsDir() {
-		return nil
-	}
-
-	names, err := b.readDirNames(path)
-	if err != nil {
-		return walkFn(path, info, err)
-	}
-
-	for _, name := range names {
-
-		filename := filepath.Join(path, name)
-		fileObject, err := b.Open(filename)
-		if err != nil {
-			return err
-		}
-		defer fileObject.Close()
-
-		fileInfo, err := fileObject.Stat()
-		if err != nil {
-			if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
-				return err
-			}
-		} else {
-			err = b.walk(filename, fileInfo, walkFn)
-			if err != nil {
-				if !fileInfo.IsDir() || err != filepath.SkipDir {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-
-}
-
-// readDirNames reads the directory named by path and returns a sorted list of directory entries.
-// See readDirNames() in $GOROOT/pkg/path/filepath/path.go
-func (b *Box) readDirNames(path string) ([]string, error) {
-
-	f, err := b.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	stat, err := f.Stat()
-	if err != nil {
-		return nil, err
-	}
-
-	if !stat.IsDir() {
-		return nil, nil
-	}
-
-	infos, err := f.Readdir(0)
-	if err != nil {
-		return nil, err
-	}
-
-	var names []string
-
-	for _, info := range infos {
-		names = append(names, info.Name())
-	}
-
-	sort.Strings(names)
-	return names, nil
-
-}

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

@@ -1,4 +1,4 @@
-Copyright (c) 2016 The Go Authors. All rights reserved.
+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
@@ -10,9 +10,8 @@ notice, this list of conditions and the following disclaimer.
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
+   * 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

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