Update documentation

.github/ISSUE_TEMPLATE.md

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

.github/ISSUE_TEMPLATE/Bug_report.md

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

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

@@ -1,55 +0,0 @@
-language: go
-go:
-    - 1.11.x
-
-# we have everything vendored
-install: true
-
-git:
-  depth: 200
-
-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
-  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s -- -b $GOPATH/bin v1.12.2
-
-
-# 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 "$(go fmt ./...)"         # 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
-  - golangci-lint run --enable-all -D lll -D errcheck -D gosec -D maligned -D prealloc -D gocyclo -D gochecknoglobals
-  #- megacheck $PKGS                   # "go vet on steroids" + linter
-  - /bin/bash ci/bintray.sh
-  #- golint -set_exit_status $PKGS     # one last linter
-
-deploy:
-  provider: bintray
-  edge:
-    branch: v1.8.47
-  file: ci/deploy.json
-  user: 42wim
-  key:
-     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="

Dockerfile

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

README-0.6.md

@@ -0,0 +1,115 @@
+# 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,104 +1,52 @@
-<div align="center">
-
 # matterbridge
+Simple bridge between mattermost, IRC, XMPP, Gitter, Slack and Discord
 
-![Matterbridge Logo](img/matterbridge-notext.gif)<br />
+* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack and Discord. Pick and mix.
-   **A simple chat bridge**<br />
+* Supports multiple channels.
-   Letting people be where they want to be.<br />
+* Matterbridge can also work with private groups on your mattermost.
-   <sub>Bridges between a growing number of protocols. Click below to demo.</sub>
+* 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).
 
-   <sup>
+Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
+Look at [matterbridge.toml.simple] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.simple) for a simple example.
 
-   [Gitter][mb-gitter] |
+## Changelog
-   [IRC][mb-irc] |
+Since v0.7.0 the configuration has changed. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
-      [Discord][mb-discord] |
-      [Matrix][mb-matrix] |
-      [Slack][mb-slack] |
-      [Mattermost][mb-mattermost] |
-      [XMPP][mb-xmpp] |
-      [Twitch][mb-twitch] |
-      [Zulip][mb-zulip] |
-      And more...
-   </sup>
-
-----
-[![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)
-   [![Maintainability](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/maintainability)](https://codeclimate.com/github/42wim/matterbridge/maintainability)
-   [![Test Coverage](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/test_coverage)](https://codeclimate.com/github/42wim/matterbridge/test_coverage)<br />
-  <hr />
-</div>
-<div align="right"><sup>
-
-**Note:** Matter<em>most</em> isn't required to run matter<em>bridge</em>.</sup></div>
-
-### Table of Contents
- * [Features](https://github.com/42wim/matterbridge/wiki/Features)
-   * [API](#API)
- * [Requirements](#requirements)
- * [Screenshots](https://github.com/42wim/matterbridge/wiki/)
- * [Installing](#installing)
-   * [Binaries](#binaries)
-   * [Building](#building)
- * [Configuration](#configuration)
-   * [Howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config)
-   * [Examples](#examples)
- * [Running](#running)
-   * [Docker](#docker)
- * [Changelog](#changelog)
- * [FAQ](#faq)
- * [Related projects](#related-projects)
- * [Articles](#articles)
- * [Thanks](#thanks)
-
-## Features
-* [Support bridging between any protocols](https://github.com/42wim/matterbridge/wiki/Features#support-bridging-between-any-protocols)
-* [Support multiple gateways(bridges) for your protocols](https://github.com/42wim/matterbridge/wiki/Features#support-multiple-gatewaysbridges-for-your-protocols)
-* [Message edits and deletes](https://github.com/42wim/matterbridge/wiki/Features#message-edits-and-deletes)
-* Preserves threading when possible
-* [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 3 projects. Feel free to make a PR to add your project to this list.
-
-* [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
-* [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
-* [Mattereddit](https://github.com/bonehurtingjuice/mattereddit) (Reddit chat support)
 
 ## Requirements
 Accounts to one of the supported bridges
-* [Mattermost](https://github.com/mattermost/platform/) 3.8.x - 3.10.x, 4.x, 5.x
+* [Mattermost] (https://github.com/mattermost/platform/)
-* [IRC](http://www.mirc.com/servers.html)
+* [IRC] (http://www.mirc.com/servers.html)
-* [XMPP](https://jabber.org)
+* [XMPP] (https://jabber.org)
-* [Gitter](https://gitter.im)
+* [Gitter] (https://gitter.im)
-* [Slack](https://slack.com)
+* [Slack] (https://slack.com)
-* [Discord](https://discordapp.com)
+* [Discord] (https://discordapp.com)
-* [Telegram](https://telegram.org)
-* [Hipchat](https://www.hipchat.com)
-* [Rocket.chat](https://rocket.chat)
-* [Matrix](https://matrix.org)
-* [Steam](https://store.steampowered.com/)
-* [Twitch](https://twitch.tv)
-* [Ssh-chat](https://github.com/shazow/ssh-chat)
-* [Zulip](https://zulipchat.com)
 
-## Screenshots
+## Docker
-See https://github.com/42wim/matterbridge/wiki
+Create your matterbridge.toml file locally eg in ```/tmp/matterbridge.toml```
+```
+docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
+```
 
-## Installing
+## binaries
-### Binaries
+Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* Latest stable release [v1.12.0](https://github.com/42wim/matterbridge/releases/latest)
+* For use with mattermost 3.5.0+ [v0.8.0](https://github.com/42wim/matterircd/releases/tag/v0.8.0)
-* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)
+* For use with mattermost 3.3.0 - 3.4.0 [v0.7.0](https://github.com/42wim/matterircd/releases/tag/v0.7.0)
 
-### Building
+## Compatibility
-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).
+### Mattermost 
+* Matterbridge v0.8.0 works with mattermost 3.5.0+ [3.5.0 release](https://github.com/mattermost/platform/releases/tag/v3.5.0)
+* Matterbridge v0.7.0 works with mattermost 3.3.0 - 3.4.0 [3.4.0 release](https://github.com/mattermost/platform/releases/tag/v3.4.0)
 
-After Go is setup, download matterbridge to your $GOPATH directory.
+#### Webhooks version
+* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
+
+#### API version
+* A dedicated user(bot) on your mattermost instance.
+
+
+## building
+Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
 
 ```
 cd $GOPATH
@@ -112,73 +60,10 @@ $ ls bin/
 matterbridge
 ```
 
-## Configuration
+## running
-### Basic configuration
+1) Copy the matterbridge.conf.sample to matterbridge.conf in the same directory as the matterbridge binary.  
-See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
+2) Edit matterbridge.conf with the settings for your environment. See below for more config information.  
-
+3) Now you can run matterbridge. 
-### Advanced configuration
-* [matterbridge.toml.sample](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
-
-### Examples
-#### Bridge mattermost (off-topic) - irc (#testing)
-```toml
-[irc]
-    [irc.freenode]
-    Server="irc.freenode.net:6667"
-    Nick="yourbotname"
-
-[mattermost]
-    [mattermost.work]
-    Server="yourmattermostserver.tld"
-    Team="yourteam"
-    Login="yourlogin"
-    Password="yourpass"
-    PrefixMessagesWithNick=true
-    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
-
-[[gateway]]
-name="mygateway"
-enable=true
-    [[gateway.inout]]
-    account="irc.freenode"
-    channel="#testing"
-
-    [[gateway.inout]]
-    account="mattermost.work"
-    channel="off-topic"
-```
-
-#### Bridge slack (#general) - discord (general)
-```toml
-[slack]
-[slack.test]
-Token="yourslacktoken"
-PrefixMessagesWithNick=true
-
-[discord]
-[discord.test]
-Token="yourdiscordtoken"
-Server="yourdiscordservername"
-
-[general]
-RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
-
-[[gateway]]
-    name = "mygateway"
-    enable=true
-
-    [[gateway.inout]]
-    account = "discord.test"
-    channel="general"
-
-    [[gateway.inout]]
-    account ="slack.test"
-    channel = "general"
-```
-
-## Running
-
-See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
 
 ```
 Usage of ./matterbridge:
@@ -186,73 +71,39 @@ Usage of ./matterbridge:
         config file (default "matterbridge.toml")
   -debug
         enable debug
-  -gops
-        enable gops agent
   -version
         show version
 ```
 
-### Docker
+## config
-Create your matterbridge.toml file locally eg in `/tmp/matterbridge.toml`
+### matterbridge
-```
+matterbridge looks for matterbridge.toml in current directory. (use -conf to specify another file)
-docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
-```
 
-## Changelog
+Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for an example.
-See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.md)
+
+### mattermost
+#### webhooks version
+You'll have to configure the incoming and outgoing webhooks. 
+
+* 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)
 
 ## 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.
 
-See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
+If you're running the plus version you'll need to:
+* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
 
-Want to tip ?
+Also look at the ```RemoteNickFormat``` setting.
-* eth: 0xb3f9b5387c66ad6be892bcb7bbc67862f3abc16f
-* btc: 1N7cKHj5SfqBHBzDJ6kad4BzeqUBBS2zhs
-
-## Related projects
-* [matterbridge-heroku](https://github.com/cadecairos/matterbridge-heroku)
-* [matterbridge config viewer](https://github.com/patcon/matterbridge-heroku-viewer)
-* [matterbridge autoconfig](https://github.com/patcon/matterbridge-autoconfig)
-* [matterlink](https://github.com/elytra/MatterLink)
-* [mattereddit](https://github.com/bonehurtingjuice/mattereddit)
-* [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
-* [mattermost-plugin](https://github.com/matterbridge/mattermost-plugin) - Run matterbridge as a plugin in mattermost
-
-## Articles
-* https://mattermost.com/blog/connect-irc-to-mattermost/
-* https://blog.valvin.fr/2016/09/17/mattermost-et-un-channel-irc-cest-possible/
-* https://blog.brightscout.com/top-10-mattermost-integrations/
-* http://bencey.co.nz/2018/09/17/bridge/
-* https://www.algoo.fr/blog/2018/01/19/recouvrez-votre-liberte-en-quittant-slack-pour-un-mattermost-auto-heberge/
-* https://kopano.com/blog/matterbridge-bridging-mattermost-chat/
-* https://www.stitcher.com/s/?eid=52382713
-
-## Thanks
-[![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
-
-Matterbridge wouldn't exist without these libraries:
-* discord - https://github.com/bwmarrin/discordgo
-* echo - https://github.com/labstack/echo
-* gitter - https://github.com/sromku/go-gitter
-* gops - https://github.com/google/gops
-* gozulipbot - https://github.com/ifo/gozulipbot
-* irc - https://github.com/lrstanley/girc
-* mattermost - https://github.com/mattermost/platform
-* matrix - https://github.com/matrix-org/gomatrix
-* slack - https://github.com/nlopes/slack
-* steam - https://github.com/Philipp15b/go-steam
-* telegram - https://github.com/go-telegram-bot-api/telegram-bot-api
-* xmpp - https://github.com/mattn/go-xmpp
-* zulip - https://github.com/ifo/gozulipbot
-
-<!-- Links -->
-
-   [mb-gitter]: https://gitter.im/42wim/matterbridge
-   [mb-irc]: https://webchat.freenode.net/?channels=matterbridgechat
-   [mb-discord]: https://discord.gg/AkKPtrQ
-   [mb-matrix]: https://riot.im/app/#/room/#matterbridge:matrix.org
-   [mb-slack]: https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA
-   [mb-mattermost]: https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e
-   [mb-xmpp]: https://inverse.chat/
-   [mb-twitch]: https://www.twitch.tv/matterbridge
-   [mb-zulip]: https://matterbridge.zulipchat.com/register/

bridge/api/api.go

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

bridge/bridge.go

@@ -2,108 +2,44 @@ package bridge
 
 import (
 	"github.com/42wim/matterbridge/bridge/config"
-	log "github.com/sirupsen/logrus"
+	"github.com/42wim/matterbridge/bridge/discord"
-
+	"github.com/42wim/matterbridge/bridge/gitter"
+	"github.com/42wim/matterbridge/bridge/irc"
+	"github.com/42wim/matterbridge/bridge/mattermost"
+	"github.com/42wim/matterbridge/bridge/slack"
+	"github.com/42wim/matterbridge/bridge/xmpp"
 	"strings"
 )
 
-type Bridger interface {
+type Bridge interface {
-	Send(msg config.Message) (string, error)
+	Send(msg config.Message) error
+	Name() string
 	Connect() error
-	JoinChannel(channel config.ChannelInfo) error
+	FullOrigin() string
-	Disconnect() error
+	Origin() string
+	Protocol() string
+	JoinChannel(channel string) error
 }
 
-type Bridge struct {
+func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) Bridge {
-	Bridger
-	Name     string
-	Account  string
-	Protocol string
-	Channels map[string]config.ChannelInfo
-	Joined   map[string]bool
-	Log      *log.Entry
-	Config   config.Config
-	General  *config.Protocol
-}
-
-type Config struct {
-	//	General *config.Protocol
-	Remote chan config.Message
-	Log    *log.Entry
-	*Bridge
-}
-
-// Factory is the factory function to create a bridge
-type Factory func(*Config) Bridger
-
-func New(bridge *config.Bridge) *Bridge {
-	b := new(Bridge)
-	b.Channels = make(map[string]config.ChannelInfo)
 	accInfo := strings.Split(bridge.Account, ".")
 	protocol := accInfo[0]
 	name := accInfo[1]
-	b.Name = name
+	// override config from environment
-	b.Protocol = protocol
+	config.OverrideCfgFromEnv(cfg, protocol, name)
-	b.Account = bridge.Account
+	switch protocol {
-	b.Joined = make(map[string]bool)
+	case "mattermost":
-	return b
+		return bmattermost.New(cfg.Mattermost[name], name, c)
-}
+	case "irc":
-
+		return birc.New(cfg.IRC[name], name, c)
-func (b *Bridge) JoinChannels() error {
+	case "gitter":
-	err := b.joinChannels(b.Channels, b.Joined)
+		return bgitter.New(cfg.Gitter[name], name, c)
-	return err
+	case "slack":
-}
+		return bslack.New(cfg.Slack[name], name, c)
-
+	case "xmpp":
-func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map[string]bool) error {
+		return bxmpp.New(cfg.Xmpp[name], name, c)
-	for ID, channel := range channels {
+	case "discord":
-		if !exists[ID] {
+		return bdiscord.New(cfg.Discord[name], name, c)
-			b.Log.Infof("%s: joining %s (ID: %s)", b.Account, channel.Name, ID)
-			err := b.JoinChannel(channel)
-			if err != nil {
-				return err
-			}
-			exists[ID] = true
-		}
 	}
 	return nil
 }
-
-func (b *Bridge) GetBool(key string) bool {
-	val, ok := b.Config.GetBool(b.Account + "." + key)
-	if !ok {
-		val, _ = b.Config.GetBool("general." + key)
-	}
-	return val
-}
-
-func (b *Bridge) GetInt(key string) int {
-	val, ok := b.Config.GetInt(b.Account + "." + key)
-	if !ok {
-		val, _ = b.Config.GetInt("general." + key)
-	}
-	return val
-}
-
-func (b *Bridge) GetString(key string) string {
-	val, ok := b.Config.GetString(b.Account + "." + key)
-	if !ok {
-		val, _ = b.Config.GetString("general." + key)
-	}
-	return val
-}
-
-func (b *Bridge) GetStringSlice(key string) []string {
-	val, ok := b.Config.GetStringSlice(b.Account + "." + key)
-	if !ok {
-		val, _ = b.Config.GetStringSlice("general." + key)
-	}
-	return val
-}
-
-func (b *Bridge) GetStringSlice2D(key string) [][]string {
-	val, ok := b.Config.GetStringSlice2D(b.Account + "." + key)
-	if !ok {
-		val, _ = b.Config.GetStringSlice2D("general." + key)
-	}
-	return val
-}

bridge/config/config.go

@@ -1,145 +1,57 @@
 package config
 
 import (
-	"bytes"
+	"github.com/BurntSushi/toml"
-	"io/ioutil"
+	"log"
+	"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 (
-	EventJoinLeave       = "join_leave"
-	EventTopicChange     = "topic_change"
-	EventFailure         = "failure"
-	EventFileFailureSize = "file_failure_size"
-	EventAvatarDownload  = "avatar_download"
-	EventRejoinChannels  = "rejoin_channels"
-	EventUserAction      = "user_action"
-	EventMsgDelete       = "msg_delete"
-	EventAPIConnected    = "api_connected"
-	EventUserTyping      = "user_typing"
 )
 
 type Message struct {
-	Text      string    `json:"text"`
+	Text       string
-	Channel   string    `json:"channel"`
+	Channel    string
-	Username  string    `json:"username"`
+	Username   string
-	UserID    string    `json:"userid"` // userid on the bridge
+	Origin     string
-	Avatar    string    `json:"avatar"`
+	FullOrigin string
-	Account   string    `json:"account"`
+	Protocol   string
-	Event     string    `json:"event"`
+	Avatar     string
-	Protocol  string    `json:"protocol"`
-	Gateway   string    `json:"gateway"`
-	ParentID  string    `json:"parent_id"`
-	Timestamp time.Time `json:"timestamp"`
-	ID        string    `json:"id"`
-	Extra     map[string][]interface{}
-}
-
-type FileInfo struct {
-	Name    string
-	Data    *[]byte
-	Comment string
-	URL     string
-	Size    int64
-	Avatar  bool
-	SHA     string
-}
-
-type ChannelInfo struct {
-	Name        string
-	Account     string
-	Direction   string
-	ID          string
-	SameChannel map[string]bool
-	Options     ChannelOptions
 }
 
 type Protocol struct {
-	AuthCode               string // steam
+	BindAddress            string // mattermost, slack
-	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
-	Login                  string // mattermost, matrix
+	Muc                    string // xmpp
-	MediaDownloadBlackList []string
+	Name                   string // all protocols
-	MediaDownloadPath      string // Basically MediaServerUpload, but instead of uploading it, just write it to a file on the same server.
+	Nick                   string // all protocols
-	MediaDownloadSize      int    // all protocols
+	NickFormatter          string // mattermost, slack
-	MediaServerDownload    string
+	NickServNick           string // IRC
-	MediaServerUpload      string
+	NickServPassword       string // IRC
-	MessageDelay           int        // IRC, time in millisecond to wait between messages
+	NicksPerRow            int    // mattermost, slack
-	MessageFormat          string     // telegram
+	NoTLS                  bool   // mattermost
-	MessageLength          int        // IRC, max length of a message allowed
+	Password               string // IRC,mattermost,XMPP
-	MessageQueue           int        // IRC, size of message queue for flood control
+	PrefixMessagesWithNick bool   // mattemost, slack
-	MessageSplit           bool       // IRC, split long messages with newlines on MessageLength instead of clipping
+	Protocol               string //all protocols
-	Muc                    string     // xmpp
+	MessageQueue           int    // IRC, size of message queue for flood control
-	Name                   string     // all protocols
+	MessageDelay           int    // IRC, time in millisecond to wait between messages
-	Nick                   string     // all protocols
+	RemoteNickFormat       string // all protocols
-	NickFormatter          string     // mattermost, slack
+	Server                 string // IRC,mattermost,XMPP,discord
-	NickServNick           string     // IRC
+	ShowJoinPart           bool   // all protocols
-	NickServUsername       string     // IRC
+	SkipTLSVerify          bool   // IRC, mattermost
-	NickServPassword       string     // IRC
+	Team                   string // mattermost
-	NicksPerRow            int        // mattermost, slack
+	Token                  string // gitter, slack, discord
-	NoHomeServerSuffix     bool       // matrix
+	URL                    string // mattermost, slack
-	NoSendJoinPart         bool       // all protocols
+	UseAPI                 bool   // mattermost, slack
-	NoTLS                  bool       // mattermost
+	UseSASL                bool   // IRC
-	Password               string     // IRC,mattermost,XMPP,matrix
+	UseTLS                 bool   // IRC
-	PrefixMessagesWithNick bool       // mattemost, slack
-	PreserveThreading      bool       // 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
-	ShowUserTyping         bool       // slack
-	ShowEmbeds             bool       // discord
-	SkipTLSVerify          bool       // IRC, mattermost
-	StripNick              bool       // all protocols
-	Team                   string     // mattermost
-	Token                  string     // gitter, slack, discord, api
-	Topic                  string     // zulip
-	URL                    string     // mattermost, slack // DEPRECATED
-	UseAPI                 bool       // mattermost, slack
-	UseSASL                bool       // IRC
-	UseTLS                 bool       // IRC
-	UseFirstName           bool       // telegram
-	UseUserName            bool       // discord
-	UseInsecureURL         bool       // telegram
-	WebhookBindAddress     string     // mattermost, slack
-	WebhookURL             string     // mattermost, slack
-	WebhookUse             string     // mattermost, slack, discord
-}
-
-type ChannelOptions struct {
-	Key        string // irc, xmpp
-	WebhookURL string // discord
 }
 
 type Bridge struct {
-	Account     string
+	Account string
-	Channel     string
+	Channel string
-	Options     ChannelOptions
-	SameChannel bool
 }
 
 type Gateway struct {
@@ -147,7 +59,6 @@ type Gateway struct {
 	Enable bool
 	In     []Bridge
 	Out    []Bridge
-	InOut  []Bridge
 }
 
 type SameChannelGateway struct {
@@ -157,193 +68,74 @@ type SameChannelGateway struct {
 	Accounts []string
 }
 
-type BridgeValues struct {
+type Config struct {
-	API                map[string]Protocol
 	IRC                map[string]Protocol
 	Mattermost         map[string]Protocol
-	Matrix             map[string]Protocol
 	Slack              map[string]Protocol
-	SlackLegacy        map[string]Protocol
-	Steam              map[string]Protocol
 	Gitter             map[string]Protocol
-	XMPP               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 interface {
+func NewConfig(cfgfile string) *Config {
-	BridgeValues() *BridgeValues
+	var cfg Config
-	GetBool(key string) (bool, bool)
+	if _, err := toml.DecodeFile(cfgfile, &cfg); err != nil {
-	GetInt(key string) (int, bool)
-	GetString(key string) (string, bool)
-	GetStringSlice(key string) ([]string, bool)
-	GetStringSlice2D(key string) ([][]string, bool)
-}
-
-type config struct {
-	v *viper.Viper
-	sync.RWMutex
-
-	cv *BridgeValues
-}
-
-func NewConfig(cfgfile string) Config {
-	log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false})
-	flog := log.WithFields(log.Fields{"prefix": "config"})
-	viper.SetConfigFile(cfgfile)
-	input, err := getFileContents(cfgfile)
-	if err != nil {
 		log.Fatal(err)
 	}
-	mycfg := newConfigFromString(input)
+	return &cfg
-	if mycfg.cv.General.MediaDownloadSize == 0 {
-		mycfg.cv.General.MediaDownloadSize = 1000000
-	}
-	viper.WatchConfig()
-	viper.OnConfigChange(func(e fsnotify.Event) {
-		flog.Println("Config file changed:", e.Name)
-	})
-	return mycfg
 }
 
-func getFileContents(filename string) ([]byte, error) {
+func OverrideCfgFromEnv(cfg *Config, protocol string, account string) {
-	input, err := ioutil.ReadFile(filename)
+	var protoCfg Protocol
-	if err != nil {
+	val := reflect.ValueOf(cfg).Elem()
-		log.Fatal(err)
+	// loop over the Config struct
-		return []byte(nil), err
+	for i := 0; i < val.NumField(); i++ {
-	}
+		typeField := val.Type().Field(i)
-	return input, nil
+		// look for the protocol map (both lowercase)
-}
+		if strings.ToLower(typeField.Name) == protocol {
-
+			// get the Protocol struct from the map
-func NewConfigFromString(input []byte) Config {
+			data := val.Field(i).MapIndex(reflect.ValueOf(account))
-	return newConfigFromString(input)
+			protoCfg = data.Interface().(Protocol)
-}
+			protoStruct := reflect.ValueOf(&protoCfg).Elem()
-
+			// loop over the found protocol struct
-func newConfigFromString(input []byte) *config {
+			for i := 0; i < protoStruct.NumField(); i++ {
-	viper.SetConfigType("toml")
+				typeField := protoStruct.Type().Field(i)
-	viper.SetEnvPrefix("matterbridge")
+				// build our environment key (eg MATTERBRIDGE_MATTERMOST_WORK_LOGIN)
-	viper.AddConfigPath(".")
+				key := "matterbridge_" + protocol + "_" + account + "_" + typeField.Name
-	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
+				key = strings.ToUpper(key)
-	viper.AutomaticEnv()
+				// search the environment
-	err := viper.ReadConfig(bytes.NewBuffer(input))
+				res := os.Getenv(key)
-	if err != nil {
+				// if it exists and the current field is a string
-		log.Fatal(err)
+				// then update the current field
-	}
+				if res != "" {
-
+					fieldVal := protoStruct.Field(i)
-	cfg := &BridgeValues{}
+					if fieldVal.Kind() == reflect.String {
-	err = viper.Unmarshal(cfg)
+						log.Printf("config: overriding %s from env with %s\n", key, res)
-	if err != nil {
+						fieldVal.Set(reflect.ValueOf(res))
-		log.Fatal(err)
+					}
-	}
+				}
-	return &config{
-		v:  viper.GetViper(),
-		cv: cfg,
-	}
-}
-
-func (c *config) BridgeValues() *BridgeValues {
-	return c.cv
-}
-
-func (c *config) GetBool(key string) (bool, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	//	log.Debugf("getting bool %s = %#v", key, c.v.GetBool(key))
-	return c.v.GetBool(key), c.v.IsSet(key)
-}
-
-func (c *config) GetInt(key string) (int, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	//	log.Debugf("getting int %s = %d", key, c.v.GetInt(key))
-	return c.v.GetInt(key), c.v.IsSet(key)
-}
-
-func (c *config) GetString(key string) (string, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	//	log.Debugf("getting String %s = %s", key, c.v.GetString(key))
-	return c.v.GetString(key), c.v.IsSet(key)
-}
-
-func (c *config) GetStringSlice(key string) ([]string, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	// log.Debugf("getting StringSlice %s = %#v", key, c.v.GetStringSlice(key))
-	return c.v.GetStringSlice(key), c.v.IsSet(key)
-}
-
-func (c *config) GetStringSlice2D(key string) ([][]string, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	result := [][]string{}
-	if res, ok := c.v.Get(key).([]interface{}); ok {
-		for _, entry := range res {
-			result2 := []string{}
-			for _, entry2 := range entry.([]interface{}) {
-				result2 = append(result2, entry2.(string))
 			}
-			result = append(result, result2)
+			// update the map with the modified Protocol (cfg.Protocol[account] = Protocol)
+			val.Field(i).SetMapIndex(reflect.ValueOf(account), reflect.ValueOf(protoCfg))
+			break
 		}
-		return result, true
 	}
-	return result, false
 }
 
-func GetIconURL(msg *Message, iconURL string) string {
+func GetIconURL(msg *Message, cfg *Protocol) string {
-	info := strings.Split(msg.Account, ".")
+	iconURL := cfg.IconURL
-	protocol := info[0]
-	name := info[1]
 	iconURL = strings.Replace(iconURL, "{NICK}", msg.Username, -1)
-	iconURL = strings.Replace(iconURL, "{BRIDGE}", name, -1)
+	iconURL = strings.Replace(iconURL, "{BRIDGE}", msg.Origin, -1)
-	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
+	iconURL = strings.Replace(iconURL, "{PROTOCOL}", msg.Protocol, -1)
 	return iconURL
 }
 
-type TestConfig struct {
+func GetNick(msg *Message, cfg *Protocol) string {
-	Config
+	nick := cfg.RemoteNickFormat
-
+	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
-	Overrides map[string]interface{}
+	nick = strings.Replace(nick, "{BRIDGE}", msg.Origin, -1)
-}
+	nick = strings.Replace(nick, "{PROTOCOL}", msg.Protocol, -1)
-
+	return nick
-func (c *TestConfig) GetBool(key string) (bool, bool) {
-	val, ok := c.Overrides[key]
-	if ok {
-		return val.(bool), true
-	}
-	return c.Config.GetBool(key)
-}
-
-func (c *TestConfig) GetInt(key string) (int, bool) {
-	if val, ok := c.Overrides[key]; ok {
-		return val.(int), true
-	}
-	return c.Config.GetInt(key)
-}
-
-func (c *TestConfig) GetString(key string) (string, bool) {
-	if val, ok := c.Overrides[key]; ok {
-		return val.(string), true
-	}
-	return c.Config.GetString(key)
-}
-
-func (c *TestConfig) GetStringSlice(key string) ([]string, bool) {
-	if val, ok := c.Overrides[key]; ok {
-		return val.([]string), true
-	}
-	return c.Config.GetStringSlice(key)
-}
-
-func (c *TestConfig) GetStringSlice2D(key string) ([][]string, bool) {
-	if val, ok := c.Overrides[key]; ok {
-		return val.([][]string), true
-	}
-	return c.Config.GetStringSlice2D(key)
 }

bridge/discord/discord.go

@@ -1,371 +1,136 @@
 package bdiscord
 
 import (
-	"bytes"
-	"errors"
-	"fmt"
-	"regexp"
-	"strings"
-	"sync"
-
-	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
+	log "github.com/Sirupsen/logrus"
 	"github.com/bwmarrin/discordgo"
+	"strings"
 )
 
-const MessageLength = 1950
+type bdiscord struct {
-
+	c            *discordgo.Session
-type Bdiscord struct {
+	Config       *config.Protocol
-	c              *discordgo.Session
+	Remote       chan config.Message
-	Channels       []*discordgo.Channel
+	protocol     string
-	Nick           string
+	origin       string
-	UseChannelID   bool
+	Channels     []*discordgo.Channel
-	userMemberMap  map[string]*discordgo.Member
+	Nick         string
-	nickMemberMap  map[string]*discordgo.Member
+	UseChannelID bool
-	guildID        string
-	webhookID      string
-	webhookToken   string
-	channelInfoMap map[string]*config.ChannelInfo
-	sync.RWMutex
-	*bridge.Config
 }
 
-func New(cfg *bridge.Config) bridge.Bridger {
+var flog *log.Entry
-	b := &Bdiscord{Config: cfg}
+var protocol = "discord"
-	b.userMemberMap = make(map[string]*discordgo.Member)
+
-	b.nickMemberMap = make(map[string]*discordgo.Member)
+func init() {
-	b.channelInfoMap = make(map[string]*config.ChannelInfo)
+	flog = log.WithFields(log.Fields{"module": protocol})
-	if b.GetString("WebhookURL") != "" {
+}
-		b.Log.Debug("Configuring Discord Incoming Webhook")
+
-		b.webhookID, b.webhookToken = b.splitURL(b.GetString("WebhookURL"))
+func New(cfg config.Protocol, origin string, c chan config.Message) *bdiscord {
-	}
+	b := &bdiscord{}
+	b.Config = &cfg
+	b.Remote = c
+	b.protocol = protocol
+	b.origin = origin
 	return b
 }
 
-func (b *Bdiscord) Connect() error {
+func (b *bdiscord) Connect() error {
 	var err error
-	var token string
+	flog.Info("Connecting")
-	b.Log.Info("Connecting")
+	b.c, err = discordgo.New(b.Config.Token)
-	if b.GetString("WebhookURL") == "" {
-		b.Log.Info("Connecting using token")
-	} else {
-		b.Log.Info("Connecting using webhookurl (for posting) and token")
-	}
-	if !strings.HasPrefix(b.GetString("Token"), "Bot ") {
-		token = "Bot " + b.GetString("Token")
-	}
-	b.c, err = discordgo.New(token)
 	if err != nil {
+		flog.Debugf("%#v", err)
 		return err
 	}
-	b.Log.Info("Connection succeeded")
+	flog.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(100, "", "")
+	guilds, err := b.c.UserGuilds()
 	if err != nil {
+		flog.Debugf("%#v", err)
 		return err
 	}
 	userinfo, err := b.c.User("@me")
 	if err != nil {
+		flog.Debugf("%#v", err)
 		return err
 	}
-	serverName := strings.Replace(b.GetString("Server"), "ID:", "", -1)
 	b.Nick = userinfo.Username
 	for _, guild := range guilds {
-		if guild.Name == serverName || guild.ID == serverName {
+		if guild.Name == b.Config.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)
-	}
-	// obtaining guild members and initializing nickname mapping
-	b.Lock()
-	defer b.Unlock()
-	members, err := b.c.GuildMembers(b.guildID, "", 1000)
-	if err != nil {
-		b.Log.Error("Error obtaining guild members", err)
-		return err
-	}
-	for _, member := range members {
-		b.userMemberMap[member.User.ID] = member
-		b.nickMemberMap[member.User.Username] = member
-		if member.Nick != "" {
-			b.nickMemberMap[member.Nick] = member
-		}
-	}
 	return nil
 }
 
-func (b *Bdiscord) Disconnect() error {
+func (b *bdiscord) FullOrigin() string {
-	return b.c.Close()
+	return b.protocol + "." + b.origin
 }
 
-func (b *Bdiscord) JoinChannel(channel config.ChannelInfo) error {
+func (b *bdiscord) JoinChannel(channel string) error {
-	b.channelInfoMap[channel.ID] = &channel
+	idcheck := strings.Split(channel, "ID:")
-	idcheck := strings.Split(channel.Name, "ID:")
 	if len(idcheck) > 1 {
 		b.UseChannelID = true
 	}
 	return nil
 }
 
-func (b *Bdiscord) Send(msg config.Message) (string, error) {
+func (b *bdiscord) Name() string {
-	b.Log.Debugf("=> Receiving %#v", msg)
+	return b.protocol + "." + b.origin
+}
 
+func (b *bdiscord) Protocol() string {
+	return b.protocol
+}
+
+func (b *bdiscord) Origin() string {
+	return b.origin
+}
+
+func (b *bdiscord) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
 	channelID := b.getChannelID(msg.Channel)
 	if channelID == "" {
-		return "", fmt.Errorf("Could not find channelID for %v", msg.Channel)
+		flog.Errorf("Could not find channelID for %v", msg.Channel)
+		return nil
 	}
-
+	nick := config.GetNick(&msg, b.Config)
-	// Make a action /me of the message
+	b.c.ChannelMessageSend(channelID, nick+msg.Text)
-	if msg.Event == config.EventUserAction {
+	return nil
-		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.EventJoinLeave && msg.Event != config.EventTopicChange {
-			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)
-		msg.Text = b.replaceUserMentions(msg.Text)
-		// discord username must be [0..32] max
-		if len(msg.Username) > 32 {
-			msg.Username = msg.Username[0:32]
-		}
-		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.EventMsgDelete {
-		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)
-	msg.Text = b.replaceUserMentions(msg.Text)
-
-	// Edit message
-	if msg.ID != "" {
-		_, err := b.c.ChannelMessageEdit(channelID, msg.ID, msg.Username+msg.Text)
-		return msg.ID, err
-	}
-
-	// Post normal message
-	res, err := b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
-	if err != nil {
-		return "", err
-	}
-	return res.ID, err
 }
 
-func (b *Bdiscord) messageDelete(s *discordgo.Session, m *discordgo.MessageDelete) {
+func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
-	rmsg := config.Message{Account: b.Account, ID: m.ID, Event: config.EventMsgDelete, Text: config.EventMsgDelete}
-	rmsg.Channel = b.getChannelName(m.ChannelID)
-	if b.UseChannelID {
-		rmsg.Channel = "ID:" + m.ChannelID
-	}
-	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
-	b.Log.Debugf("<= Message is %#v", rmsg)
-	b.Remote <- rmsg
-}
-
-func (b *Bdiscord) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
-	if b.GetBool("EditDisable") {
-		return
-	}
-	// only when message is actually edited
-	if m.Message.EditedTimestamp != "" {
-		b.Log.Debugf("Sending edit message")
-		m.Content += b.GetString("EditSuffix")
-		b.messageCreate(s, (*discordgo.MessageCreate)(m))
-	}
-}
-
-func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
-	var err error
-
 	// not relay our own messages
 	if m.Author.Username == b.Nick {
 		return
 	}
-	// if using webhooks, do not relay if it's ours
-	if b.useWebhook() && m.Author.Bot && b.isWebhookID(m.Author.ID) {
-		return
-	}
-
-	// add the url of the attachments to content
 	if len(m.Attachments) > 0 {
 		for _, attach := range m.Attachments {
 			m.Content = m.Content + "\n" + attach.URL
 		}
 	}
-
+	if m.Content == "" {
-	rmsg := config.Message{Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg", UserID: m.Author.ID, ID: m.ID}
-
-	if m.Content != "" {
-		b.Log.Debugf("== Receiving event %#v", m.Message)
-		m.Message.Content = b.stripCustomoji(m.Message.Content)
-		m.Message.Content = b.replaceChannelMentions(m.Message.Content)
-		rmsg.Text, err = m.ContentWithMoreMentionsReplaced(b.c)
-		if err != nil {
-			b.Log.Errorf("ContentWithMoreMentionsReplaced failed: %s", err)
-			rmsg.Text = m.ContentWithMentionsReplaced()
-		}
-	}
-
-	// set channel name
-	rmsg.Channel = b.getChannelName(m.ChannelID)
-	if b.UseChannelID {
-		rmsg.Channel = "ID:" + m.ChannelID
-	}
-
-	// set username
-	if !b.GetBool("UseUserName") {
-		rmsg.Username = b.getNick(m.Author)
-	} else {
-		rmsg.Username = m.Author.Username
-	}
-
-	// if we have embedded content add it to text
-	if b.GetBool("ShowEmbeds") && m.Message.Embeds != nil {
-		for _, embed := range m.Message.Embeds {
-			rmsg.Text = rmsg.Text + "embed: " + embed.Title + " - " + embed.Description + " - " + embed.URL + "\n"
-		}
-	}
-
-	// no empty messages
-	if rmsg.Text == "" {
 		return
 	}
-
+	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.FullOrigin())
-	// do we have a /me action
+	channelName := b.getChannelName(m.ChannelID)
-	var ok bool
+	if b.UseChannelID {
-	rmsg.Text, ok = b.replaceAction(rmsg.Text)
+		channelName = "ID:" + m.ChannelID
-	if ok {
-		rmsg.Event = config.EventUserAction
 	}
-
+	b.Remote <- config.Message{Username: m.Author.Username, Text: m.ContentWithMentionsReplaced(), Channel: channelName,
-	b.Log.Debugf("<= Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+		Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin(), Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg"}
-	b.Log.Debugf("<= Message is %#v", rmsg)
-	b.Remote <- rmsg
 }
 
-func (b *Bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
+func (b *bdiscord) getChannelID(name string) string {
-	b.Lock()
-	if _, ok := b.userMemberMap[m.Member.User.ID]; ok {
-		b.Log.Debugf("%s: memberupdate: user %s (nick %s) changes nick to %s", b.Account, m.Member.User.Username, b.userMemberMap[m.Member.User.ID].Nick, m.Member.Nick)
-	}
-	b.userMemberMap[m.Member.User.ID] = m.Member
-	b.nickMemberMap[m.Member.User.Username] = m.Member
-	if m.Member.Nick != "" {
-		b.nickMemberMap[m.Member.Nick] = m.Member
-	}
-	b.Unlock()
-}
-
-func (b *Bdiscord) getNick(user *discordgo.User) string {
-	var err error
-	b.Lock()
-	defer b.Unlock()
-	if _, ok := b.userMemberMap[user.ID]; ok {
-		if b.userMemberMap[user.ID] != nil {
-			if b.userMemberMap[user.ID].Nick != "" {
-				// only return if nick is set
-				return b.userMemberMap[user.ID].Nick
-			}
-			// otherwise return username
-			return user.Username
-		}
-	}
-	// if we didn't find nick, search for it
-	member, err := b.c.GuildMember(b.guildID, user.ID)
-	if err != nil {
-		return user.Username
-	}
-	b.userMemberMap[user.ID] = member
-	// only return if nick is set
-	if b.userMemberMap[user.ID].Nick != "" {
-		return b.userMemberMap[user.ID].Nick
-	}
-	return user.Username
-}
-
-func (b *Bdiscord) getGuildMemberByNick(nick string) (*discordgo.Member, error) {
-	b.Lock()
-	defer b.Unlock()
-	if _, ok := b.nickMemberMap[nick]; ok {
-		if b.nickMemberMap[nick] != nil {
-			return b.nickMemberMap[nick], nil
-		}
-	}
-
-	return nil, errors.New("Couldn't find guild member with nick " + nick) // This will most likely get ignored by the caller
-}
-
-func (b *Bdiscord) getChannelID(name string) string {
 	idcheck := strings.Split(name, "ID:")
 	if len(idcheck) > 1 {
 		return idcheck[1]
@@ -378,7 +143,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
@@ -386,126 +151,3 @@ func (b *Bdiscord) getChannelName(id string) string {
 	}
 	return ""
 }
-
-func (b *Bdiscord) replaceChannelMentions(text string) string {
-	var err error
-	re := regexp.MustCompile("<#[0-9]+>")
-	text = re.ReplaceAllStringFunc(text, func(m string) string {
-		channel := b.getChannelName(m[2 : len(m)-1])
-		// if at first don't succeed, try again
-		if channel == "" {
-			b.Channels, err = b.c.GuildChannels(b.guildID)
-			if err != nil {
-				return "#unknownchannel"
-			}
-			channel = b.getChannelName(m[2 : len(m)-1])
-			return "#" + channel
-		}
-		return "#" + channel
-	})
-	return text
-}
-
-func (b *Bdiscord) replaceUserMentions(text string) string {
-	re := regexp.MustCompile("@[^@]{1,32}")
-	text = re.ReplaceAllStringFunc(text, func(m string) string {
-		mention := strings.TrimSpace(m[1:])
-		var member *discordgo.Member
-		var err error
-		for {
-			b.Log.Debugf("Testing mention: '%s'", mention)
-			member, err = b.getGuildMemberByNick(mention)
-			if err != nil {
-				lastSpace := strings.LastIndex(mention, " ")
-				if lastSpace == -1 {
-					break
-				}
-				mention = strings.TrimSpace(mention[0:lastSpace])
-			} else {
-				break
-			}
-		}
-		if err != nil {
-			return m
-		}
-		return strings.Replace(m, "@"+mention, member.User.Mention(), -1)
-	})
-	b.Log.Debugf("Message with mention replaced: %s", text)
-	return text
-}
-
-func (b *Bdiscord) replaceAction(text string) (string, bool) {
-	if strings.HasPrefix(text, "_") && strings.HasSuffix(text, "_") {
-		return strings.Replace(text, "_", "", -1), true
-	}
-	return text, false
-}
-
-func (b *Bdiscord) stripCustomoji(text string) string {
-	// <:doge:302803592035958784>
-	re := regexp.MustCompile("<(:.*?:)[0-9]+>")
-	return re.ReplaceAllString(text, `$1`)
-}
-
-// splitURL splits a webhookURL and returns the id and token
-func (b *Bdiscord) splitURL(url string) (string, string) {
-	webhookURLSplit := strings.Split(url, "/")
-	if len(webhookURLSplit) != 7 {
-		b.Log.Fatalf("%s is no correct discord WebhookURL", url)
-	}
-	return webhookURLSplit[len(webhookURLSplit)-2], webhookURLSplit[len(webhookURLSplit)-1]
-}
-
-// useWebhook returns true if we have a webhook defined somewhere
-func (b *Bdiscord) useWebhook() bool {
-	if b.GetString("WebhookURL") != "" {
-		return true
-	}
-	for _, channel := range b.channelInfoMap {
-		if channel.Options.WebhookURL != "" {
-			return true
-		}
-	}
-	return false
-}
-
-// isWebhookID returns true if the specified id is used in a defined webhook
-func (b *Bdiscord) isWebhookID(id string) bool {
-	if b.GetString("WebhookURL") != "" {
-		wID, _ := b.splitURL(b.GetString("WebhookURL"))
-		if wID == id {
-			return true
-		}
-	}
-	for _, channel := range b.channelInfoMap {
-		if channel.Options.WebhookURL != "" {
-			wID, _ := b.splitURL(channel.Options.WebhookURL)
-			if wID == id {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// handleUploadFile handles native upload of files
-func (b *Bdiscord) handleUploadFile(msg *config.Message, channelID string) (string, error) {
-	var err error
-	for _, f := range msg.Extra["file"] {
-		fi := f.(config.FileInfo)
-		file := discordgo.File{
-			Name:        fi.Name,
-			ContentType: "",
-			Reader:      bytes.NewReader(*fi.Data),
-		}
-		m := discordgo.MessageSend{
-			Content: msg.Username + fi.Comment,
-			Files:   []*discordgo.File{&file},
-		}
-		_, err = b.c.ChannelMessageSendComplex(channelID, &m)
-		if err != nil {
-			return "", fmt.Errorf("file upload failed: %#v", err)
-		}
-	}
-	return "", nil
-}

bridge/gitter/gitter.go

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

@@ -1,153 +0,0 @@
-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
-}
-
-// GetSubLines splits messages in newline-delimited lines. If maxLineLength is
-// specified as non-zero GetSubLines will and also clip long lines to the
-// maximum length and insert a warning marker that the line was clipped.
-//
-// TODO: The current implementation has the inconvenient that it disregards
-// word boundaries when splitting but this is hard to solve without potentially
-// breaking formatting and other stylistic effects.
-func GetSubLines(message string, maxLineLength int) []string {
-	const clippingMessage = " <clipped message>"
-
-	var lines []string
-	for _, line := range strings.Split(strings.TrimSpace(message), "\n") {
-		if maxLineLength == 0 || len([]byte(line)) <= maxLineLength {
-			lines = append(lines, line)
-			continue
-		}
-
-		// !!! WARNING !!!
-		// Before touching the splitting logic below please ensure that you PROPERLY
-		// understand how strings, runes and range loops over strings work in Go.
-		// A good place to start is to read https://blog.golang.org/strings. :-)
-		var splitStart int
-		var startOfPreviousRune int
-		for i := range line {
-			if i-splitStart > maxLineLength-len([]byte(clippingMessage)) {
-				lines = append(lines, line[splitStart:startOfPreviousRune]+clippingMessage)
-				splitStart = startOfPreviousRune
-			}
-			startOfPreviousRune = i
-		}
-		// This last append is safe to do without looking at the remaining byte-length
-		// as we assume that the byte-length of the last rune will never exceed that of
-		// the byte-length of the clipping message.
-		lines = append(lines, line[splitStart:])
-	}
-	return lines
-}
-
-// handle all the stuff we put into extra
-func HandleExtra(msg *config.Message, general *config.Protocol) []config.Message {
-	extra := msg.Extra
-	rmsg := []config.Message{}
-	for _, f := range extra[config.EventFileFailureSize] {
-		fi := f.(config.FileInfo)
-		text := fmt.Sprintf("file %s too big to download (%#v > allowed size: %#v)", fi.Name, fi.Size, general.MediaDownloadSize)
-		rmsg = append(rmsg, config.Message{Text: text, Username: "<system> ", Channel: msg.Channel, Account: msg.Account})
-	}
-	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.EventFileFailureSize
-		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.EventAvatarDownload {
-		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/helper/helper_test.go

@@ -1,105 +0,0 @@
-package helper
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-const testLineLength = 64
-
-var (
-	lineSplittingTestCases = map[string]struct {
-		input          string
-		splitOutput    []string
-		nonSplitOutput []string
-	}{
-		"Short single-line message": {
-			input:          "short",
-			splitOutput:    []string{"short"},
-			nonSplitOutput: []string{"short"},
-		},
-		"Long single-line message": {
-			input: "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-			splitOutput: []string{
-				"Lorem ipsum dolor sit amet, consectetur adipis <clipped message>",
-				"cing elit, sed do eiusmod tempor incididunt ut <clipped message>",
-				" labore et dolore magna aliqua.",
-			},
-			nonSplitOutput: []string{"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."},
-		},
-		"Short multi-line message": {
-			input: "I\ncan't\nget\nno\nsatisfaction!",
-			splitOutput: []string{
-				"I",
-				"can't",
-				"get",
-				"no",
-				"satisfaction!",
-			},
-			nonSplitOutput: []string{
-				"I",
-				"can't",
-				"get",
-				"no",
-				"satisfaction!",
-			},
-		},
-		"Long multi-line message": {
-			input: "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n" +
-				"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n" +
-				"Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n" +
-				"Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
-			splitOutput: []string{
-				"Lorem ipsum dolor sit amet, consectetur adipis <clipped message>",
-				"cing elit, sed do eiusmod tempor incididunt ut <clipped message>",
-				" labore et dolore magna aliqua.",
-				"Ut enim ad minim veniam, quis nostrud exercita <clipped message>",
-				"tion ullamco laboris nisi ut aliquip ex ea com <clipped message>",
-				"modo consequat.",
-				"Duis aute irure dolor in reprehenderit in volu <clipped message>",
-				"ptate velit esse cillum dolore eu fugiat nulla <clipped message>",
-				" pariatur.",
-				"Excepteur sint occaecat cupidatat non proident <clipped message>",
-				", sunt in culpa qui officia deserunt mollit an <clipped message>",
-				"im id est laborum.",
-			},
-			nonSplitOutput: []string{
-				"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-				"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.",
-				"Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.",
-				"Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
-			},
-		},
-		"Message ending with new-line.": {
-			input:          "Newline ending\n",
-			splitOutput:    []string{"Newline ending"},
-			nonSplitOutput: []string{"Newline ending"},
-		},
-		"Long message containing UTF-8 multi-byte runes": {
-			input: "不布人個我此而及單石業喜資富下我河下日沒一我臺空達的常景便物沒為……子大我別名解成？生賣的全直黑，我自我結毛分洲了世當，是政福那是東；斯說",
-			splitOutput: []string{
-				"不布人個我此而及單石業喜資富下 <clipped message>",
-				"我河下日沒一我臺空達的常景便物 <clipped message>",
-				"沒為……子大我別名解成？生賣的 <clipped message>",
-				"全直黑，我自我結毛分洲了世當， <clipped message>",
-				"是政福那是東；斯說",
-			},
-			nonSplitOutput: []string{"不布人個我此而及單石業喜資富下我河下日沒一我臺空達的常景便物沒為……子大我別名解成？生賣的全直黑，我自我結毛分洲了世當，是政福那是東；斯說"},
-		},
-	}
-)
-
-func TestGetSubLines(t *testing.T) {
-	for testname, testcase := range lineSplittingTestCases {
-		splitLines := GetSubLines(testcase.input, testLineLength)
-		assert.Equalf(t, testcase.splitOutput, splitLines, "'%s' testcase should give expected lines with splitting.", testname)
-		for _, splitLine := range splitLines {
-			byteLength := len([]byte(splitLine))
-			assert.True(t, byteLength <= testLineLength, "Splitted line '%s' of testcase '%s' should not exceed the maximum byte-length (%d vs. %d).", splitLine, testcase, byteLength, testLineLength)
-		}
-
-		nonSplitLines := GetSubLines(testcase.input, 0)
-		assert.Equalf(t, testcase.nonSplitOutput, nonSplitLines, "'%s' testcase should give expected lines without splitting.", testname)
-	}
-}

bridge/irc/helper.go

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

bridge/irc/irc.go

@@ -1,485 +1,262 @@
 package birc
 
 import (
-	"bytes"
 	"crypto/tls"
 	"fmt"
-	"hash/crc32"
+	"github.com/42wim/matterbridge/bridge/config"
-	"io"
+	log "github.com/Sirupsen/logrus"
-	"io/ioutil"
+	ircm "github.com/sorcix/irc"
-	"net"
+	"github.com/thoj/go-ircevent"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 	"time"
-
-	"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/saintfish/chardet"
-
-	// We need to import the 'data' package as an implicit dependency.
-	// See: https://godoc.org/github.com/paulrosania/go-charset/charset
-	_ "github.com/paulrosania/go-charset/data"
 )
 
 type Birc struct {
-	i                                         *girc.Client
+	i         *irc.Connection
-	Nick                                      string
+	Nick      string
-	names                                     map[string][]string
+	names     map[string][]string
-	connected                                 chan error
+	Config    *config.Protocol
-	Local                                     chan config.Message // local queue for flood control
+	origin    string
-	FirstConnection, authDone                 bool
+	protocol  string
-	MessageDelay, MessageQueue, MessageLength int
+	Remote    chan config.Message
-
+	connected chan struct{}
-	*bridge.Config
+	Local     chan config.Message // local queue for flood control
 }
 
-func New(cfg *bridge.Config) bridge.Bridger {
+var flog *log.Entry
+var protocol = "irc"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, origin string, c chan config.Message) *Birc {
 	b := &Birc{}
-	b.Config = cfg
+	b.Config = &cfg
-	b.Nick = b.GetString("Nick")
+	b.Nick = b.Config.Nick
+	b.Remote = c
 	b.names = make(map[string][]string)
-	b.connected = make(chan error)
+	b.origin = origin
-	if b.GetInt("MessageDelay") == 0 {
+	b.protocol = protocol
-		b.MessageDelay = 1300
+	b.connected = make(chan struct{})
-	} else {
+	if b.Config.MessageDelay == 0 {
-		b.MessageDelay = b.GetInt("MessageDelay")
+		b.Config.MessageDelay = 1300
 	}
-	if b.GetInt("MessageQueue") == 0 {
+	if b.Config.MessageQueue == 0 {
-		b.MessageQueue = 30
+		b.Config.MessageQueue = 30
-	} else {
-		b.MessageQueue = b.GetInt("MessageQueue")
 	}
-	if b.GetInt("MessageLength") == 0 {
+	b.Local = make(chan config.Message, b.Config.MessageQueue+10)
-		b.MessageLength = 400
-	} else {
-		b.MessageLength = b.GetInt("MessageLength")
-	}
-	b.FirstConnection = true
 	return b
 }
 
 func (b *Birc) Command(msg *config.Message) string {
-	if msg.Text == "!users" {
+	switch msg.Text {
-		b.i.Handlers.Add(girc.RPL_NAMREPLY, b.storeNames)
+	case "!users":
-		b.i.Handlers.Add(girc.RPL_ENDOFNAMES, b.endNames)
+		b.i.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
-		b.i.Cmd.SendRaw("NAMES " + msg.Channel)
+		b.i.SendRaw("NAMES " + msg.Channel)
+		b.i.ClearCallback(ircm.RPL_ENDOFNAMES)
 	}
 	return ""
 }
 
 func (b *Birc) Connect() error {
-	b.Local = make(chan config.Message, b.MessageQueue+10)
+	flog.Infof("Connecting %s", b.Config.Server)
-	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	i := irc.IRC(b.Config.Nick, b.Config.Nick)
-	server, portstr, err := net.SplitHostPort(b.GetString("Server"))
+	if log.GetLevel() == log.DebugLevel {
+		i.Debug = true
+	}
+	i.UseTLS = b.Config.UseTLS
+	i.UseSASL = b.Config.UseSASL
+	i.SASLLogin = b.Config.NickServNick
+	i.SASLPassword = b.Config.NickServPassword
+	i.TLSConfig = &tls.Config{InsecureSkipVerify: b.Config.SkipTLSVerify}
+	if b.Config.Password != "" {
+		i.Password = b.Config.Password
+	}
+	i.AddCallback(ircm.RPL_WELCOME, b.handleNewConnection)
+	err := i.Connect(b.Config.Server)
 	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{
-			User: b.GetString("NickServNick"),
-			Pass: 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)
-				if b.FirstConnection {
-					b.connected <- err
-					return
-				}
-			} 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.EventRejoinChannels}
-				// set our correct nick on reconnect if necessary
-				b.Nick = event.Source.Name
-			})
-		}
-	}()
 	b.i = i
-	err = <-b.connected
+	select {
-	if err != nil {
+	case <-b.connected:
-		return fmt.Errorf("connection failed %s", err)
+		flog.Info("Connection succeeded")
-	}
+	case <-time.After(time.Second * 30):
-	b.Log.Info("Connection succeeded")
+		return fmt.Errorf("connection timed out")
-	b.FirstConnection = false
-	if b.GetInt("DebugLevel") == 0 {
-		i.Handlers.Clear(girc.ALL_EVENTS)
 	}
+	i.Debug = false
 	go b.doSend()
 	return nil
 }
 
-func (b *Birc) Disconnect() error {
+func (b *Birc) FullOrigin() string {
-	b.i.Close()
+	return b.protocol + "." + b.origin
-	close(b.Local)
+}
+
+func (b *Birc) JoinChannel(channel string) error {
+	b.i.Join(channel)
 	return nil
 }
 
-func (b *Birc) JoinChannel(channel config.ChannelInfo) error {
+func (b *Birc) Name() string {
-	// need to check if we have nickserv auth done before joining channels
+	return b.protocol + "." + b.origin
-	for {
-		if b.authDone {
-			break
-		}
-		time.Sleep(time.Second)
-	}
-	if channel.Options.Key != "" {
-		b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
-		b.i.Cmd.JoinKey(channel.Name, channel.Options.Key)
-	} else {
-		b.i.Cmd.Join(channel.Name)
-	}
-	return nil
 }
 
-func (b *Birc) Send(msg config.Message) (string, error) {
+func (b *Birc) Protocol() string {
-	// ignore delete messages
+	return b.protocol
-	if msg.Event == config.EventMsgDelete {
+}
-		return "", nil
+
+func (b *Birc) Origin() string {
+	return b.origin
+}
+
+func (b *Birc) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	if msg.FullOrigin == b.FullOrigin() {
+		return nil
 	}
-
-	b.Log.Debugf("=> Receiving %#v", msg)
-
-	// we can be in between reconnects #385
-	if !b.i.IsConnected() {
-		b.Log.Error("Not connected to server, dropping message")
-	}
-
-	// Execute a command
 	if strings.HasPrefix(msg.Text, "!") {
 		b.Command(&msg)
+		return nil
 	}
-
+	nick := config.GetNick(&msg, b.Config)
-	// convert to specified charset
+	for _, text := range strings.Split(msg.Text, "\n") {
-	if b.GetString("Charset") != "" {
+		if len(b.Local) < b.Config.MessageQueue {
-		switch b.GetString("Charset") {
+			if len(b.Local) == b.Config.MessageQueue-1 {
-		case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
+				text = text + " <message clipped>"
-			msg.Text = ic.ConvertString("utf-8", b.GetString("Charset"), msg.Text)
-		default:
-			buf := new(bytes.Buffer)
-			w, err := charset.NewWriter(b.GetString("Charset"), buf)
-			if err != nil {
-				b.Log.Errorf("charset from utf-8 conversion failed: %s", err)
-				return "", err
 			}
-			fmt.Fprint(w, msg.Text)
+			b.Local <- config.Message{Text: text, Username: nick, Channel: msg.Channel}
-			w.Close()
+		} else {
-			msg.Text = buf.String()
+			flog.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
 		}
 	}
-
+	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
-		}
-	}
-
-	var msgLines []string
-	if b.GetBool("MessageSplit") {
-		msgLines = helper.GetSubLines(msg.Text, b.MessageLength)
-	} else {
-		msgLines = helper.GetSubLines(msg.Text, 0)
-	}
-	for i := range msgLines {
-		if len(b.Local) >= b.MessageQueue {
-			b.Log.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
-			return "", nil
-		}
-
-		b.Local <- config.Message{
-			Text:     msgLines[i],
-			Username: msg.Username,
-			Channel:  msg.Channel,
-			Event:    msg.Event,
-		}
-	}
-	return "", nil
 }
 
 func (b *Birc) doSend() {
-	rate := time.Millisecond * time.Duration(b.MessageDelay)
+	rate := time.Millisecond * time.Duration(b.Config.MessageDelay)
-	throttle := time.NewTicker(rate)
+	throttle := time.Tick(rate)
 	for msg := range b.Local {
-		<-throttle.C
+		<-throttle
-		username := msg.Username
+		b.i.Privmsg(msg.Channel, msg.Username+msg.Text)
-		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.EventUserAction {
-			b.i.Cmd.Action(msg.Channel, username+msg.Text)
-		} else {
-			b.Log.Debugf("Sending to channel %s", msg.Channel)
-			b.i.Cmd.Message(msg.Channel, username+msg.Text)
-		}
 	}
 }
 
-func (b *Birc) endNames(client *girc.Client, event girc.Event) {
+func (b *Birc) endNames(event *irc.Event) {
-	channel := event.Params[1]
+	channel := event.Arguments[1]
 	sort.Strings(b.names[channel])
 	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
+	continued := false
 	for len(b.names[channel]) > maxNamesPerPost {
-		b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel][0:maxNamesPerPost]),
+		b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel][0:maxNamesPerPost], continued),
-			Channel: channel, Account: b.Account}
+			Channel: channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
 		b.names[channel] = b.names[channel][maxNamesPerPost:]
+		continued = true
 	}
-	b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel]),
+	b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel], continued), Channel: channel,
-		Channel: channel, Account: b.Account}
+		Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
 	b.names[channel] = nil
-	b.i.Handlers.Clear(girc.RPL_NAMREPLY)
-	b.i.Handlers.Clear(girc.RPL_ENDOFNAMES)
 }
 
-func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
+func (b *Birc) handleNewConnection(event *irc.Event) {
-	b.Log.Debug("Registering callbacks")
+	flog.Debug("Registering callbacks")
 	i := b.i
-	b.Nick = event.Params[0]
+	b.Nick = event.Arguments[0]
-
+	i.AddCallback("PRIVMSG", b.handlePrivMsg)
-	i.Handlers.Add("PRIVMSG", b.handlePrivMsg)
+	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
-	i.Handlers.Add("CTCP_ACTION", b.handlePrivMsg)
+	i.AddCallback(ircm.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
-	i.Handlers.Add(girc.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
+	i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
-	i.Handlers.Add(girc.NOTICE, b.handleNotice)
+	i.AddCallback(ircm.NOTICE, b.handleNotice)
-	i.Handlers.Add("JOIN", b.handleJoinPart)
+	//i.AddCallback(ircm.RPL_MYINFO, func(e *irc.Event) { flog.Infof("%s: %s", e.Code, strings.Join(e.Arguments[1:], " ")) })
-	i.Handlers.Add("PART", b.handleJoinPart)
+	i.AddCallback("PING", func(e *irc.Event) {
-	i.Handlers.Add("QUIT", b.handleJoinPart)
+		i.SendRaw("PONG :" + e.Message())
-	i.Handlers.Add("KICK", b.handleJoinPart)
+		flog.Debugf("PING/PONG")
+	})
+	i.AddCallback("*", b.handleOther)
+	// we are now fully connected
+	b.connected <- struct{}{}
 }
 
-func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
+func (b *Birc) handleNotice(event *irc.Event) {
-	if len(event.Params) == 0 {
+	if strings.Contains(event.Message(), "This nickname is registered") && event.Nick == b.Config.NickServNick {
-		b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
+		b.i.Privmsg(b.Config.NickServNick, "IDENTIFY "+b.Config.NickServPassword)
-		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.EventRejoinChannels}
-		return
-	}
-	if event.Command == "QUIT" {
-		if event.Source.Name == b.Nick && strings.Contains(event.Trailing, "Ping timeout") {
-			b.Log.Infof("%s reconnecting ..", b.Account)
-			b.Remote <- config.Message{Username: "system", Text: "reconnect", Channel: channel, Account: b.Account, Event: config.EventFailure}
-			return
-		}
-	}
-	if event.Source.Name != b.Nick {
-		if b.GetBool("nosendjoinpart") {
-			return
-		}
-		b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
-		msg := config.Message{Username: "system", Text: event.Source.Name + " " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
-		b.Log.Debugf("<= Message is %#v", msg)
-		b.Remote <- msg
-		return
-	}
-	b.Log.Debugf("handle %#v", event)
-}
-
-func (b *Birc) handleNotice(client *girc.Client, event girc.Event) {
-	if strings.Contains(event.String(), "This nickname is registered") && event.Source.Name == b.GetString("NickServNick") {
-		b.handleNickServ()
 	} else {
-		b.handlePrivMsg(client, event)
+		b.handlePrivMsg(event)
 	}
 }
 
-func (b *Birc) handleOther(client *girc.Client, event girc.Event) {
+func (b *Birc) handleOther(event *irc.Event) {
-	if b.GetInt("DebugLevel") == 1 {
+	switch event.Code {
-		if event.Command != "CLIENT_STATE_UPDATED" &&
-			event.Command != "CLIENT_GENERAL_UPDATED" {
-			b.Log.Debugf("%#v", event.String())
-		}
-		return
-	}
-	switch event.Command {
 	case "372", "375", "376", "250", "251", "252", "253", "254", "255", "265", "266", "002", "003", "004", "005":
 		return
 	}
-	b.Log.Debugf("%#v", event.String())
+	flog.Debugf("%#v", event.Raw)
 }
 
-func (b *Birc) handleOtherAuth(client *girc.Client, event girc.Event) {
+func (b *Birc) handlePrivMsg(event *irc.Event) {
-	b.handleNickServ()
-	// we are now fully connected
-	b.connected <- nil
-}
-
-func (b *Birc) skipPrivMsg(event girc.Event) bool {
-	// Our nick can be changed
-	b.Nick = b.i.GetNick()
-
-	// freenode doesn't send 001 as first reply
-	if event.Command == "NOTICE" {
-		return true
-	}
 	// don't forward queries to the bot
-	if event.Params[0] == b.Nick {
+	if event.Arguments[0] == b.Nick {
-		return true
-	}
-	// don't forward message from ourself
-	if event.Source.Name == b.Nick {
-		return true
-	}
-	return false
-}
-
-func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
-	if b.skipPrivMsg(event) {
 		return
 	}
-	rmsg := config.Message{Username: event.Source.Name, Channel: strings.ToLower(event.Params[0]), Account: b.Account, UserID: event.Source.Ident + "@" + event.Source.Host}
+	// don't forward message from ourself
-	b.Log.Debugf("== Receiving PRIVMSG: %s %s %#v", event.Source.Name, event.Trailing, event)
+	if event.Nick == b.Nick {
-
+		return
-	// set action event
-	if event.IsAction() {
-		rmsg.Event = config.EventUserAction
 	}
-
+	flog.Debugf("handlePrivMsg() %s %s %#v", event.Nick, event.Message(), event)
-	// strip action, we made an event if it was an action
+	msg := ""
-	rmsg.Text += event.StripAction()
+	if event.Code == "CTCP_ACTION" {
-
+		msg = event.Nick + " "
+	}
+	msg += event.Message()
 	// strip IRC colors
-	re := regexp.MustCompile(`\x03(?:\d{1,2}(?:,\d{1,2})?)?|[[:cntrl:]]`)
+	re := regexp.MustCompile(`[[:cntrl:]](\d+,|)\d+`)
-	rmsg.Text = re.ReplaceAllString(rmsg.Text, "")
+	msg = re.ReplaceAllString(msg, "")
-
+	flog.Debugf("Sending message from %s on %s to gateway", event.Arguments[0], b.FullOrigin())
-	// start detecting the charset
+	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
-	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) {
+func (b *Birc) handleTopicWhoTime(event *irc.Event) {
-	parts := strings.Split(event.Params[2], "!")
+	parts := strings.Split(event.Arguments[2], "!")
-	t, err := strconv.ParseInt(event.Params[3], 10, 64)
+	t, err := strconv.ParseInt(event.Arguments[3], 10, 64)
 	if err != nil {
-		b.Log.Errorf("Invalid time stamp: %s", event.Params[3])
+		flog.Errorf("Invalid time stamp: %s", event.Arguments[3])
 	}
 	user := parts[0]
 	if len(parts) > 1 {
 		user += " [" + parts[1] + "]"
 	}
-	b.Log.Debugf("%s: Topic set by %s [%s]", event.Command, user, time.Unix(t, 0))
+	flog.Debugf("%s: Topic set by %s [%s]", event.Code, 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(client *girc.Client, event girc.Event) {
+func (b *Birc) storeNames(event *irc.Event) {
-	channel := event.Params[2]
+	channel := event.Arguments[2]
 	b.names[channel] = append(
 		b.names[channel],
-		strings.Split(strings.TrimSpace(event.Trailing), " ")...)
+		strings.Split(strings.TrimSpace(event.Message()), " ")...)
 }
 
-func (b *Birc) formatnicks(nicks []string) string {
+func (b *Birc) formatnicks(nicks []string, continued bool) string {
-	return strings.Join(nicks, ", ") + " currently on IRC"
+	return plainformatter(nicks, b.nicksPerRow())
-}
+	/*
-
+		switch b.Config.Mattermost.NickFormatter {
-func (b *Birc) handleNickServ() {
+		case "table":
-	if !b.GetBool("UseSASL") && b.GetString("NickServNick") != "" && b.GetString("NickServPassword") != "" {
+			return tableformatter(nicks, b.nicksPerRow(), continued)
-		b.Log.Debugf("Sending identify to nickserv %s", b.GetString("NickServNick"))
+		default:
-		b.i.Cmd.Message(b.GetString("NickServNick"), "IDENTIFY "+b.GetString("NickServPassword"))
+			return plainformatter(nicks, b.nicksPerRow())
-	}
+		}
-	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"))
-	}
-	// give nickserv some slack
-	time.Sleep(time.Second * 5)
-	b.authDone = true
 }

bridge/matrix/matrix.go

@@ -1,315 +0,0 @@
-package bmatrix
-
-import (
-	"bytes"
-	"fmt"
-	"mime"
-	"regexp"
-	"strings"
-	"sync"
-
-	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
-	matrix "github.com/matterbridge/gomatrix"
-)
-
-type Bmatrix struct {
-	mc      *matrix.Client
-	UserID  string
-	RoomMap map[string]string
-	sync.RWMutex
-	*bridge.Config
-}
-
-func New(cfg *bridge.Config) bridge.Bridger {
-	b := &Bmatrix{Config: cfg}
-	b.RoomMap = make(map[string]string)
-	return b
-}
-
-func (b *Bmatrix) Connect() error {
-	var err error
-	b.Log.Infof("Connecting %s", b.GetString("Server"))
-	b.mc, err = matrix.NewClient(b.GetString("Server"), "", "")
-	if err != nil {
-		return err
-	}
-	resp, err := b.mc.Login(&matrix.ReqLogin{
-		Type:     "m.login.password",
-		User:     b.GetString("Login"),
-		Password: b.GetString("Password"),
-	})
-	if err != nil {
-		return err
-	}
-	b.mc.SetCredentials(resp.UserID, resp.AccessToken)
-	b.UserID = resp.UserID
-	b.Log.Info("Connection succeeded")
-	go b.handlematrix()
-	return nil
-}
-
-func (b *Bmatrix) Disconnect() error {
-	return nil
-}
-
-func (b *Bmatrix) JoinChannel(channel config.ChannelInfo) error {
-	resp, err := b.mc.JoinRoom(channel.Name, "", nil)
-	if err != nil {
-		return err
-	}
-	b.Lock()
-	b.RoomMap[resp.RoomID] = channel.Name
-	b.Unlock()
-	return err
-}
-
-func (b *Bmatrix) Send(msg config.Message) (string, error) {
-	b.Log.Debugf("=> Receiving %#v", msg)
-
-	channel := b.getRoomID(msg.Channel)
-	b.Log.Debugf("Channel %s maps to channel id %s", msg.Channel, channel)
-
-	// Make a action /me of the message
-	if msg.Event == config.EventUserAction {
-		m := matrix.TextMessage{
-			MsgType: "m.emote",
-			Body:    msg.Username + msg.Text,
-		}
-		resp, err := b.mc.SendMessageEvent(channel, "m.room.message", m)
-		if err != nil {
-			return "", err
-		}
-		return resp.EventID, err
-	}
-
-	// Delete message
-	if msg.Event == config.EventMsgDelete {
-		if msg.ID == "" {
-			return "", nil
-		}
-		resp, err := b.mc.RedactEvent(channel, msg.ID, &matrix.ReqRedact{})
-		if err != nil {
-			return "", err
-		}
-		return resp.EventID, err
-	}
-
-	// Upload a file if it exists
-	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			b.mc.SendText(channel, rmsg.Username+rmsg.Text)
-		}
-		// check if we have files to upload (from slack, telegram or mattermost)
-		if len(msg.Extra["file"]) > 0 {
-			return b.handleUploadFile(&msg, channel)
-		}
-	}
-
-	// Edit message if we have an ID
-	// matrix has no editing support
-
-	// Post normal message
-	resp, err := b.mc.SendText(channel, msg.Username+msg.Text)
-	if err != nil {
-		return "", err
-	}
-	return resp.EventID, err
-}
-
-func (b *Bmatrix) getRoomID(channel string) string {
-	b.RLock()
-	defer b.RUnlock()
-	for ID, name := range b.RoomMap {
-		if name == channel {
-			return ID
-		}
-	}
-	return ""
-}
-
-func (b *Bmatrix) handlematrix() {
-	syncer := b.mc.Syncer.(*matrix.DefaultSyncer)
-	syncer.OnEventType("m.room.redaction", b.handleEvent)
-	syncer.OnEventType("m.room.message", b.handleEvent)
-	go func() {
-		for {
-			if err := b.mc.Sync(); err != nil {
-				b.Log.Println("Sync() returned ", err)
-			}
-		}
-	}()
-}
-
-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] is not a string: %T\n%#v",
-				ev.Content["body"], ev.Content)
-			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.EventMsgDelete
-			rmsg.ID = ev.Redacts
-			rmsg.Text = config.EventMsgDelete
-			b.Remote <- rmsg
-			return
-		}
-
-		// Do we have a /me action
-		if ev.Content["msgtype"].(string) == "m.emote" {
-			rmsg.Event = config.EventUserAction
-		}
-
-		// 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 += mext[0]
-			}
-		} else {
-			// just a default .png extension if we don't have mime info
-			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,33 +1,54 @@
 package bmattermost
 
 import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/42wim/matterbridge/matterclient"
 	"github.com/42wim/matterbridge/matterhook"
-	"github.com/mattermost/platform/model"
+	log "github.com/Sirupsen/logrus"
-	"github.com/rs/xid"
 )
 
-type Bmattermost struct {
+type MMhook struct {
-	mh     *matterhook.Client
+	mh *matterhook.Client
-	mc     *matterclient.MMClient
-	uuid   string
-	TeamID string
-	*bridge.Config
-	avatarMap map[string]string
 }
 
-const mattermostPlugin = "mattermost.plugin"
+type MMapi struct {
+	mc            *matterclient.MMClient
+	mmMap         map[string]string
+	mmIgnoreNicks []string
+}
 
-func New(cfg *bridge.Config) bridge.Bridger {
+type MMMessage struct {
-	b := &Bmattermost{Config: cfg, avatarMap: make(map[string]string)}
+	Text     string
-	b.uuid = xid.New().String()
+	Channel  string
+	Username string
+}
+
+type Bmattermost struct {
+	MMhook
+	MMapi
+	Config   *config.Protocol
+	Remote   chan config.Message
+	name     string
+	origin   string
+	protocol string
+	TeamId   string
+}
+
+var flog *log.Entry
+var protocol = "mattermost"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, origin string, c chan config.Message) *Bmattermost {
+	b := &Bmattermost{}
+	b.Config = &cfg
+	b.origin = origin
+	b.Remote = c
+	b.protocol = "mattermost"
+	b.name = cfg.Name
+	b.mmMap = make(map[string]string)
 	return b
 }
 
@@ -36,447 +57,126 @@ func (b *Bmattermost) Command(cmd string) string {
 }
 
 func (b *Bmattermost) Connect() error {
-	if b.Account == mattermostPlugin {
+	if !b.Config.UseAPI {
-		return nil
+		flog.Info("Connecting webhooks")
-	}
+		b.mh = matterhook.New(b.Config.URL,
-	if b.GetString("WebhookBindAddress") != "" {
+			matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
-		switch {
+				BindAddress: b.Config.BindAddress})
-		case b.GetString("WebhookURL") != "":
+	} else {
-			b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
+		b.mc = matterclient.New(b.Config.Login, b.Config.Password,
-			b.mh = matterhook.New(b.GetString("WebhookURL"),
+			b.Config.Team, b.Config.Server)
-				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+		b.mc.SkipTLSVerify = b.Config.SkipTLSVerify
-					BindAddress: b.GetString("WebhookBindAddress")})
+		b.mc.NoTLS = b.Config.NoTLS
-		case b.GetString("Token") != "":
+		flog.Infof("Connecting %s (team: %s) on %s", b.Config.Login, b.Config.Team, b.Config.Server)
-			b.Log.Info("Connecting using token (sending)")
+		err := b.mc.Login()
-			err := b.apiLogin()
-			if err != nil {
-				return err
-			}
-		case b.GetString("Login") != "":
-			b.Log.Info("Connecting using login/password (sending)")
-			err := b.apiLogin()
-			if err != nil {
-				return err
-			}
-		default:
-			b.Log.Info("Connecting using webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString("WebhookURL"),
-				matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-					BindAddress: b.GetString("WebhookBindAddress")})
-		}
-		go b.handleMatter()
-		return nil
-	}
-	switch {
-	case 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
-	case b.GetString("Token") != "":
-		b.Log.Info("Connecting using token (sending and receiving)")
-		err := b.apiLogin()
 		if err != nil {
 			return err
 		}
-		go b.handleMatter()
+		flog.Info("Connection succeeded")
-	case b.GetString("Login") != "":
+		b.TeamId = b.mc.GetTeamId()
-		b.Log.Info("Connecting using login/password (sending and receiving)")
+		go b.mc.WsReceiver()
-		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
 }
 
-func (b *Bmattermost) Disconnect() error {
+func (b *Bmattermost) FullOrigin() string {
-	return nil
+	return b.protocol + "." + b.origin
 }
 
-func (b *Bmattermost) JoinChannel(channel config.ChannelInfo) error {
+func (b *Bmattermost) JoinChannel(channel string) error {
-	if b.Account == mattermostPlugin {
-		return nil
-	}
 	// we can only join channels using the API
-	if b.GetString("WebhookURL") == "" && b.GetString("WebhookBindAddress") == "" {
+	if b.Config.UseAPI {
-		id := b.mc.GetChannelId(channel.Name, b.TeamID)
+		return b.mc.JoinChannel(b.mc.GetChannelId(channel, ""))
-		if id == "" {
-			return fmt.Errorf("Could not find channel ID for channel %s", channel.Name)
-		}
-		return b.mc.JoinChannel(id)
 	}
 	return nil
 }
 
-func (b *Bmattermost) Send(msg config.Message) (string, error) {
+func (b *Bmattermost) Name() string {
-	if b.Account == mattermostPlugin {
+	return b.protocol + "." + b.origin
-		return "", nil
+}
-	}
-	b.Log.Debugf("=> Receiving %#v", msg)
 
-	// Make a action /me of the message
+func (b *Bmattermost) Origin() string {
-	if msg.Event == config.EventUserAction {
+	return b.origin
-		msg.Text = "*" + msg.Text + "*"
+}
-	}
 
-	// map the file SHA to our user (caches the avatar)
+func (b *Bmattermost) Protocol() string {
-	if msg.Event == config.EventAvatarDownload {
+	return b.protocol
-		return b.cacheAvatar(&msg)
+}
-	}
 
-	// Use webhook to send the message
+func (b *Bmattermost) Send(msg config.Message) error {
-	if b.GetString("WebhookURL") != "" {
+	flog.Debugf("Receiving %#v", msg)
-		return b.sendWebhook(msg)
+	nick := config.GetNick(&msg, b.Config)
-	}
+	message := msg.Text
+	channel := msg.Channel
 
-	// Delete message
+	if b.Config.PrefixMessagesWithNick {
-	if msg.Event == config.EventMsgDelete {
+		/*if IsMarkup(message) {
-		if msg.ID == "" {
+			message = nick + "\n\n" + message
-			return "", nil
+		} else {
+		*/
+		message = nick + " " + message
+		//}
+	}
+	if !b.Config.UseAPI {
+		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+		matterMessage.Channel = channel
+		matterMessage.UserName = nick
+		matterMessage.Type = ""
+		matterMessage.Text = message
+		err := b.mh.Send(matterMessage)
+		if err != nil {
+			flog.Info(err)
+			return err
 		}
-		return msg.ID, b.mc.DeleteMessage(msg.ID)
+		return nil
 	}
-
+	b.mc.PostMessage(b.mc.GetChannelId(channel, ""), message)
-	// Upload a file if it exists
+	return nil
-	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			b.mc.PostMessage(b.mc.GetChannelId(rmsg.Channel, b.TeamID), 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, b.TeamID), msg.Text)
 }
 
 func (b *Bmattermost) handleMatter() {
-	messages := make(chan *config.Message)
+	flog.Debugf("Choosing API based Mattermost connection: %t", b.Config.UseAPI)
-	if b.GetString("WebhookBindAddress") != "" {
+	mchan := make(chan *MMMessage)
-		b.Log.Debugf("Choosing webhooks based receiving")
+	if b.Config.UseAPI {
-		go b.handleMatterHook(messages)
+		go b.handleMatterClient(mchan)
 	} else {
-		if b.GetString("Token") != "" {
+		go b.handleMatterHook(mchan)
-			b.Log.Debugf("Choosing token based receiving")
-		} else {
-			b.Log.Debugf("Choosing login/password based receiving")
-		}
-		go b.handleMatterClient(messages)
 	}
-	var ok bool
+	for message := range mchan {
-	for message := range messages {
+		flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.FullOrigin())
-		message.Avatar = helper.GetAvatar(b.avatarMap, message.UserID, b.General)
+		b.Remote <- config.Message{Text: message.Text, Username: message.Username, Channel: message.Channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
-		message.Account = b.Account
-		message.Text, ok = b.replaceAction(message.Text)
-		if ok {
-			message.Event = config.EventUserAction
-		}
-		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
-		b.Log.Debugf("<= Message is %#v", message)
-		b.Remote <- *message
 	}
 }
 
-func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
+func (b *Bmattermost) handleMatterClient(mchan chan *MMMessage) {
 	for message := range b.mc.MessageChan {
-		b.Log.Debugf("%#v", message.Raw.Data)
+		// do not post our own messages back to irc
-
+		// only listen to message from our team
-		if b.skipMessage(message) {
+		if message.Raw.Event == "posted" && b.mc.User.Username != message.Username && message.Raw.Data["team_id"].(string) == b.TeamId {
-			b.Log.Debugf("Skipped message: %#v", message)
+			flog.Debugf("Receiving from matterclient %#v", message)
-			continue
+			m := &MMMessage{}
-		}
+			m.Username = message.Username
-
+			m.Channel = message.Channel
-		// only download avatars if we have a place to upload them (configured mediaserver)
+			m.Text = message.Text
-		if b.General.MediaServerUpload != "" || b.General.MediaDownloadPath != "" {
+			if len(message.Post.Filenames) > 0 {
-			b.handleDownloadAvatar(message.UserID, message.Channel)
+				for _, link := range b.mc.GetPublicLinks(message.Post.Filenames) {
-		}
+					m.Text = m.Text + "\n" + link
-
-		b.Log.Debugf("== Receiving event %#v", message)
-
-		rmsg := &config.Message{Username: message.Username, UserID: message.UserID, Channel: message.Channel, Text: message.Text, ID: message.Post.Id, Extra: make(map[string][]interface{})}
-
-		// handle mattermost post properties (override username and attachments)
-		props := message.Post.Props
-		if props != nil {
-			if _, ok := props["override_username"].(string); ok {
-				rmsg.Username = props["override_username"].(string)
-			}
-			if _, ok := props["attachments"].([]interface{}); ok {
-				rmsg.Extra["attachments"] = props["attachments"].([]interface{})
-				if rmsg.Text == "" {
-					for _, attachment := range rmsg.Extra["attachments"] {
-						attach := attachment.(map[string]interface{})
-						if attach["text"].(string) != "" {
-							rmsg.Text += attach["text"].(string)
-							continue
-						}
-						if attach["fallback"].(string) != "" {
-							rmsg.Text += attach["fallback"].(string)
-						}
-					}
 				}
 			}
+			mchan <- m
 		}
-
-		// create a text for bridges that don't support native editing
-		if message.Raw.Event == model.WEBSOCKET_EVENT_POST_EDITED && !b.GetBool("EditDisable") {
-			rmsg.Text = message.Text + b.GetString("EditSuffix")
-		}
-
-		if message.Raw.Event == model.WEBSOCKET_EVENT_POST_DELETED {
-			rmsg.Event = config.EventMsgDelete
-		}
-
-		if len(message.Post.FileIds) > 0 {
-			for _, id := range message.Post.FileIds {
-				err := b.handleDownloadFile(rmsg, id)
-				if err != nil {
-					b.Log.Errorf("download failed: %s", err)
-				}
-			}
-		}
-		// Use nickname instead of username if defined
-		if nick := b.mc.GetNickName(rmsg.UserID); nick != "" {
-			rmsg.Username = nick
-		}
-
-		messages <- rmsg
 	}
 }
 
-func (b *Bmattermost) handleMatterHook(messages chan *config.Message) {
+func (b *Bmattermost) handleMatterHook(mchan chan *MMMessage) {
 	for {
 		message := b.mh.Receive()
-		b.Log.Debugf("Receiving from matterhook %#v", message)
+		flog.Debugf("Receiving from matterhook %#v", message)
-		messages <- &config.Message{UserID: message.UserID, Username: message.UserName, Text: message.Text, Channel: message.ChannelName}
+		m := &MMMessage{}
+		m.Username = message.UserName
+		m.Text = message.Text
+		m.Channel = message.ChannelName
+		mchan <- m
 	}
 }
-
-func (b *Bmattermost) apiLogin() error {
-	password := b.GetString("Password")
-	if b.GetString("Token") != "" {
-		password = "token=" + 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.EventAvatarDownload, 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, b.TeamID)
-	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) {
-			rmsg := rmsg // scopelint
-			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
-			matterMessage := matterhook.OMessage{IconURL: iconURL, Channel: rmsg.Channel, UserName: rmsg.Username, Text: rmsg.Text, Props: make(map[string]interface{})}
-			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.EventJoinLeave}
-		return true
-	}
-
-	// Handle edited messages
-	if (message.Raw.Event == model.WEBSOCKET_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 == model.WEBSOCKET_EVENT_POST_EDITED || message.Raw.Event == model.WEBSOCKET_EVENT_POST_DELETED) {
-		return true
-	}
-	return false
-}

bridge/rocketchat/rocketchat.go

@@ -1,92 +0,0 @@
-package brocketchat
-
-import (
-	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/42wim/matterbridge/hook/rockethook"
-	"github.com/42wim/matterbridge/matterhook"
-)
-
-type Brocketchat struct {
-	mh *matterhook.Client
-	rh *rockethook.Client
-	*bridge.Config
-}
-
-func New(cfg *bridge.Config) bridge.Bridger {
-	return &Brocketchat{Config: cfg}
-}
-
-func (b *Brocketchat) Command(cmd string) string {
-	return ""
-}
-
-func (b *Brocketchat) Connect() error {
-	b.Log.Info("Connecting webhooks")
-	b.mh = matterhook.New(b.GetString("WebhookURL"),
-		matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
-			DisableServer: true})
-	b.rh = rockethook.New(b.GetString("WebhookURL"), rockethook.Config{BindAddress: b.GetString("WebhookBindAddress")})
-	go b.handleRocketHook()
-	return nil
-}
-
-func (b *Brocketchat) Disconnect() error {
-	return nil
-
-}
-
-func (b *Brocketchat) JoinChannel(channel config.ChannelInfo) error {
-	return nil
-}
-
-func (b *Brocketchat) Send(msg config.Message) (string, error) {
-	// ignore delete messages
-	if msg.Event == config.EventMsgDelete {
-		return "", nil
-	}
-	b.Log.Debugf("=> Receiving %#v", msg)
-	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			rmsg := rmsg // scopelint
-			iconURL := config.GetIconURL(&rmsg, b.GetString("iconurl"))
-			matterMessage := matterhook.OMessage{IconURL: iconURL, Channel: rmsg.Channel, UserName: rmsg.Username, Text: rmsg.Text}
-			b.mh.Send(matterMessage)
-		}
-		if len(msg.Extra["file"]) > 0 {
-			for _, f := range msg.Extra["file"] {
-				fi := f.(config.FileInfo)
-				if fi.URL != "" {
-					msg.Text += fi.URL
-				}
-			}
-		}
-	}
-
-	iconURL := config.GetIconURL(&msg, b.GetString("iconurl"))
-	matterMessage := matterhook.OMessage{IconURL: iconURL}
-	matterMessage.Channel = msg.Channel
-	matterMessage.UserName = msg.Username
-	matterMessage.Type = ""
-	matterMessage.Text = msg.Text
-	err := b.mh.Send(matterMessage)
-	if err != nil {
-		b.Log.Info(err)
-		return "", err
-	}
-	return "", nil
-}
-
-func (b *Brocketchat) handleRocketHook() {
-	for {
-		message := b.rh.Receive()
-		b.Log.Debugf("Receiving from rockethook %#v", message)
-		// do not loop
-		if message.UserName == b.GetString("Nick") {
-			continue
-		}
-		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.UserName, b.Account)
-		b.Remote <- config.Message{Text: message.Text, Username: message.UserName, Channel: message.ChannelName, Account: b.Account, UserID: message.UserID}
-	}
-}

bridge/slack/handlers.go

@@ -1,311 +0,0 @@
-package bslack
-
-import (
-	"fmt"
-	"html"
-	"time"
-
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/nlopes/slack"
-)
-
-func (b *Bslack) handleSlack() {
-	messages := make(chan *config.Message)
-	if b.GetString(incomingWebhookConfig) != "" {
-		b.Log.Debugf("Choosing webhooks based receiving")
-		go b.handleMatterHook(messages)
-	} else {
-		b.Log.Debugf("Choosing token based receiving")
-		go b.handleSlackClient(messages)
-	}
-	time.Sleep(time.Second)
-	b.Log.Debug("Start listening for Slack messages")
-	for message := range messages {
-		if message.Event != config.EventUserTyping {
-			b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
-		}
-
-		// cleanup the message
-		message.Text = b.replaceMention(message.Text)
-		message.Text = b.replaceVariable(message.Text)
-		message.Text = b.replaceChannel(message.Text)
-		message.Text = b.replaceURL(message.Text)
-		message.Text = html.UnescapeString(message.Text)
-
-		// Add the avatar
-		message.Avatar = b.getAvatar(message.UserID)
-
-		b.Log.Debugf("<= Message is %#v", message)
-		b.Remote <- *message
-	}
-}
-
-func (b *Bslack) handleSlackClient(messages chan *config.Message) {
-	for msg := range b.rtm.IncomingEvents {
-		if msg.Type != sUserTyping && msg.Type != sLatencyReport {
-			b.Log.Debugf("== Receiving event %#v", msg.Data)
-		}
-		switch ev := msg.Data.(type) {
-		case *slack.UserTypingEvent:
-			if !b.GetBool("ShowUserTyping") {
-				continue
-			}
-			rmsg, err := b.handleTypingEvent(ev)
-			if err != nil {
-				b.Log.Errorf("%#v", err)
-				continue
-			}
-
-			messages <- rmsg
-		case *slack.MessageEvent:
-			if b.skipMessageEvent(ev) {
-				b.Log.Debugf("Skipped message: %#v", ev)
-				continue
-			}
-			rmsg, err := b.handleMessageEvent(ev)
-			if err != nil {
-				b.Log.Errorf("%#v", err)
-				continue
-			}
-			messages <- rmsg
-		case *slack.OutgoingErrorEvent:
-			b.Log.Debugf("%#v", ev.Error())
-		case *slack.ChannelJoinedEvent:
-			// When we join a channel we update the full list of users as
-			// well as the information for the channel that we joined as this
-			// should now tell that we are a member of it.
-			b.populateUsers()
-
-			b.channelsMutex.Lock()
-			b.channelsByID[ev.Channel.ID] = &ev.Channel
-			b.channelsByName[ev.Channel.Name] = &ev.Channel
-			b.channelsMutex.Unlock()
-		case *slack.ConnectedEvent:
-			b.si = ev.Info
-			b.populateChannels()
-			b.populateUsers()
-		case *slack.InvalidAuthEvent:
-			b.Log.Fatalf("Invalid Token %#v", ev)
-		case *slack.ConnectionErrorEvent:
-			b.Log.Errorf("Connection failed %#v %#v", ev.Error(), ev.ErrorObj)
-		default:
-		}
-	}
-}
-
-func (b *Bslack) handleMatterHook(messages chan *config.Message) {
-	for {
-		message := b.mh.Receive()
-		b.Log.Debugf("receiving from matterhook (slack) %#v", message)
-		if message.UserName == "slackbot" {
-			continue
-		}
-		messages <- &config.Message{
-			Username: message.UserName,
-			Text:     message.Text,
-			Channel:  message.ChannelName,
-		}
-	}
-}
-
-// skipMessageEvent skips event that need to be skipped :-)
-func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
-	switch ev.SubType {
-	case sChannelLeave, sChannelJoin:
-		return b.GetBool(noSendJoinConfig)
-	case sPinnedItem, sUnpinnedItem:
-		return true
-	}
-
-	// Skip any messages that we made ourselves or from 'slackbot' (see #527).
-	if ev.Username == sSlackBotUser ||
-		(b.rtm != nil && ev.Username == b.si.User.Name) ||
-		(len(ev.Attachments) > 0 && ev.Attachments[0].CallbackID == "matterbridge_"+b.uuid) {
-		return true
-	}
-
-	// It seems ev.SubMessage.Edited == nil when slack unfurls.
-	// Do not forward these messages. See Github issue #266.
-	if ev.SubMessage != nil &&
-		ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp &&
-		ev.SubMessage.Edited == nil {
-		return true
-	}
-
-	if len(ev.Files) > 0 {
-		return b.filesCached(ev.Files)
-	}
-
-	return false
-}
-
-func (b *Bslack) filesCached(files []slack.File) bool {
-	for i := range files {
-		if !b.fileCached(&files[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-// handleMessageEvent handles the message events. Together with any called sub-methods,
-// this method implements the following event processing pipeline:
-//
-// 1. Check if the message should be ignored.
-//    NOTE: This is not actually part of the method below but is done just before it
-//          is called via the 'skipMessageEvent()' method.
-// 2. Populate the Matterbridge message that will be sent to the router based on the
-//    received event and logic that is common to all events that are not skipped.
-// 3. Detect and handle any message that is "status" related (think join channel, etc.).
-//    This might result in an early exit from the pipeline and passing of the
-//    pre-populated message to the Matterbridge router.
-// 4. Handle the specific case of messages that edit existing messages depending on
-//    configuration.
-// 5. Handle any attachments of the received event.
-// 6. Check that the Matterbridge message that we end up with after at the end of the
-//    pipeline is valid before sending it to the Matterbridge router.
-func (b *Bslack) handleMessageEvent(ev *slack.MessageEvent) (*config.Message, error) {
-	rmsg, err := b.populateReceivedMessage(ev)
-	if err != nil {
-		return nil, err
-	}
-
-	// Handle some message types early.
-	if b.handleStatusEvent(ev, rmsg) {
-		return rmsg, nil
-	}
-
-	b.handleAttachments(ev, rmsg)
-
-	// Verify that we have the right information and the message
-	// is well-formed before sending it out to the router.
-	if len(ev.Files) == 0 && (rmsg.Text == "" || rmsg.Username == "") {
-		if ev.BotID != "" {
-			// This is probably a webhook we couldn't resolve.
-			return nil, fmt.Errorf("message handling resulted in an empty bot message (probably an incoming webhook we couldn't resolve): %#v", ev)
-		}
-		return nil, fmt.Errorf("message handling resulted in an empty message: %#v", ev)
-	}
-	return rmsg, nil
-}
-
-func (b *Bslack) handleStatusEvent(ev *slack.MessageEvent, rmsg *config.Message) bool {
-	switch ev.SubType {
-	case sChannelJoined, sMemberJoined:
-		b.populateUsers()
-		// There's no further processing needed on channel events
-		// so we return 'true'.
-		return true
-	case sChannelJoin, sChannelLeave:
-		rmsg.Username = sSystemUser
-		rmsg.Event = config.EventJoinLeave
-	case sChannelTopic, sChannelPurpose:
-		rmsg.Event = config.EventTopicChange
-	case sMessageChanged:
-		rmsg.Text = ev.SubMessage.Text
-		// handle deleted thread starting messages
-		if ev.SubMessage.Text == "This message was deleted." {
-			rmsg.Event = config.EventMsgDelete
-			return true
-		}
-	case sMessageDeleted:
-		rmsg.Text = config.EventMsgDelete
-		rmsg.Event = config.EventMsgDelete
-		rmsg.ID = ev.DeletedTimestamp
-		// If a message is being deleted we do not need to process
-		// the event any further so we return 'true'.
-		return true
-	case sMeMessage:
-		rmsg.Event = config.EventUserAction
-	}
-	return false
-}
-
-func (b *Bslack) handleAttachments(ev *slack.MessageEvent, rmsg *config.Message) {
-	// File comments are set by the system (because there is no username given).
-	if ev.SubType == sFileComment {
-		rmsg.Username = sSystemUser
-	}
-
-	// 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
-			}
-		}
-	}
-
-	// Save the attachments, so that we can send them to other slack (compatible) bridges.
-	if len(ev.Attachments) > 0 {
-		rmsg.Extra[sSlackAttachment] = append(rmsg.Extra[sSlackAttachment], ev.Attachments)
-	}
-
-	// If we have files attached, download them (in memory) and put a pointer to it in msg.Extra.
-	for i := range ev.Files {
-		if err := b.handleDownloadFile(rmsg, &ev.Files[i]); err != nil {
-			b.Log.Errorf("Could not download incoming file: %#v", err)
-		}
-	}
-}
-
-func (b *Bslack) handleTypingEvent(ev *slack.UserTypingEvent) (*config.Message, error) {
-	channelInfo, err := b.getChannelByID(ev.Channel)
-	if err != nil {
-		return nil, err
-	}
-	return &config.Message{
-		Channel: channelInfo.Name,
-		Account: b.Account,
-		Event:   config.EventUserTyping,
-	}, nil
-}
-
-// handleDownloadFile handles file download
-func (b *Bslack) handleDownloadFile(rmsg *config.Message, file *slack.File) error {
-	if b.fileCached(file) {
-		return nil
-	}
-	// Check that the file is neither too large nor blacklisted.
-	if err := helper.HandleDownloadSize(b.Log, rmsg, file.Name, int64(file.Size), b.General); err != nil {
-		b.Log.WithError(err).Infof("Skipping download of incoming file.")
-		return nil
-	}
-
-	// Actually download the file.
-	data, err := helper.DownloadFileAuth(file.URLPrivateDownload, "Bearer "+b.GetString(tokenConfig))
-	if err != nil {
-		return fmt.Errorf("download %s failed %#v", file.URLPrivateDownload, err)
-	}
-
-	// If a comment is attached to the file(s) it is in the 'Text' field of the Slack messge event
-	// and should be added as comment to only one of the files. We reset the 'Text' field to ensure
-	// that the comment is not duplicated.
-	comment := rmsg.Text
-	rmsg.Text = ""
-	helper.HandleDownloadData(b.Log, rmsg, file.Name, comment, file.URLPrivateDownload, data, b.General)
-	return nil
-}
-
-// fileCached implements Matterbridge's caching logic for files
-// shared via Slack.
-//
-// We consider that a file was cached if its ID was added in the last minute or
-// it's name was registered in the last 10 seconds. This ensures that an
-// identically named file but with different content will be uploaded correctly
-// (the assumption is that such name collisions will not occur within the given
-// timeframes).
-func (b *Bslack) fileCached(file *slack.File) bool {
-	if ts, ok := b.cache.Get("file" + file.ID); ok && time.Since(ts.(time.Time)) < time.Minute {
-		return true
-	} else if ts, ok = b.cache.Get("filename" + file.Name); ok && time.Since(ts.(time.Time)) < 10*time.Second {
-		return true
-	}
-	return false
-}

bridge/slack/helpers.go

@@ -1,323 +0,0 @@
-package bslack
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/nlopes/slack"
-)
-
-func (b *Bslack) getUser(id string) *slack.User {
-	b.usersMutex.RLock()
-	defer b.usersMutex.RUnlock()
-
-	return b.users[id]
-}
-
-func (b *Bslack) getUsername(id string) string {
-	if user := b.getUser(id); user != nil {
-		if user.Profile.DisplayName != "" {
-			return user.Profile.DisplayName
-		}
-		return user.Name
-	}
-	b.Log.Warnf("Could not find user with ID '%s'", id)
-	return ""
-}
-
-func (b *Bslack) getAvatar(id string) string {
-	if user := b.getUser(id); user != nil {
-		return user.Profile.Image48
-	}
-	return ""
-}
-
-func (b *Bslack) getChannel(channel string) (*slack.Channel, error) {
-	if strings.HasPrefix(channel, "ID:") {
-		return b.getChannelByID(strings.TrimPrefix(channel, "ID:"))
-	}
-	return b.getChannelByName(channel)
-}
-
-func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
-	b.channelsMutex.RLock()
-	defer b.channelsMutex.RUnlock()
-
-	if channel, ok := b.channelsByName[name]; ok {
-		return channel, nil
-	}
-	return nil, fmt.Errorf("%s: channel %s not found", b.Account, name)
-}
-
-func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
-	b.channelsMutex.RLock()
-	defer b.channelsMutex.RUnlock()
-
-	if channel, ok := b.channelsByID[ID]; ok {
-		return channel, nil
-	}
-	return nil, fmt.Errorf("%s: channel %s not found", b.Account, ID)
-}
-
-const minimumRefreshInterval = 10 * time.Second
-
-func (b *Bslack) populateUsers() {
-	b.refreshMutex.Lock()
-	if time.Now().Before(b.earliestUserRefresh) || b.refreshInProgress {
-		b.Log.Debugf("Not refreshing user list as it was done less than %v ago.",
-			minimumRefreshInterval)
-		b.refreshMutex.Unlock()
-
-		return
-	}
-	b.refreshInProgress = true
-	b.refreshMutex.Unlock()
-
-	newUsers := map[string]*slack.User{}
-	pagination := b.sc.GetUsersPaginated(slack.GetUsersOptionLimit(200))
-	for {
-		var err error
-		pagination, err = pagination.Next(context.Background())
-		if err != nil {
-			if pagination.Done(err) {
-				break
-			}
-
-			if err = b.handleRateLimit(err); err != nil {
-				b.Log.Errorf("Could not retrieve users: %#v", err)
-				return
-			}
-			continue
-		}
-
-		for i := range pagination.Users {
-			newUsers[pagination.Users[i].ID] = &pagination.Users[i]
-		}
-	}
-
-	b.usersMutex.Lock()
-	defer b.usersMutex.Unlock()
-	b.users = newUsers
-
-	b.refreshMutex.Lock()
-	defer b.refreshMutex.Unlock()
-	b.earliestUserRefresh = time.Now().Add(minimumRefreshInterval)
-	b.refreshInProgress = false
-}
-
-func (b *Bslack) populateChannels() {
-	b.refreshMutex.Lock()
-	if time.Now().Before(b.earliestChannelRefresh) || b.refreshInProgress {
-		b.Log.Debugf("Not refreshing channel list as it was done less than %v seconds ago.",
-			minimumRefreshInterval)
-		b.refreshMutex.Unlock()
-		return
-	}
-	b.refreshInProgress = true
-	b.refreshMutex.Unlock()
-
-	newChannelsByID := map[string]*slack.Channel{}
-	newChannelsByName := map[string]*slack.Channel{}
-
-	// We only retrieve public and private channels, not IMs
-	// and MPIMs as those do not have a channel name.
-	queryParams := &slack.GetConversationsParameters{
-		ExcludeArchived: "true",
-		Types:           []string{"public_channel,private_channel"},
-	}
-	for {
-		channels, nextCursor, err := b.sc.GetConversations(queryParams)
-		if err != nil {
-			if err = b.handleRateLimit(err); err != nil {
-				b.Log.Errorf("Could not retrieve channels: %#v", err)
-				return
-			}
-			continue
-		}
-
-		for i := range channels {
-			newChannelsByID[channels[i].ID] = &channels[i]
-			newChannelsByName[channels[i].Name] = &channels[i]
-		}
-		if nextCursor == "" {
-			break
-		}
-		queryParams.Cursor = nextCursor
-	}
-
-	b.channelsMutex.Lock()
-	defer b.channelsMutex.Unlock()
-	b.channelsByID = newChannelsByID
-	b.channelsByName = newChannelsByName
-
-	b.refreshMutex.Lock()
-	defer b.refreshMutex.Unlock()
-	b.earliestChannelRefresh = time.Now().Add(minimumRefreshInterval)
-	b.refreshInProgress = false
-}
-
-// populateReceivedMessage shapes the initial Matterbridge message that we will forward to the
-// router before we apply message-dependent modifications.
-func (b *Bslack) populateReceivedMessage(ev *slack.MessageEvent) (*config.Message, error) {
-	// 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:       ev.Timestamp,
-		Extra:    make(map[string][]interface{}),
-		ParentID: ev.ThreadTimestamp,
-		Protocol: b.Protocol,
-	}
-	if b.useChannelID {
-		rmsg.Channel = "ID:" + channel.ID
-	}
-
-	// Handle 'edit' messages.
-	if ev.SubMessage != nil && !b.GetBool(editDisableConfig) {
-		rmsg.ID = ev.SubMessage.Timestamp
-		if ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
-			b.Log.Debugf("SubMessage %#v", ev.SubMessage)
-			rmsg.Text = ev.SubMessage.Text + b.GetString(editSuffixConfig)
-		}
-	}
-
-	if err = b.populateMessageWithUserInfo(ev, rmsg); err != nil {
-		return nil, err
-	}
-	return rmsg, err
-}
-
-func (b *Bslack) populateMessageWithUserInfo(ev *slack.MessageEvent, rmsg *config.Message) error {
-	if ev.SubType == sMessageDeleted || ev.SubType == sFileComment {
-		return nil
-	}
-
-	// First, deal with bot-originating messages but only do so when not using webhooks: we
-	// would not be able to distinguish which bot would be sending them.
-	if err := b.populateMessageWithBotInfo(ev, rmsg); err != nil {
-		return err
-	}
-
-	// Second, deal with "real" users if we have the necessary information.
-	var userID string
-	switch {
-	case ev.User != "":
-		userID = ev.User
-	case ev.SubMessage != nil && ev.SubMessage.User != "":
-		userID = ev.SubMessage.User
-	default:
-		return nil
-	}
-
-	user := b.getUser(userID)
-	if user == nil {
-		return fmt.Errorf("could not find information for user with id %s", ev.User)
-	}
-
-	rmsg.UserID = user.ID
-	rmsg.Username = user.Name
-	if user.Profile.DisplayName != "" {
-		rmsg.Username = user.Profile.DisplayName
-	}
-	return nil
-}
-
-func (b *Bslack) populateMessageWithBotInfo(ev *slack.MessageEvent, rmsg *config.Message) error {
-	if ev.BotID == "" || b.GetString(outgoingWebhookConfig) != "" {
-		return nil
-	}
-
-	var err error
-	var bot *slack.Bot
-	for {
-		bot, err = b.rtm.GetBotInfo(ev.BotID)
-		if err == nil {
-			break
-		}
-
-		if err = b.handleRateLimit(err); err != nil {
-			b.Log.Errorf("Could not retrieve bot information: %#v", err)
-			return err
-		}
-	}
-
-	if bot.Name != "" && bot.Name != "Slack API Tester" {
-		rmsg.Username = bot.Name
-		if ev.Username != "" {
-			rmsg.Username = ev.Username
-		}
-		rmsg.UserID = bot.ID
-	}
-	return nil
-}
-
-var (
-	mentionRE  = regexp.MustCompile(`<@([a-zA-Z0-9]+)>`)
-	channelRE  = regexp.MustCompile(`<#[a-zA-Z0-9]+\|(.+?)>`)
-	variableRE = regexp.MustCompile(`<!((?:subteam\^)?[a-zA-Z0-9]+)(?:\|@?(.+?))?>`)
-	urlRE      = regexp.MustCompile(`<(.*?)(\|.*?)?>`)
-)
-
-// @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
-func (b *Bslack) replaceMention(text string) string {
-	replaceFunc := func(match string) string {
-		userID := strings.Trim(match, "@<>")
-		if username := b.getUsername(userID); userID != "" {
-			return "@" + username
-		}
-		return match
-	}
-	return mentionRE.ReplaceAllStringFunc(text, replaceFunc)
-}
-
-// @see https://api.slack.com/docs/message-formatting#linking_to_channels_and_users
-func (b *Bslack) replaceChannel(text string) string {
-	for _, r := range channelRE.FindAllStringSubmatch(text, -1) {
-		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 {
-	for _, r := range variableRE.FindAllStringSubmatch(text, -1) {
-		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 {
-	for _, r := range urlRE.FindAllStringSubmatch(text, -1) {
-		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) handleRateLimit(err error) error {
-	rateLimit, ok := err.(*slack.RateLimitedError)
-	if !ok {
-		return err
-	}
-	b.Log.Infof("Rate-limited by Slack. Sleeping for %v", rateLimit.RetryAfter)
-	time.Sleep(rateLimit.RetryAfter)
-	return nil
-}

bridge/slack/legacy.go

@@ -1,74 +0,0 @@
-package bslack
-
-import (
-	"errors"
-
-	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/matterhook"
-	"github.com/nlopes/slack"
-)
-
-type BLegacy struct {
-	*Bslack
-}
-
-func NewLegacy(cfg *bridge.Config) bridge.Bridger {
-	return &BLegacy{Bslack: newBridge(cfg)}
-}
-
-func (b *BLegacy) Connect() error {
-	b.RLock()
-	defer b.RUnlock()
-	if b.GetString(incomingWebhookConfig) != "" {
-		switch {
-		case b.GetString(outgoingWebhookConfig) != "":
-			b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
-				InsecureSkipVerify: b.GetBool(skipTLSConfig),
-				BindAddress:        b.GetString(incomingWebhookConfig),
-			})
-		case b.GetString(tokenConfig) != "":
-			b.Log.Info("Connecting using token (sending)")
-			b.sc = slack.New(b.GetString(tokenConfig))
-			b.rtm = b.sc.NewRTM()
-			go b.rtm.ManageConnection()
-			b.Log.Info("Connecting using webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
-				InsecureSkipVerify: b.GetBool(skipTLSConfig),
-				BindAddress:        b.GetString(incomingWebhookConfig),
-			})
-		default:
-			b.Log.Info("Connecting using webhookbindaddress (receiving)")
-			b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
-				InsecureSkipVerify: b.GetBool(skipTLSConfig),
-				BindAddress:        b.GetString(incomingWebhookConfig),
-			})
-		}
-		go b.handleSlack()
-		return nil
-	}
-	if b.GetString(outgoingWebhookConfig) != "" {
-		b.Log.Info("Connecting using webhookurl (sending)")
-		b.mh = matterhook.New(b.GetString(outgoingWebhookConfig), matterhook.Config{
-			InsecureSkipVerify: b.GetBool(skipTLSConfig),
-			DisableServer:      true,
-		})
-		if b.GetString(tokenConfig) != "" {
-			b.Log.Info("Connecting using token (receiving)")
-			b.sc = slack.New(b.GetString(tokenConfig))
-			b.rtm = b.sc.NewRTM()
-			go b.rtm.ManageConnection()
-			go b.handleSlack()
-		}
-	} else if b.GetString(tokenConfig) != "" {
-		b.Log.Info("Connecting using token (sending and receiving)")
-		b.sc = slack.New(b.GetString(tokenConfig))
-		b.rtm = b.sc.NewRTM()
-		go b.rtm.ManageConnection()
-		go b.handleSlack()
-	}
-	if b.GetString(incomingWebhookConfig) == "" && b.GetString(outgoingWebhookConfig) == "" && b.GetString(tokenConfig) == "" {
-		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Token configured")
-	}
-	return nil
-}

bridge/slack/slack.go

@@ -1,105 +1,49 @@
 package bslack
 
 import (
-	"bytes"
-	"errors"
 	"fmt"
-	"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"
+	log "github.com/Sirupsen/logrus"
 	"github.com/nlopes/slack"
-	"github.com/rs/xid"
+	"strings"
+	"time"
 )
 
+type MMMessage struct {
+	Text     string
+	Channel  string
+	Username string
+	Raw      *slack.MessageEvent
+}
+
 type Bslack struct {
-	sync.RWMutex
+	mh       *matterhook.Client
-	*bridge.Config
+	sc       *slack.Client
-
+	Config   *config.Protocol
-	mh  *matterhook.Client
+	rtm      *slack.RTM
-	sc  *slack.Client
+	Plus     bool
-	rtm *slack.RTM
+	Remote   chan config.Message
-	si  *slack.Info
+	Users    []slack.User
-
+	protocol string
-	cache        *lru.Cache
+	origin   string
-	uuid         string
+	si       *slack.Info
-	useChannelID bool
+	channels []slack.Channel
-
-	users      map[string]*slack.User
-	usersMutex sync.RWMutex
-
-	channelsByID   map[string]*slack.Channel
-	channelsByName map[string]*slack.Channel
-	channelsMutex  sync.RWMutex
-
-	refreshInProgress      bool
-	earliestChannelRefresh time.Time
-	earliestUserRefresh    time.Time
-	refreshMutex           sync.Mutex
 }
 
-const (
+var flog *log.Entry
-	sChannelJoin     = "channel_join"
+var protocol = "slack"
-	sChannelLeave    = "channel_leave"
-	sChannelJoined   = "channel_joined"
-	sMemberJoined    = "member_joined_channel"
-	sMessageChanged  = "message_changed"
-	sMessageDeleted  = "message_deleted"
-	sSlackAttachment = "slack_attachment"
-	sPinnedItem      = "pinned_item"
-	sUnpinnedItem    = "unpinned_item"
-	sChannelTopic    = "channel_topic"
-	sChannelPurpose  = "channel_purpose"
-	sFileComment     = "file_comment"
-	sMeMessage       = "me_message"
-	sUserTyping      = "user_typing"
-	sLatencyReport   = "latency_report"
-	sSystemUser      = "system"
-	sSlackBotUser    = "slackbot"
 
-	tokenConfig           = "Token"
+func init() {
-	incomingWebhookConfig = "WebhookBindAddress"
+	flog = log.WithFields(log.Fields{"module": protocol})
-	outgoingWebhookConfig = "WebhookURL"
-	skipTLSConfig         = "SkipTLSVerify"
-	useNickPrefixConfig   = "PrefixMessagesWithNick"
-	editDisableConfig     = "EditDisable"
-	editSuffixConfig      = "EditSuffix"
-	iconURLConfig         = "iconurl"
-	noSendJoinConfig      = "nosendjoinpart"
-)
-
-func New(cfg *bridge.Config) bridge.Bridger {
-	// Print a deprecation warning for legacy non-bot tokens (#527).
-	token := cfg.GetString(tokenConfig)
-	if token != "" && !strings.HasPrefix(token, "xoxb") {
-		cfg.Log.Warn("Non-bot token detected. It is STRONGLY recommended to use a proper bot-token instead.")
-		cfg.Log.Warn("Legacy tokens may be deprecated by Slack at short notice. See the Matterbridge GitHub wiki for a migration guide.")
-		cfg.Log.Warn("See https://github.com/42wim/matterbridge/wiki/Slack-bot-setup")
-		return NewLegacy(cfg)
-	}
-	return newBridge(cfg)
 }
 
-func newBridge(cfg *bridge.Config) *Bslack {
+func New(cfg config.Protocol, origin string, c chan config.Message) *Bslack {
-	newCache, err := lru.New(5000)
+	b := &Bslack{}
-	if err != nil {
+	b.Config = &cfg
-		cfg.Log.Fatalf("Could not create LRU cache for Slack bridge: %v", err)
+	b.Remote = c
-	}
+	b.protocol = protocol
-	b := &Bslack{
+	b.origin = origin
-		Config:                 cfg,
-		uuid:                   xid.New().String(),
-		cache:                  newCache,
-		users:                  map[string]*slack.User{},
-		channelsByID:           map[string]*slack.Channel{},
-		channelsByName:         map[string]*slack.Channel{},
-		earliestChannelRefresh: time.Now(),
-		earliestUserRefresh:    time.Now(),
-	}
 	return b
 }
 
@@ -108,359 +52,187 @@ func (b *Bslack) Command(cmd string) string {
 }
 
 func (b *Bslack) Connect() error {
-	b.RLock()
+	flog.Info("Connecting")
-	defer b.RUnlock()
+	if !b.Config.UseAPI {
-
+		b.mh = matterhook.New(b.Config.URL,
-	if b.GetString(incomingWebhookConfig) == "" && b.GetString(outgoingWebhookConfig) == "" && b.GetString(tokenConfig) == "" {
+			matterhook.Config{BindAddress: b.Config.BindAddress})
-		return errors.New("no connection method found: WebhookBindAddress, WebhookURL or Token need to be configured")
+	} else {
-	}
+		b.sc = slack.New(b.Config.Token)
-
-	// If we have a token we use the Slack websocket-based RTM for both sending and receiving.
-	if token := b.GetString(tokenConfig); token != "" {
-		b.Log.Info("Connecting using token")
-		b.sc = slack.New(token)
 		b.rtm = b.sc.NewRTM()
 		go b.rtm.ManageConnection()
-		go b.handleSlack()
-		return nil
 	}
+	flog.Info("Connection succeeded")
+	go b.handleSlack()
+	return nil
+}
 
-	// In absence of a token we fall back to incoming and outgoing Webhooks.
+func (b *Bslack) FullOrigin() string {
-	b.mh = matterhook.New(
+	return b.protocol + "." + b.origin
-		"",
+}
-		matterhook.Config{
+
-			InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+func (b *Bslack) JoinChannel(channel string) error {
-			DisableServer:      true,
+	// we can only join channels using the API
-		},
+	if b.Config.UseAPI {
-	)
+		_, err := b.sc.JoinChannel(channel)
-	if b.GetString(outgoingWebhookConfig) != "" {
+		if err != nil {
-		b.Log.Info("Using specified webhook for outgoing messages.")
+			return err
-		b.mh.Url = b.GetString(outgoingWebhookConfig)
+		}
-	}
-	if b.GetString(incomingWebhookConfig) != "" {
-		b.Log.Info("Setting up local webhook for incoming messages.")
-		b.mh.BindAddress = b.GetString(incomingWebhookConfig)
-		b.mh.DisableServer = false
-		go b.handleSlack()
 	}
 	return nil
 }
 
-func (b *Bslack) Disconnect() error {
+func (b *Bslack) Name() string {
-	return b.rtm.Disconnect()
+	return b.protocol + "." + b.origin
 }
 
-// JoinChannel only acts as a verification method that checks whether Matterbridge's
+func (b *Bslack) Protocol() string {
-// Slack integration is already member of the channel. This is because Slack does not
+	return b.protocol
-// allow apps or bots to join channels themselves and they need to be invited
+}
-// manually by a user.
+
-func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
+func (b *Bslack) Origin() string {
-	// We can only join a channel through the Slack API.
+	return b.origin
-	if b.sc == nil {
+}
+
+func (b *Bslack) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	if msg.FullOrigin == b.FullOrigin() {
 		return nil
 	}
-
+	nick := config.GetNick(&msg, b.Config)
-	b.populateChannels()
+	message := msg.Text
-
+	channel := msg.Channel
-	channelInfo, err := b.getChannel(channel.Name)
+	if b.Config.PrefixMessagesWithNick {
+		message = nick + " " + message
+	}
+	if !b.Config.UseAPI {
+		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+		matterMessage.Channel = channel
+		matterMessage.UserName = nick
+		matterMessage.Type = ""
+		matterMessage.Text = message
+		err := b.mh.Send(matterMessage)
+		if err != nil {
+			flog.Info(err)
+			return err
+		}
+		return nil
+	}
+	schannel, err := b.getChannelByName(channel)
 	if err != nil {
-		return fmt.Errorf("could not join channel: %#v", err)
+		return err
 	}
-
+	np := slack.NewPostMessageParameters()
-	if strings.HasPrefix(channel.Name, "ID:") {
+	if b.Config.PrefixMessagesWithNick == true {
-		b.useChannelID = true
+		np.AsUser = true
-		channel.Name = channelInfo.Name
-	}
-
-	if !channelInfo.IsMember {
-		return fmt.Errorf("slack integration that matterbridge is using is not member of channel '%s', please add it manually", channelInfo.Name)
-	}
-	return nil
-}
-
-func (b *Bslack) Reload(cfg *bridge.Config) (string, error) {
-	return "", nil
-}
-
-func (b *Bslack) Send(msg config.Message) (string, error) {
-	// Too noisy to log like other events
-	if msg.Event != config.EventUserTyping {
-		b.Log.Debugf("=> Receiving %#v", msg)
-	}
-
-	// Make a action /me of the message
-	if msg.Event == config.EventUserAction {
-		msg.Text = "_" + msg.Text + "_"
-	}
-
-	// Use webhook to send the message
-	if b.GetString(outgoingWebhookConfig) != "" {
-		return b.sendWebhook(msg)
-	}
-	return b.sendRTM(msg)
-}
-
-// 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(useNickPrefixConfig) {
-		msg.Text = msg.Username + msg.Text
-	}
-
-	if msg.Extra != nil {
-		// This sends a message only if we received a config.EVENT_FILE_FAILURE_SIZE.
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			rmsg := rmsg // scopelint
-			iconURL := config.GetIconURL(&rmsg, b.GetString(iconURLConfig))
-			matterMessage := matterhook.OMessage{
-				IconURL:  iconURL,
-				Channel:  msg.Channel,
-				UserName: rmsg.Username,
-				Text:     rmsg.Text,
-			}
-			if err := b.mh.Send(matterMessage); err != nil {
-				b.Log.Errorf("Failed to send message: %v", err)
-			}
-		}
-
-		// Webhook doesn't support file uploads, so we add the URL manually.
-		for _, f := range msg.Extra["file"] {
-			fi, ok := f.(config.FileInfo)
-			if !ok {
-				b.Log.Errorf("Received a file with unexpected content: %#v", f)
-				continue
-			}
-			if fi.URL != "" {
-				msg.Text += " " + fi.URL
-			}
-		}
-	}
-
-	// If we have native slack_attachments add them.
-	var attachs []slack.Attachment
-	for _, attach := range msg.Extra[sSlackAttachment] {
-		attachs = append(attachs, attach.([]slack.Attachment)...)
-	}
-
-	iconURL := config.GetIconURL(&msg, b.GetString(iconURLConfig))
-	matterMessage := matterhook.OMessage{
-		IconURL:     iconURL,
-		Attachments: attachs,
-		Channel:     msg.Channel,
-		UserName:    msg.Username,
-		Text:        msg.Text,
 	}
+	np.Username = nick
+	np.IconURL = config.GetIconURL(&msg, b.Config)
 	if msg.Avatar != "" {
-		matterMessage.IconURL = msg.Avatar
+		np.IconURL = msg.Avatar
 	}
-	if err := b.mh.Send(matterMessage); err != nil {
+	b.sc.PostMessage(schannel.ID, message, np)
-		b.Log.Errorf("Failed to send message via webhook: %#v", err)
+
-		return "", err
+	/*
-	}
+	   newmsg := b.rtm.NewOutgoingMessage(message, schannel.ID)
-	return "", nil
+	   b.rtm.SendMessage(newmsg)
+	*/
+
+	return nil
 }
 
-func (b *Bslack) sendRTM(msg config.Message) (string, error) {
+func (b *Bslack) getAvatar(user string) string {
-	channelInfo, err := b.getChannel(msg.Channel)
+	var avatar string
-	if err != nil {
+	if b.Users != nil {
-		return "", fmt.Errorf("could not send message: %v", err)
+		for _, u := range b.Users {
-	}
+			if user == u.Name {
-	if msg.Event == config.EventUserTyping {
+				return u.Profile.Image48
-		if b.GetBool("ShowUserTyping") {
-			b.rtm.SendMessage(b.rtm.NewTypingMessage(channelInfo.ID))
-		}
-		return "", nil
-	}
-
-	// Handle message deletions.
-	var handled bool
-	if handled, err = b.deleteMessage(&msg, channelInfo); handled {
-		return msg.ID, err
-	}
-
-	// Prepend nickname if configured.
-	if b.GetBool(useNickPrefixConfig) {
-		msg.Text = msg.Username + msg.Text
-	}
-
-	// Handle message edits.
-	if handled, err = b.editMessage(&msg, channelInfo); handled {
-		return msg.ID, err
-	}
-
-	messageParameters := b.prepareMessageParameters(&msg)
-
-	// Upload a file if it exists.
-	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			_, _, err = b.rtm.PostMessage(channelInfo.ID, rmsg.Username+rmsg.Text, *messageParameters)
-			if err != nil {
-				b.Log.Error(err)
 			}
 		}
-		// Upload files if necessary (from Slack, Telegram or Mattermost).
-		b.uploadFile(&msg, channelInfo.ID)
 	}
-
+	return avatar
-	// Post message.
-	return b.postMessage(&msg, messageParameters, channelInfo)
 }
 
-func (b *Bslack) deleteMessage(msg *config.Message, channelInfo *slack.Channel) (bool, error) {
+func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
-	if msg.Event != config.EventMsgDelete {
+	if b.channels == nil {
-		return false, nil
+		return nil, fmt.Errorf("%s: channel %s not found (no channels found)", b.FullOrigin(), name)
 	}
-
+	for _, channel := range b.channels {
-	// Some protocols echo deletes, but with an empty ID.
+		if channel.Name == name {
-	if msg.ID == "" {
+			return &channel, nil
-		return true, nil
-	}
-
-	for {
-		_, _, err := b.rtm.DeleteMessage(channelInfo.ID, msg.ID)
-		if err == nil {
-			return true, nil
-		}
-
-		if err = b.handleRateLimit(err); err != nil {
-			b.Log.Errorf("Failed to delete user message from Slack: %#v", err)
-			return true, err
 		}
 	}
+	return nil, fmt.Errorf("%s: channel %s not found", b.FullOrigin(), name)
 }
 
-func (b *Bslack) editMessage(msg *config.Message, channelInfo *slack.Channel) (bool, error) {
+func (b *Bslack) handleSlack() {
-	if msg.ID == "" {
+	flog.Debugf("Choosing API based slack connection: %t", b.Config.UseAPI)
-		return false, nil
+	mchan := make(chan *MMMessage)
+	if b.Config.UseAPI {
+		go b.handleSlackClient(mchan)
+	} else {
+		go b.handleMatterHook(mchan)
 	}
-
+	time.Sleep(time.Second)
-	for {
+	flog.Debug("Start listening for Slack messages")
-		_, _, _, err := b.rtm.UpdateMessage(channelInfo.ID, msg.ID, msg.Text)
+	for message := range mchan {
-		if err == nil {
+		// do not send messages from ourself
-			return true, nil
+		if message.Username == b.si.User.Name {
-		}
-
-		if err = b.handleRateLimit(err); err != nil {
-			b.Log.Errorf("Failed to edit user message on Slack: %#v", err)
-			return true, err
-		}
-	}
-}
-
-func (b *Bslack) postMessage(msg *config.Message, messageParameters *slack.PostMessageParameters, channelInfo *slack.Channel) (string, error) {
-	// don't post empty messages
-	if msg.Text == "" {
-		return "", nil
-	}
-	for {
-		_, id, err := b.rtm.PostMessage(channelInfo.ID, msg.Text, *messageParameters)
-		if err == nil {
-			return id, nil
-		}
-
-		if err = b.handleRateLimit(err); err != nil {
-			b.Log.Errorf("Failed to sent user message to Slack: %#v", err)
-			return "", err
-		}
-	}
-}
-
-// uploadFile handles native upload of files
-func (b *Bslack) uploadFile(msg *config.Message, channelID string) {
-	for _, f := range msg.Extra["file"] {
-		fi, ok := f.(config.FileInfo)
-		if !ok {
-			b.Log.Errorf("Received a file with unexpected content: %#v", f)
 			continue
 		}
-		if msg.Text == fi.Comment {
+		texts := strings.Split(message.Text, "\n")
-			msg.Text = ""
+		for _, text := range texts {
-		}
+			flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.FullOrigin())
-		// Because the result of the UploadFile is slower than the MessageEvent from slack
+			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin(), Avatar: b.getAvatar(message.Username)}
-		// we can't match on the file ID yet, so we have to match on the filename too.
-		ts := time.Now()
-		b.Log.Debugf("Adding file %s to cache at %s with timestamp", fi.Name, ts.String())
-		b.cache.Add("filename"+fi.Name, ts)
-		initialComment := fmt.Sprintf("File from %s", msg.Username)
-		if fi.Comment != "" {
-			initialComment += fmt.Sprintf("with comment: %s", fi.Comment)
-		}
-		res, err := b.sc.UploadFile(slack.FileUploadParameters{
-			Reader:          bytes.NewReader(*fi.Data),
-			Filename:        fi.Name,
-			Channels:        []string{channelID},
-			InitialComment:  initialComment,
-			ThreadTimestamp: msg.ParentID,
-		})
-		if err != nil {
-			b.Log.Errorf("uploadfile %#v", err)
-			return
-		}
-		if res.ID != "" {
-			b.Log.Debugf("Adding file ID %s to cache with timestamp %s", res.ID, ts.String())
-			b.cache.Add("file"+res.ID, ts)
 		}
 	}
 }
 
-func (b *Bslack) prepareMessageParameters(msg *config.Message) *slack.PostMessageParameters {
+func (b *Bslack) handleSlackClient(mchan chan *MMMessage) {
-	params := slack.NewPostMessageParameters()
+	count := 0
-	if b.GetBool(useNickPrefixConfig) {
+	for msg := range b.rtm.IncomingEvents {
-		params.AsUser = true
+		switch ev := msg.Data.(type) {
-	}
+		case *slack.MessageEvent:
-	params.Username = msg.Username
+			// ignore first message
-	params.LinkNames = 1 // replace mentions
+			if count > 0 {
-	params.IconURL = config.GetIconURL(msg, b.GetString(iconURLConfig))
+				flog.Debugf("Receiving from slackclient %#v", ev)
-	params.ThreadTimestamp = msg.ParentID
+				//ev.ReplyTo
-	if msg.Avatar != "" {
+				channel, err := b.rtm.GetChannelInfo(ev.Channel)
-		params.IconURL = msg.Avatar
+				if err != nil {
-	}
+					continue
-	// add a callback ID so we can see we created it
+				}
-	params.Attachments = append(params.Attachments, slack.Attachment{CallbackID: "matterbridge_" + b.uuid})
+				user, err := b.rtm.GetUserInfo(ev.User)
-	// add file attachments
+				if err != nil {
-	params.Attachments = append(params.Attachments, b.createAttach(msg.Extra)...)
+					continue
-	// add slack attachments (from another slack bridge)
+				}
-	if msg.Extra != nil {
+				m := &MMMessage{}
-		for _, attach := range msg.Extra[sSlackAttachment] {
+				m.Username = user.Name
-			params.Attachments = append(params.Attachments, attach.([]slack.Attachment)...)
+				m.Channel = channel.Name
+				m.Text = ev.Text
+				m.Raw = ev
+				mchan <- m
+			}
+			count++
+		case *slack.OutgoingErrorEvent:
+			flog.Debugf("%#v", ev.Error())
+		case *slack.ConnectedEvent:
+			b.channels = ev.Info.Channels
+			b.si = ev.Info
+			b.Users, _ = b.sc.GetUsers()
+		case *slack.InvalidAuthEvent:
+			flog.Fatalf("Invalid Token %#v", ev)
+		default:
 		}
 	}
-	return &params
 }
 
-func (b *Bslack) createAttach(extra map[string][]interface{}) []slack.Attachment {
+func (b *Bslack) handleMatterHook(mchan chan *MMMessage) {
-	var attachements []slack.Attachment
+	for {
-	for _, v := range extra["attachments"] {
+		message := b.mh.Receive()
-		entry := v.(map[string]interface{})
+		flog.Debugf("receiving from matterhook (slack) %#v", message)
-		s := slack.Attachment{
+		m := &MMMessage{}
-			Fallback:   extractStringField(entry, "fallback"),
+		m.Username = message.UserName
-			Color:      extractStringField(entry, "color"),
+		m.Text = message.Text
-			Pretext:    extractStringField(entry, "pretext"),
+		m.Channel = message.ChannelName
-			AuthorName: extractStringField(entry, "author_name"),
+		mchan <- m
-			AuthorLink: extractStringField(entry, "author_link"),
-			AuthorIcon: extractStringField(entry, "author_icon"),
-			Title:      extractStringField(entry, "title"),
-			TitleLink:  extractStringField(entry, "title_link"),
-			Text:       extractStringField(entry, "text"),
-			ImageURL:   extractStringField(entry, "image_url"),
-			ThumbURL:   extractStringField(entry, "thumb_url"),
-			Footer:     extractStringField(entry, "footer"),
-			FooterIcon: extractStringField(entry, "footer_icon"),
-		}
-		attachements = append(attachements, s)
 	}
-	return attachements
-}
-
-func extractStringField(data map[string]interface{}, field string) string {
-	if rawValue, found := data[field]; found {
-		if value, ok := rawValue.(string); ok {
-			return value
-		}
-	}
-	return ""
 }

bridge/sshchat/sshchat.go

@@ -1,141 +0,0 @@
-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.EventMsgDelete {
-		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

@@ -1,180 +0,0 @@
-package bsteam
-
-import (
-	"fmt"
-	"strconv"
-	"sync"
-	"time"
-
-	"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"
-)
-
-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.EventMsgDelete {
-		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)
-		default:
-			b.Log.Debugf("unknown event %#v", e)
-		}
-	}
-}

bridge/telegram/html.go

@@ -1,69 +0,0 @@
-package btelegram
-
-import (
-	"bytes"
-	"html"
-	"io"
-
-	"github.com/russross/blackfriday"
-)
-
-type customHTML struct {
-	blackfriday.Renderer
-}
-
-func (options *customHTML) Paragraph(out *bytes.Buffer, text func() bool) {
-	marker := out.Len()
-
-	if !text() {
-		out.Truncate(marker)
-		return
-	}
-	out.WriteString("\n")
-}
-
-func (options *customHTML) BlockCode(out *bytes.Buffer, text []byte, lang string) {
-	out.WriteString("<pre>")
-
-	out.WriteString(html.EscapeString(string(text)))
-	out.WriteString("</pre>\n")
-}
-
-func (options *customHTML) Header(out *bytes.Buffer, text func() bool, level int, id string) {
-	options.Paragraph(out, text)
-}
-
-func (options *customHTML) HRule(out io.ByteWriter) {
-	out.WriteByte('\n')
-}
-
-func (options *customHTML) BlockQuote(out *bytes.Buffer, text []byte) {
-	out.WriteString("> ")
-	out.Write(text)
-	out.WriteByte('\n')
-}
-
-func (options *customHTML) List(out *bytes.Buffer, text func() bool, flags int) {
-	options.Paragraph(out, text)
-}
-
-func (options *customHTML) ListItem(out *bytes.Buffer, text []byte, flags int) {
-	out.WriteString("- ")
-	out.Write(text)
-	out.WriteByte('\n')
-}
-
-func makeHTML(input string) string {
-	extensions := blackfriday.NoIntraEmphasis |
-		blackfriday.FencedCode |
-		blackfriday.Autolink |
-		blackfriday.SpaceHeadings |
-		blackfriday.HeadingIDs |
-		blackfriday.BackslashLineBreak |
-		blackfriday.DefinitionLists
-
-	renderer := &customHTML{blackfriday.NewHTMLRenderer(blackfriday.HTMLRendererParameters{
-		Flags: blackfriday.UseXHTML | blackfriday.SkipImages,
-	})}
-	return string(blackfriday.Run([]byte(input), blackfriday.WithExtensions(extensions), blackfriday.WithRenderer(renderer)))
-}

bridge/telegram/telegram.go

@@ -1,450 +0,0 @@
-package btelegram
-
-import (
-	"html"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/go-telegram-bot-api/telegram-bot-api"
-)
-
-const (
-	unknownUser = "unknown"
-	HTMLFormat  = "HTML"
-	HTMLNick    = "htmlnick"
-)
-
-type Btelegram struct {
-	c *tgbotapi.BotAPI
-	*bridge.Config
-	avatarMap map[string]string // keep cache of userid and avatar sha
-}
-
-func New(cfg *bridge.Config) bridge.Bridger {
-	return &Btelegram{Config: cfg, avatarMap: make(map[string]string)}
-}
-
-func (b *Btelegram) Connect() error {
-	var err error
-	b.Log.Info("Connecting")
-	b.c, err = tgbotapi.NewBotAPI(b.GetString("Token"))
-	if err != nil {
-		b.Log.Debugf("%#v", err)
-		return err
-	}
-	u := tgbotapi.NewUpdate(0)
-	u.Timeout = 60
-	updates, err := b.c.GetUpdatesChan(u)
-	if err != nil {
-		b.Log.Debugf("%#v", err)
-		return err
-	}
-	b.Log.Info("Connection succeeded")
-	go b.handleRecv(updates)
-	return nil
-}
-
-func (b *Btelegram) Disconnect() error {
-	return nil
-}
-
-func (b *Btelegram) JoinChannel(channel config.ChannelInfo) error {
-	return nil
-}
-
-func (b *Btelegram) Send(msg config.Message) (string, error) {
-	b.Log.Debugf("=> Receiving %#v", msg)
-
-	// get the chatid
-	chatid, err := strconv.ParseInt(msg.Channel, 10, 64)
-	if err != nil {
-		return "", err
-	}
-
-	// map the file SHA to our user (caches the avatar)
-	if msg.Event == config.EventAvatarDownload {
-		return b.cacheAvatar(&msg)
-	}
-
-	if b.GetString("MessageFormat") == HTMLFormat {
-		msg.Text = makeHTML(msg.Text)
-	}
-
-	// Delete message
-	if msg.Event == config.EventMsgDelete {
-		if msg.ID == "" {
-			return "", nil
-		}
-		msgid, err := strconv.Atoi(msg.ID)
-		if err != nil {
-			return "", err
-		}
-		_, err = b.c.DeleteMessage(tgbotapi.DeleteMessageConfig{ChatID: chatid, MessageID: msgid})
-		return "", err
-	}
-
-	// Upload a file if it exists
-	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			b.sendMessage(chatid, rmsg.Username, rmsg.Text)
-		}
-		// check if we have files to upload (from slack, telegram or mattermost)
-		if len(msg.Extra["file"]) > 0 {
-			b.handleUploadFile(&msg, chatid)
-		}
-	}
-
-	// edit the message if we have a msg ID
-	if msg.ID != "" {
-		msgid, err := strconv.Atoi(msg.ID)
-		if err != nil {
-			return "", err
-		}
-		if strings.ToLower(b.GetString("MessageFormat")) == HTMLNick {
-			b.Log.Debug("Using mode HTML - nick only")
-			msg.Text = html.EscapeString(msg.Text)
-		}
-		m := tgbotapi.NewEditMessageText(chatid, msgid, msg.Username+msg.Text)
-		if b.GetString("MessageFormat") == HTMLFormat {
-			b.Log.Debug("Using mode HTML")
-			m.ParseMode = tgbotapi.ModeHTML
-		}
-		if b.GetString("MessageFormat") == "Markdown" {
-			b.Log.Debug("Using mode markdown")
-			m.ParseMode = tgbotapi.ModeMarkdown
-		}
-		if strings.ToLower(b.GetString("MessageFormat")) == HTMLNick {
-			b.Log.Debug("Using mode HTML - nick only")
-			m.ParseMode = tgbotapi.ModeHTML
-		}
-		_, err = b.c.Send(m)
-		if err != nil {
-			return "", err
-		}
-		return "", nil
-	}
-
-	// Post normal message
-	return b.sendMessage(chatid, msg.Username, msg.Text)
-}
-
-func (b *Btelegram) handleRecv(updates <-chan tgbotapi.Update) {
-	for update := range updates {
-		b.Log.Debugf("== Receiving event: %#v", update.Message)
-
-		if update.Message == nil && update.ChannelPost == nil && update.EditedMessage == nil && update.EditedChannelPost == nil {
-			b.Log.Error("Getting nil messages, this shouldn't happen.")
-			continue
-		}
-
-		var message *tgbotapi.Message
-
-		rmsg := config.Message{Account: b.Account, Extra: make(map[string][]interface{})}
-
-		// handle channels
-		if update.ChannelPost != nil {
-			message = update.ChannelPost
-			rmsg.Text = message.Text
-		}
-
-		// edited channel message
-		if update.EditedChannelPost != nil && !b.GetBool("EditDisable") {
-			message = update.EditedChannelPost
-			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
-		}
-
-		// handle groups
-		if update.Message != nil {
-			message = update.Message
-			rmsg.Text = message.Text
-		}
-
-		// edited group message
-		if update.EditedMessage != nil && !b.GetBool("EditDisable") {
-			message = update.EditedMessage
-			rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
-		}
-
-		// set the ID's from the channel or group message
-		rmsg.ID = strconv.Itoa(message.MessageID)
-		rmsg.Channel = strconv.FormatInt(message.Chat.ID, 10)
-
-		// handle username
-		if message.From != nil {
-			rmsg.UserID = strconv.Itoa(message.From.ID)
-			if b.GetBool("UseFirstName") {
-				rmsg.Username = message.From.FirstName
-			}
-			if rmsg.Username == "" {
-				rmsg.Username = message.From.UserName
-				if rmsg.Username == "" {
-					rmsg.Username = message.From.FirstName
-				}
-			}
-			// only download avatars if we have a place to upload them (configured mediaserver)
-			if b.General.MediaServerUpload != "" {
-				b.handleDownloadAvatar(message.From.ID, rmsg.Channel)
-			}
-		}
-
-		// if we really didn't find a username, set it to unknown
-		if rmsg.Username == "" {
-			rmsg.Username = unknownUser
-		}
-
-		// handle any downloads
-		err := b.handleDownload(message, &rmsg)
-		if err != nil {
-			b.Log.Errorf("download failed: %s", err)
-		}
-
-		// handle forwarded messages
-		if message.ForwardFrom != nil {
-			usernameForward := ""
-			if b.GetBool("UseFirstName") {
-				usernameForward = message.ForwardFrom.FirstName
-			}
-			if usernameForward == "" {
-				usernameForward = message.ForwardFrom.UserName
-				if usernameForward == "" {
-					usernameForward = message.ForwardFrom.FirstName
-				}
-			}
-			if usernameForward == "" {
-				usernameForward = unknownUser
-			}
-			rmsg.Text = "Forwarded from " + usernameForward + ": " + rmsg.Text
-		}
-
-		// quote the previous message
-		if message.ReplyToMessage != nil {
-			usernameReply := ""
-			if message.ReplyToMessage.From != nil {
-				if b.GetBool("UseFirstName") {
-					usernameReply = message.ReplyToMessage.From.FirstName
-				}
-				if usernameReply == "" {
-					usernameReply = message.ReplyToMessage.From.UserName
-					if usernameReply == "" {
-						usernameReply = message.ReplyToMessage.From.FirstName
-					}
-				}
-			}
-			if usernameReply == "" {
-				usernameReply = unknownUser
-			}
-			if !b.GetBool("QuoteDisable") {
-				rmsg.Text = b.handleQuote(rmsg.Text, usernameReply, message.ReplyToMessage.Text)
-			}
-		}
-
-		if rmsg.Text != "" || len(rmsg.Extra) > 0 {
-			rmsg.Text = helper.RemoveEmptyNewLines(rmsg.Text)
-			// channels don't have (always?) user information. see #410
-			if message.From != nil {
-				rmsg.Avatar = helper.GetAvatar(b.avatarMap, strconv.Itoa(message.From.ID), b.General)
-			}
-
-			b.Log.Debugf("<= Sending message from %s on %s to gateway", rmsg.Username, b.Account)
-			b.Log.Debugf("<= Message is %#v", rmsg)
-			b.Remote <- rmsg
-		}
-	}
-}
-
-func (b *Btelegram) getFileDirectURL(id string) string {
-	res, err := b.c.GetFileDirectURL(id)
-	if err != nil {
-		return ""
-	}
-	return res
-}
-
-// handleDownloadAvatar downloads the avatar of userid from channel
-// sends a EVENT_AVATAR_DOWNLOAD message to the gateway if successful.
-// logs an error message if it fails
-func (b *Btelegram) handleDownloadAvatar(userid int, channel string) {
-	rmsg := config.Message{Username: "system", Text: "avatar", Channel: channel, Account: b.Account, UserID: strconv.Itoa(userid), Event: config.EventAvatarDownload, 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 += ".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 += ".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 += 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{
-			Name:  fi.Name,
-			Bytes: *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") == HTMLFormat {
-		b.Log.Debug("Using mode HTML")
-		m.ParseMode = tgbotapi.ModeHTML
-	}
-	if b.GetString("MessageFormat") == "Markdown" {
-		b.Log.Debug("Using mode markdown")
-		m.ParseMode = tgbotapi.ModeMarkdown
-	}
-	if strings.ToLower(b.GetString("MessageFormat")) == HTMLNick {
-		b.Log.Debug("Using mode HTML - nick only")
-		m.Text = username + html.EscapeString(text)
-		m.ParseMode = tgbotapi.ModeHTML
-	}
-	res, err := b.c.Send(m)
-	if err != nil {
-		return "", err
-	}
-	return strconv.Itoa(res.MessageID), nil
-}
-
-func (b *Btelegram) cacheAvatar(msg *config.Message) (string, error) {
-	fi := msg.Extra["file"][0].(config.FileInfo)
-	/* if we have a sha we have successfully uploaded the file to the media server,
-	so we can now cache the sha */
-	if fi.SHA != "" {
-		b.Log.Debugf("Added %s to %s in avatarMap", fi.SHA, msg.UserID)
-		b.avatarMap[msg.UserID] = fi.SHA
-	}
-	return "", nil
-}
-
-func (b *Btelegram) handleQuote(message, quoteNick, quoteMessage string) string {
-	format := b.GetString("quoteformat")
-	if format == "" {
-		format = "{MESSAGE} (re @{QUOTENICK}: {QUOTEMESSAGE})"
-	}
-	format = strings.Replace(format, "{MESSAGE}", message, -1)
-	format = strings.Replace(format, "{QUOTENICK}", quoteNick, -1)
-	format = strings.Replace(format, "{QUOTEMESSAGE}", quoteMessage, -1)
-	return format
-}

bridge/xmpp/xmpp.go

@@ -1,160 +1,115 @@
 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
+	xc       *xmpp.Client
-	xmppMap map[string]string
+	xmppMap  map[string]string
-	*bridge.Config
+	Config   *config.Protocol
+	origin   string
+	protocol string
+	Remote   chan config.Message
 }
 
-func New(cfg *bridge.Config) bridge.Bridger {
+var flog *log.Entry
-	b := &Bxmpp{Config: cfg}
+var protocol = "xmpp"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, origin string, c chan config.Message) *Bxmpp {
+	b := &Bxmpp{}
 	b.xmppMap = make(map[string]string)
+	b.Config = &cfg
+	b.protocol = protocol
+	b.origin = origin
+	b.Remote = c
 	return b
 }
 
 func (b *Bxmpp) Connect() error {
 	var err error
-	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	flog.Infof("Connecting %s", b.Config.Server)
 	b.xc, err = b.createXMPP()
 	if err != nil {
-		b.Log.Debugf("%#v", err)
+		flog.Debugf("%#v", err)
 		return err
 	}
-	b.Log.Info("Connection succeeded")
+	flog.Info("Connection succeeded")
-	go func() {
+	go b.handleXmpp()
-		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.EventRejoinChannels}
-				b.handleXMPP()
-				bf.Reset()
-			}
-		}
-	}()
 	return nil
 }
 
-func (b *Bxmpp) Disconnect() error {
+func (b *Bxmpp) FullOrigin() string {
+	return b.protocol + "." + b.origin
+}
+
+func (b *Bxmpp) JoinChannel(channel string) error {
+	b.xc.JoinMUCNoHistory(channel+"@"+b.Config.Muc, b.Config.Nick)
 	return nil
 }
 
-func (b *Bxmpp) JoinChannel(channel config.ChannelInfo) error {
+func (b *Bxmpp) Name() string {
-	if channel.Options.Key != "" {
+	return b.protocol + "." + b.origin
-		b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
-		b.xc.JoinProtectedMUC(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"), channel.Options.Key, xmpp.NoHistory, 0, nil)
-	} else {
-		b.xc.JoinMUCNoHistory(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"))
-	}
-	return nil
 }
 
-func (b *Bxmpp) Send(msg config.Message) (string, error) {
+func (b *Bxmpp) Protocol() string {
-	// ignore delete messages
+	return b.protocol
-	if msg.Event == config.EventMsgDelete {
+}
-		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)
+func (b *Bxmpp) Origin() string {
-	if msg.Extra != nil {
+	return b.origin
-		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)
-		}
-	}
 
-	var msgreplaceid string
+func (b *Bxmpp) Send(msg config.Message) error {
-	msgid := xid.New().String()
+	flog.Debugf("Receiving %#v", msg)
-	if msg.ID != "" {
+	nick := config.GetNick(&msg, b.Config)
-		msgid = msg.ID
+	b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.Config.Muc, Text: nick + msg.Text})
-		msgreplaceid = msg.ID
+	return nil
-	}
-	// Post normal message
-	_, err := b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Text: msg.Username + msg.Text, ID: msgid, ReplaceID: msgreplaceid})
-	if err != nil {
-		return "", err
-	}
-	return msgid, nil
 }
 
 func (b *Bxmpp) createXMPP() (*xmpp.Client, error) {
-	tc := new(tls.Config)
-	tc.InsecureSkipVerify = b.GetBool("SkipTLSVerify")
-	tc.ServerName = strings.Split(b.GetString("Server"), ":")[0]
 	options := xmpp.Options{
-		Host:                         b.GetString("Server"),
+		Host:     b.Config.Server,
-		User:                         b.GetString("Jid"),
+		User:     b.Config.Jid,
-		Password:                     b.GetString("Password"),
+		Password: b.Config.Password,
-		NoTLS:                        true,
+		NoTLS:    true,
-		StartTLS:                     true,
+		StartTLS: true,
-		TLSConfig:                    tc,
+		//StartTLS:      false,
-		Debug:                        b.GetBool("debug"),
+		Debug:                        true,
-		Logger:                       b.Log.Writer(),
 		Session:                      true,
 		Status:                       "",
 		StatusMessage:                "",
 		Resource:                     "",
 		InsecureAllowUnencryptedAuth: false,
+		//InsecureAllowUnencryptedAuth: true,
 	}
 	var err error
 	b.xc, err = options.NewClient()
 	return b.xc, err
 }
 
-func (b *Bxmpp) xmppKeepAlive() chan bool {
+func (b *Bxmpp) xmppKeepAlive() {
-	done := make(chan bool)
 	go func() {
 		ticker := time.NewTicker(90 * time.Second)
-		defer ticker.Stop()
 		for {
 			select {
 			case <-ticker.C:
-				b.Log.Debugf("PING")
+				b.xc.Send(xmpp.Chat{})
-				err := b.xc.PingC2S("", "")
-				if err != nil {
-					b.Log.Debugf("PING failed %#v", err)
-				}
-			case <-done:
-				return
 			}
 		}
 	}()
-	return done
 }
 
-func (b *Bxmpp) handleXMPP() error {
+func (b *Bxmpp) handleXmpp() error {
-	var ok bool
-	var msgid string
-	done := b.xmppKeepAlive()
-	defer close(done)
 	for {
 		m, err := b.xc.Recv()
 		if err != nil {
@@ -162,104 +117,23 @@ func (b *Bxmpp) handleXMPP() error {
 		}
 		switch v := m.(type) {
 		case xmpp.Chat:
+			var channel, nick string
 			if v.Type == "groupchat" {
-				b.Log.Debugf("== Receiving %#v", v)
+				s := strings.Split(v.Remote, "@")
-				// skip invalid messages
+				if len(s) == 2 {
-				if b.skipMessage(v) {
+					channel = s[0]
-					continue
 				}
-				msgid = v.ID
+				s = strings.Split(s[1], "/")
-				if v.ReplaceID != "" {
+				if len(s) == 2 {
-					msgid = v.ReplaceID
+					nick = s[1]
 				}
-				rmsg := config.Message{Username: b.parseNick(v.Remote), Text: v.Text, Channel: b.parseChannel(v.Remote), Account: b.Account, UserID: v.Remote, ID: msgid}
+				if nick != b.Config.Nick {
-
+					flog.Debugf("Sending message from %s on %s to gateway", nick, b.FullOrigin())
-				// check if we have an action event
+					b.Remote <- config.Message{Username: nick, Text: v.Text, Channel: channel, Origin: b.origin, Protocol: b.protocol, FullOrigin: b.FullOrigin()}
-				rmsg.Text, ok = b.replaceAction(rmsg.Text)
-				if ok {
-					rmsg.Event = config.EventUserAction
 				}
-				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

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

ci/bintray.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-go version | grep go1.11 || 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

@@ -1,11 +0,0 @@
-[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

@@ -1,11 +0,0 @@
-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,567 +1,151 @@
 package gateway
 
 import (
-	"bytes"
-	"crypto/sha1"
 	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
-
 	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/api"
 	"github.com/42wim/matterbridge/bridge/config"
-	bdiscord "github.com/42wim/matterbridge/bridge/discord"
+	log "github.com/Sirupsen/logrus"
-	bgitter "github.com/42wim/matterbridge/bridge/gitter"
+	"reflect"
-	birc "github.com/42wim/matterbridge/bridge/irc"
+	"strings"
-	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"
-	"github.com/peterhellberg/emojilib"
-	log "github.com/sirupsen/logrus"
 )
 
 type Gateway struct {
-	config.Config
+	*config.Config
-
+	MyConfig    *config.Gateway
-	Router         *Router
+	Bridges     []bridge.Bridge
-	MyConfig       *config.Gateway
+	ChannelsOut map[string][]string
-	Bridges        map[string]*bridge.Bridge
+	ChannelsIn  map[string][]string
-	Channels       map[string]*config.ChannelInfo
+	ignoreNicks map[string][]string
-	ChannelOptions map[string]config.ChannelOptions
+	Name        string
-	Message        chan config.Message
-	Name           string
-	Messages       *lru.Cache
 }
 
-type BrMsgID struct {
+func New(cfg *config.Config, gateway *config.Gateway) error {
-	br        *bridge.Bridge
+	c := make(chan config.Message)
-	ID        string
+	gw := &Gateway{}
-	ChannelID string
+	gw.Name = gateway.Name
-}
+	gw.Config = cfg
-
+	gw.MyConfig = gateway
-var flog *log.Entry
+	exists := make(map[string]bool)
-
+	for _, br := range append(gateway.In, gateway.Out...) {
-var bridgeMap = map[string]bridge.Factory{
+		if exists[br.Account] {
-	"api":          api.New,
+			continue
-	"discord":      bdiscord.New,
-	"gitter":       bgitter.New,
-	"irc":          birc.New,
-	"mattermost":   bmattermost.New,
-	"matrix":       bmatrix.New,
-	"rocketchat":   brocketchat.New,
-	"slack-legacy": bslack.NewLegacy,
-	"slack":        bslack.New,
-	"sshchat":      bsshchat.New,
-	"steam":        bsteam.New,
-	"telegram":     btelegram.New,
-	"xmpp":         bxmpp.New,
-	"zulip":        bzulip.New,
-}
-
-const (
-	apiProtocol = "api"
-)
-
-func New(cfg config.Gateway, r *Router) *Gateway {
-	flog = log.WithFields(log.Fields{"prefix": "gateway"})
-	gw := &Gateway{Channels: make(map[string]*config.ChannelInfo), Message: r.Message,
-		Router: r, Bridges: make(map[string]*bridge.Bridge), Config: r.Config}
-	cache, _ := lru.New(5000)
-	gw.Messages = cache
-	gw.AddConfig(&cfg)
-	return gw
-}
-
-// Find the canonical ID that the message is keyed under in cache
-func (gw *Gateway) FindCanonicalMsgID(protocol string, mID string) string {
-	ID := protocol + " " + mID
-	if gw.Messages.Contains(ID) {
-		return mID
-	}
-
-	// If not keyed, iterate through cache for downstream, and infer upstream.
-	for _, mid := range gw.Messages.Keys() {
-		v, _ := gw.Messages.Peek(mid)
-		ids := v.([]*BrMsgID)
-		for _, downstreamMsgObj := range ids {
-			if ID == downstreamMsgObj.ID {
-				return strings.Replace(mid.(string), protocol+" ", "", 1)
-			}
 		}
+		log.Infof("Starting bridge: %s channel: %s", br.Account, br.Channel)
+		gw.Bridges = append(gw.Bridges, bridge.New(cfg, &br, c))
+		exists[br.Account] = true
 	}
-	return ""
-}
-
-func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
-	br := gw.Router.getBridge(cfg.Account)
-	if br == nil {
-		br = bridge.New(cfg)
-		br.Config = gw.Router.Config
-		br.General = &gw.BridgeValues().General
-		// set logging
-		br.Log = log.WithFields(log.Fields{"prefix": "bridge"})
-		brconfig := &bridge.Config{Remote: gw.Message, Log: log.WithFields(log.Fields{"prefix": br.Protocol}), Bridge: br}
-		// add the actual bridger for this protocol to this bridge using the bridgeMap
-		br.Bridger = bridgeMap[br.Protocol](brconfig)
-	}
-	gw.mapChannelsToBridge(br)
-	gw.Bridges[cfg.Account] = br
-	return nil
-}
-
-func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
-	gw.Name = cfg.Name
-	gw.MyConfig = cfg
 	gw.mapChannels()
-	for _, br := range append(gw.MyConfig.In, append(gw.MyConfig.InOut, gw.MyConfig.Out...)...) {
+	//TODO fix mapIgnores
-		br := br //scopelint
+	//gw.mapIgnores()
-		err := gw.AddBridge(&br)
+	exists = make(map[string]bool)
+	for _, br := range gw.Bridges {
+		err := br.Connect()
 		if err != nil {
-			return err
+			log.Fatalf("Bridge %s failed to start: %v", br.FullOrigin(), err)
+		}
+		for _, channel := range append(gw.ChannelsOut[br.FullOrigin()], gw.ChannelsIn[br.FullOrigin()]...) {
+			if exists[br.FullOrigin()+channel] {
+				continue
+			}
+			log.Infof("%s: joining %s", br.FullOrigin(), channel)
+			br.JoinChannel(channel)
+			exists[br.FullOrigin()+channel] = true
 		}
 	}
+	gw.handleReceive(c)
 	return nil
 }
 
-func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
+func (gw *Gateway) handleReceive(c chan config.Message) {
-	for ID, channel := range gw.Channels {
+	for {
-		if br.Account == channel.Account {
+		select {
-			br.Channels[ID] = *channel
+		case msg := <-c:
-		}
+			for _, br := range gw.Bridges {
-	}
+				gw.handleMessage(msg, br)
-}
-
-func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
-	br.Disconnect()
-	time.Sleep(time.Second * 5)
-RECONNECT:
-	flog.Infof("Reconnecting %s", br.Account)
-	err := br.Connect()
-	if err != nil {
-		flog.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
-		time.Sleep(time.Second * 60)
-		goto RECONNECT
-	}
-	br.Joined = make(map[string]bool)
-	br.JoinChannels()
-}
-
-func (gw *Gateway) mapChannelConfig(cfg []config.Bridge, direction string) {
-	for _, br := range cfg {
-		if isAPI(br.Account) {
-			br.Channel = apiProtocol
-		}
-		// make sure to lowercase irc channels in config #348
-		if strings.HasPrefix(br.Account, "irc.") {
-			br.Channel = strings.ToLower(br.Channel)
-		}
-		ID := br.Channel + br.Account
-		if _, ok := gw.Channels[ID]; !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: direction, ID: ID, Options: br.Options, Account: br.Account,
-				SameChannel: make(map[string]bool)}
-			channel.SameChannel[gw.Name] = br.SameChannel
-			gw.Channels[channel.ID] = channel
-		} else {
-			// if we already have a key and it's not our current direction it means we have a bidirectional inout
-			if gw.Channels[ID].Direction != direction {
-				gw.Channels[ID].Direction = "inout"
 			}
 		}
-		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
 	}
 }
 
 func (gw *Gateway) mapChannels() error {
-	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	m := make(map[string][]string)
-	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	for _, br := range gw.MyConfig.Out {
-	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
+		m[br.Account] = append(m[br.Account], br.Channel)
+	}
+	gw.ChannelsOut = m
+	m = nil
+	m = make(map[string][]string)
+	for _, br := range gw.MyConfig.In {
+		m[br.Account] = append(m[br.Account], br.Channel)
+	}
+	gw.ChannelsIn = m
 	return nil
 }
 
-func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
+func (gw *Gateway) mapIgnores() {
-	var channels []config.ChannelInfo
+	m := make(map[string][]string)
-
+	for _, br := range gw.MyConfig.In {
-	// for messages received from the api check that the gateway is the specified one
+		accInfo := strings.Split(br.Account, ".")
-	if msg.Protocol == apiProtocol && gw.Name != msg.Gateway {
+		m[br.Account] = strings.Fields(gw.Config.IRC[accInfo[1]].IgnoreNicks)
-		return channels
 	}
-
+	gw.ignoreNicks = m
-	// if source channel is in only, do nothing
-	for _, channel := range gw.Channels {
-		// lookup the channel from the message
-		if channel.ID == getChannelID(*msg) {
-			// we only have destinations if the original message is from an "in" (sending) channel
-			if !strings.Contains(channel.Direction, "in") {
-				return channels
-			}
-			continue
-		}
-	}
-	for _, channel := range gw.Channels {
-		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
-			continue
-		}
-
-		// do samechannelgateway flogic
-		if channel.SameChannel[msg.Gateway] {
-			if msg.Channel == channel.Name && msg.Account != dest.Account {
-				channels = append(channels, *channel)
-			}
-			continue
-		}
-		if strings.Contains(channel.Direction, "out") && channel.Account == dest.Account && gw.validGatewayDest(msg) {
-			channels = append(channels, *channel)
-		}
-	}
-	return channels
 }
 
-func (gw *Gateway) getDestMsgID(msgID string, dest *bridge.Bridge, channel config.ChannelInfo) string {
+func (gw *Gateway) getDestChannel(msg *config.Message, dest string) []string {
-	if res, ok := gw.Messages.Get(msgID); ok {
+	channels := gw.ChannelsIn[msg.FullOrigin]
-		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 {
-				return strings.Replace(id.ID, dest.Protocol+" ", "", 1)
-			}
-		}
-	}
-	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.EventFileFailureSize]) != 0 {
-			if msg.Text == "" {
-				return brMsgIDs
-			}
-		}
-	}
-
-	// Avatar downloads are only relevant for telegram and mattermost for now
-	if msg.Event == config.EventAvatarDownload {
-		if dest.Protocol != "mattermost" &&
-			dest.Protocol != "telegram" {
-			return brMsgIDs
-		}
-	}
-
-	// only relay join/part when configured
-	if msg.Event == config.EventJoinLeave && !gw.Bridges[dest.Account].GetBool("ShowJoinPart") {
-		return brMsgIDs
-	}
-
-	// only relay topic change when configured
-	if msg.Event == config.EventTopicChange && !gw.Bridges[dest.Account].GetBool("ShowTopicChange") {
-		return brMsgIDs
-	}
-
-	// broadcast to every out channel (irc QUIT)
-	if msg.Channel == "" && msg.Event != config.EventJoinLeave {
-		flog.Debug("empty channel")
-		return brMsgIDs
-	}
-
-	// Get the ID of the parent message in thread
-	var canonicalParentMsgID string
-	if msg.ParentID != "" && (gw.BridgeValues().General.PreserveThreading || dest.GetBool("PreserveThreading")) {
-		canonicalParentMsgID = gw.FindCanonicalMsgID(msg.Protocol, msg.ParentID)
-	}
-
-	originchannel := msg.Channel
-	origmsg := msg
-	channels := gw.getDestChannel(&msg, *dest)
 	for _, channel := range channels {
-		// Only send the avatar download event to ourselves.
+		if channel == msg.Channel {
-		if msg.Event == config.EventAvatarDownload {
+			return gw.ChannelsOut[dest]
-			if channel.ID != getChannelID(origmsg) {
+		}
-				continue
+	}
-			}
+	return []string{}
-		} else {
+}
-			// do not send to ourself for any other event
+
-			if channel.ID == getChannelID(origmsg) {
+func (gw *Gateway) handleMessage(msg config.Message, dest bridge.Bridge) {
-				continue
+	if gw.ignoreMessage(&msg) {
-			}
+		return
-		}
+	}
-
+	originchannel := msg.Channel
-		// Too noisy to log like other events
+	channels := gw.getDestChannel(&msg, dest.FullOrigin())
-		if msg.Event != config.EventUserTyping {
+	for _, channel := range channels {
-			flog.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel.Name)
+		// do not send the message to the bridge we come from if also the channel is the same
-		}
+		if msg.FullOrigin == dest.FullOrigin() && channel == originchannel {
-
+			continue
-		msg.Channel = channel.Name
+		}
-		msg.Avatar = gw.modifyAvatar(origmsg, dest)
+		msg.Channel = channel
-		msg.Username = gw.modifyUsername(origmsg, dest)
+		if msg.Channel == "" {
-
+			log.Debug("empty channel")
-		msg.ID = gw.getDestMsgID(origmsg.Protocol+" "+origmsg.ID, dest, channel)
+			return
-
+		}
-		// for api we need originchannel as channel
+		log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.FullOrigin, originchannel, dest.FullOrigin(), channel)
-		if dest.Protocol == apiProtocol {
+		err := dest.Send(msg)
-			msg.Channel = originchannel
+		if err != nil {
-		}
+			fmt.Println(err)
-
-		msg.ParentID = gw.getDestMsgID(origmsg.Protocol+" "+canonicalParentMsgID, dest, channel)
-		if msg.ParentID == "" {
-			msg.ParentID = canonicalParentMsgID
-		}
-
-		// if we are using mattermost plugin account, send messages to MattermostPlugin channel
-		// that can be picked up by the mattermost matterbridge plugin
-		if dest.Account == "mattermost.plugin" {
-			gw.Router.MattermostPlugin <- msg
-		}
-
-		mID, err := dest.Send(msg)
-		if err != nil {
-			flog.Error(err)
-		}
-
-		// append the message ID (mID) from this bridge (dest) to our brMsgIDs slice
-		if mID != "" {
-			flog.Debugf("mID %s: %s", dest.Account, mID)
-			brMsgIDs = append(brMsgIDs, &BrMsgID{dest, dest.Protocol + " " + mID, channel.ID})
 		}
 	}
-	return brMsgIDs
 }
 
 func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
-	// if we don't have the bridge, ignore it
+	// should we discard messages ?
-	if _, ok := gw.Bridges[msg.Account]; !ok {
+	for _, entry := range gw.ignoreNicks[msg.FullOrigin] {
-		return true
-	}
-
-	// check if we need to ignore a empty message
-	if msg.Text == "" {
-		if msg.Event == config.EventUserTyping {
-			return false
-		}
-		// 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.EventFileFailureSize]) > 0) {
-			return false
-		}
-		flog.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
-		return true
-	}
-
-	// is the username in IgnoreNicks field
-	for _, entry := range strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreNicks")) {
 		if msg.Username == entry {
-			flog.Debugf("ignoring %s from %s", msg.Username, msg.Account)
 			return true
 		}
 	}
-
-	// does the message match regex in IgnoreMessages field
-	// TODO do not compile regexps everytime
-	for _, entry := range strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreMessages")) {
-		if entry != "" {
-			re, err := regexp.Compile(entry)
-			if err != nil {
-				flog.Errorf("incorrect regexp %s for %s", entry, msg.Account)
-				continue
-			}
-			if re.MatchString(msg.Text) {
-				flog.Debugf("matching %s. ignoring %s from %s", entry, msg.Text, msg.Account)
-				return true
-			}
-		}
-	}
 	return false
 }
 
-func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) string {
+func (gw *Gateway) modifyMessage(msg *config.Message, dest bridge.Bridge) {
-	br := gw.Bridges[msg.Account]
+	val := reflect.ValueOf(gw.Config).Elem()
-	msg.Protocol = br.Protocol
+	for i := 0; i < val.NumField(); i++ {
-	if gw.BridgeValues().General.StripNick || dest.GetBool("StripNick") {
+		typeField := val.Type().Field(i)
-		re := regexp.MustCompile("[^a-zA-Z0-9]+")
+		// look for the protocol map (both lowercase)
-		msg.Username = re.ReplaceAllString(msg.Username, "")
+		if strings.ToLower(typeField.Name) == dest.Protocol() {
-	}
+			// get the Protocol struct from the map
-	nick := dest.GetString("RemoteNickFormat")
+			protoCfg := val.Field(i).MapIndex(reflect.ValueOf(dest.Origin()))
-	if nick == "" {
+			//config.SetNickFormat(msg, protoCfg.Interface().(config.Protocol))
-		nick = gw.BridgeValues().General.RemoteNickFormat
+			val.Field(i).SetMapIndex(reflect.ValueOf(dest.Origin()), protoCfg)
-	}
-
-	// loop to replace nicks
-	for _, outer := range br.GetStringSlice2D("ReplaceNicks") {
-		search := outer[0]
-		replace := outer[1]
-		// TODO move compile to bridge init somewhere
-		re, err := regexp.Compile(search)
-		if err != nil {
-			flog.Errorf("regexp in %s failed: %s", msg.Account, err)
 			break
 		}
-		msg.Username = re.ReplaceAllString(msg.Username, replace)
-	}
-
-	if len(msg.Username) > 0 {
-		// fix utf-8 issue #193
-		i := 0
-		for index := range msg.Username {
-			if i == 1 {
-				i = index
-				break
-			}
-			i++
-		}
-		nick = strings.Replace(nick, "{NOPINGNICK}", msg.Username[:i]+"​"+msg.Username[i:], -1)
-	}
-
-	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
-	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
-	nick = strings.Replace(nick, "{GATEWAY}", gw.Name, -1)
-	nick = strings.Replace(nick, "{LABEL}", br.GetString("Label"), -1)
-	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
-	nick = strings.Replace(nick, "{CHANNEL}", msg.Channel, -1)
-	return nick
-}
-
-func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string {
-	iconurl := gw.BridgeValues().General.IconURL
-	if iconurl == "" {
-		iconurl = dest.GetString("IconURL")
-	}
-	iconurl = strings.Replace(iconurl, "{NICK}", msg.Username, -1)
-	if msg.Avatar == "" {
-		msg.Avatar = iconurl
-	}
-	return msg.Avatar
-}
-
-func (gw *Gateway) modifyMessage(msg *config.Message) {
-	// replace :emoji: to unicode
-	msg.Text = emojilib.Replace(msg.Text)
-
-	br := gw.Bridges[msg.Account]
-	// loop to replace messages
-	for _, outer := range br.GetStringSlice2D("ReplaceMessages") {
-		search := outer[0]
-		replace := outer[1]
-		// TODO move compile to bridge init somewhere
-		re, err := regexp.Compile(search)
-		if err != nil {
-			flog.Errorf("regexp in %s failed: %s", msg.Account, err)
-			break
-		}
-		msg.Text = re.ReplaceAllString(msg.Text, replace)
-	}
-
-	// messages from api have Gateway specified, don't overwrite
-	if msg.Protocol != apiProtocol {
-		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.BridgeValues().General.MediaServerUpload == "" &&
-			gw.BridgeValues().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 += ext
-
-		sha1sum := fmt.Sprintf("%x", sha1.Sum(*fi.Data))[:8]
-
-		if gw.BridgeValues().General.MediaServerUpload != "" {
-			// Use MediaServerUpload. Upload using a PUT HTTP request and basicauth.
-
-			url := gw.BridgeValues().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.BridgeValues().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.BridgeValues().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) bool {
-	return msg.Gateway == gw.Name
-}
-
-func getChannelID(msg config.Message) string {
-	return msg.Channel + msg.Account
-}
-
-func isAPI(account string) bool {
-	return strings.HasPrefix(account, "api.")
-}

gateway/gateway_test.go

@@ -1,388 +0,0 @@
-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"
-`)
-
-const (
-	ircTestAccount   = "irc.zzz"
-	tgTestAccount    = "telegram.zzz"
-	slackTestAccount = "slack.zzz"
-)
-
-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 == ircTestAccount || msg.Account == tgTestAccount || msg.Account == slackTestAccount) {
-						hits[gw.Name]++
-						switch br.Account {
-						case ircTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "#main",
-								Account:     ircTestAccount,
-								Direction:   "inout",
-								ID:          "#mainirc.zzz",
-								SameChannel: map[string]bool{"bridge": false},
-								Options:     config.ChannelOptions{Key: ""},
-							}}, channels)
-						case tgTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "-1111111111111",
-								Account:     tgTestAccount,
-								Direction:   "inout",
-								ID:          "-1111111111111telegram.zzz",
-								SameChannel: map[string]bool{"bridge": false},
-								Options:     config.ChannelOptions{Key: ""},
-							}}, channels)
-						case slackTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "irc",
-								Account:     slackTestAccount,
-								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 == ircTestAccount || msg.Account == tgTestAccount) {
-						hits[gw.Name]++
-						switch br.Account {
-						case ircTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "#main-help",
-								Account:     ircTestAccount,
-								Direction:   "inout",
-								ID:          "#main-helpirc.zzz",
-								SameChannel: map[string]bool{"bridge2": false},
-								Options:     config.ChannelOptions{Key: ""},
-							}}, channels)
-						case tgTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "--444444444444",
-								Account:     tgTestAccount,
-								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 == ircTestAccount || msg.Account == tgTestAccount) {
-						hits[gw.Name]++
-						switch br.Account {
-						case ircTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "#main-telegram",
-								Account:     ircTestAccount,
-								Direction:   "inout",
-								ID:          "#main-telegramirc.zzz",
-								SameChannel: map[string]bool{"bridge3": false},
-								Options:     config.ChannelOptions{Key: ""},
-							}}, channels)
-						case tgTestAccount:
-							assert.Equal(t, []config.ChannelInfo{{
-								Name:        "--333333333333",
-								Account:     tgTestAccount,
-								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 ircTestAccount:
-						assert.Len(t, channels, 2)
-						assert.Contains(t, channels, config.ChannelInfo{
-							Name:        "#main",
-							Account:     ircTestAccount,
-							Direction:   "out",
-							ID:          "#mainirc.zzz",
-							SameChannel: map[string]bool{"announcements": false},
-							Options:     config.ChannelOptions{Key: ""},
-						})
-						assert.Contains(t, channels, config.ChannelInfo{
-							Name:        "#main-help",
-							Account:     ircTestAccount,
-							Direction:   "out",
-							ID:          "#main-helpirc.zzz",
-							SameChannel: map[string]bool{"announcements": false},
-							Options:     config.ChannelOptions{Key: ""},
-						})
-					case slackTestAccount:
-						assert.Equal(t, []config.ChannelInfo{{
-							Name:        "general",
-							Account:     slackTestAccount,
-							Direction:   "out",
-							ID:          "generalslack.zzz",
-							SameChannel: map[string]bool{"announcements": false},
-							Options:     config.ChannelOptions{Key: ""},
-						}}, channels)
-					case tgTestAccount:
-						assert.Equal(t, []config.ChannelInfo{{
-							Name:        "--333333333333",
-							Account:     tgTestAccount,
-							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

@@ -1,118 +0,0 @@
-package gateway
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/config"
-	samechannelgateway "github.com/42wim/matterbridge/gateway/samechannel"
-)
-
-type Router struct {
-	config.Config
-
-	Gateways         map[string]*Gateway
-	Message          chan config.Message
-	MattermostPlugin chan config.Message
-}
-
-func NewRouter(cfg config.Config) (*Router, error) {
-	r := &Router{
-		Config:           cfg,
-		Message:          make(chan config.Message),
-		MattermostPlugin: make(chan config.Message),
-		Gateways:         make(map[string]*Gateway),
-	}
-	sgw := samechannelgateway.New(cfg)
-	gwconfigs := sgw.GetConfig()
-
-	for _, entry := range append(gwconfigs, cfg.BridgeValues().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 {
-		msg := msg // scopelint
-		if msg.Event == config.EventFailure {
-		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.EventRejoinChannels {
-			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.Protocol + " " + msg.ID); !ok && msg.ID != "" {
-					gw.Messages.Add(msg.Protocol+" "+msg.ID, msgIDs)
-				}
-			}
-		}
-	}
-}

gateway/samechannel/samechannel.go

@@ -1,28 +1,103 @@
 package samechannelgateway
 
 import (
+	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"strings"
 )
 
 type SameChannelGateway struct {
-	config.Config
+	*config.Config
+	MyConfig    *config.SameChannelGateway
+	Bridges     []bridge.Bridge
+	Channels    []string
+	ignoreNicks map[string][]string
+	Name        string
 }
 
-func New(cfg config.Config) *SameChannelGateway {
+func New(cfg *config.Config, gateway *config.SameChannelGateway) error {
-	return &SameChannelGateway{Config: cfg}
+	c := make(chan config.Message)
+	gw := &SameChannelGateway{}
+	gw.Name = gateway.Name
+	gw.Config = cfg
+	gw.MyConfig = gateway
+	gw.Channels = gateway.Channels
+	for _, account := range gateway.Accounts {
+		br := config.Bridge{Account: account}
+		log.Infof("Starting bridge: %s", account)
+		gw.Bridges = append(gw.Bridges, bridge.New(cfg, &br, c))
+	}
+	for _, br := range gw.Bridges {
+		err := br.Connect()
+		if err != nil {
+			log.Fatalf("Bridge %s failed to start: %v", br.FullOrigin(), err)
+		}
+		for _, channel := range gw.Channels {
+			log.Infof("%s: joining %s", br.FullOrigin(), channel)
+			br.JoinChannel(channel)
+		}
+	}
+	gw.handleReceive(c)
+	return nil
 }
 
-func (sgw *SameChannelGateway) GetConfig() []config.Gateway {
+func (gw *SameChannelGateway) handleReceive(c chan config.Message) {
-	var gwconfigs []config.Gateway
+	for {
-	cfg := sgw.Config
+		select {
-	for _, gw := range cfg.BridgeValues().SameChannelGateway {
+		case msg := <-c:
-		gwconfig := config.Gateway{Name: gw.Name, Enable: gw.Enable}
+			for _, br := range gw.Bridges {
-		for _, account := range gw.Accounts {
+				gw.handleMessage(msg, br)
-			for _, channel := range gw.Channels {
-				gwconfig.InOut = append(gwconfig.InOut, config.Bridge{Account: account, Channel: channel, SameChannel: true})
 			}
 		}
-		gwconfigs = append(gwconfigs, gwconfig)
 	}
-	return gwconfigs
+}
+
+func (gw *SameChannelGateway) handleMessage(msg config.Message, dest bridge.Bridge) {
+	// is this a configured channel
+	if !gw.validChannel(msg.Channel) {
+		return
+	}
+	// do not send the message to the bridge we come from if also the channel is the same
+	if msg.FullOrigin == dest.FullOrigin() {
+		return
+	}
+	gw.modifyMessage(&msg, dest)
+	log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.FullOrigin, msg.Channel, dest.FullOrigin(), msg.Channel)
+	err := dest.Send(msg)
+	if err != nil {
+		log.Error(err)
+	}
+}
+
+func setNickFormat(msg *config.Message, format string) {
+	if format == "" {
+		msg.Username = msg.Protocol + "." + msg.Origin + "-" + msg.Username + ": "
+		return
+	}
+	msg.Username = strings.Replace(format, "{NICK}", msg.Username, -1)
+	msg.Username = strings.Replace(msg.Username, "{BRIDGE}", msg.Origin, -1)
+	msg.Username = strings.Replace(msg.Username, "{PROTOCOL}", msg.Protocol, -1)
+}
+
+func (gw *SameChannelGateway) modifyMessage(msg *config.Message, dest bridge.Bridge) {
+	switch dest.Protocol() {
+	case "irc":
+		setNickFormat(msg, gw.Config.IRC[dest.Origin()].RemoteNickFormat)
+	case "mattermost":
+		setNickFormat(msg, gw.Config.Mattermost[dest.Origin()].RemoteNickFormat)
+	case "slack":
+		setNickFormat(msg, gw.Config.Slack[dest.Origin()].RemoteNickFormat)
+	case "discord":
+		setNickFormat(msg, gw.Config.Discord[dest.Origin()].RemoteNickFormat)
+	}
+}
+
+func (gw *SameChannelGateway) validChannel(channel string) bool {
+	for _, c := range gw.Channels {
+		if c == channel {
+			return true
+		}
+	}
+	return false
 }

gateway/samechannel/samechannel_test.go

@@ -1,73 +0,0 @@
-package samechannelgateway
-
-import (
-	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/stretchr/testify/assert"
-
-	"testing"
-)
-
-const testConfig = `
-[mattermost.test]
-[slack.test]
-
-[[samechannelgateway]]
-   enable = true
-   name = "blah"
-      accounts = [ "mattermost.test","slack.test" ]
-      channels = [ "testing","testing2","testing10"]
-`
-
-var (
-	expectedConfig = 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,
-			},
-		},
-	}
-)
-
-func TestGetConfig(t *testing.T) {
-	cfg := config.NewConfigFromString([]byte(testConfig))
-	sgw := New(cfg)
-	configs := sgw.GetConfig()
-	assert.Equal(t, []config.Gateway{expectedConfig}, configs)
-}

go.mod

@@ -1,80 +0,0 @@
-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 // indirect
-	github.com/Philipp15b/go-steam v0.0.0-20161020161927-e0f3bb9566e3
-	github.com/alecthomas/log4go v0.0.0-20160307011253-e5dc62318d9b // indirect
-	github.com/bwmarrin/discordgo v0.19.0
-	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 v1.4.0
-	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-20180913221000-0fb5b684054e
-	github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 // indirect
-	github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6 // indirect
-	github.com/magiconair/properties v0.0.0-20180217134545-2c9e95027885 // indirect
-	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.4.0
-	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/rs/xid v0.0.0-20180525034800-088c5cf1423a
-	github.com/russross/blackfriday v2.0.0+incompatible
-	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/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 // indirect
-	github.com/sirupsen/logrus v1.2.0
-	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 v1.2.2
-	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-20181112202954-3d3f9f413869 // 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-20181116161606-93218def8b18 // indirect
-	golang.org/x/text v0.0.0-20180511172408-5c1cf69b5978 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
-	gopkg.in/fsnotify.v1 v1.4.7 // indirect
-	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
-	gopkg.in/yaml.v2 v2.0.0-20160301204022-a83829b6f129 // indirect
-)

go.sum

@@ -1,167 +0,0 @@
-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/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.19.0 h1:kMED/DB0NR1QhRcalb85w0Cu3Ep2OrGAqZH1R5awQiY=
-github.com/bwmarrin/discordgo v0.19.0/go.mod h1:O9S4p+ofTFwB02em7jkpkV8M3R0/PUVOwN61zSZ0r4Q=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-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 v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
-github.com/gorilla/websocket v1.4.0/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/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-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-20180913221000-0fb5b684054e h1:RpktB2igr6nS1EN7bCvjldAEfngrM5GyAbmOa4/cafU=
-github.com/lrstanley/girc v0.0.0-20180913221000-0fb5b684054e/go.mod h1:7cRs1SIBfKQ7e3Tam6GKTILSNHzR862JD0JpINaZoJk=
-github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 h1:AsEBgzv3DhuYHI/GiQh2HxvTP71HCCE9E/tzGUzGdtU=
-github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5/go.mod h1:c2mYKRyMb1BPkO5St0c/ps62L4S0W2NAkaTXj9qEI+0=
-github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6 h1:iOAVXzZyXtW408TMYejlUPo6BIn92HmOacWtIfNyYns=
-github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6/go.mod h1:sFlOUpQL1YcjhFVXhg1CG8ZASEs/Mf1oVb6H75JL/zg=
-github.com/magiconair/properties 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/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.4.0 h1:OVnHm7lv5gGT5gkcHsZAyw++oHVFihbjWbL3UceUpiA=
-github.com/nlopes/slack v0.4.0/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 v2.0.0+incompatible h1:cBXrhZNUf9C+La9/YpS+UHpUT8YD6Td9ZMSU9APFcsk=
-github.com/russross/blackfriday v2.0.0+incompatible/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
-github.com/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/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95 h1:/vdW8Cb7EXrkqWGufVMES1OH2sU9gKVb2n9/1y5NMBY=
-github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-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/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/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-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16 h1:y6ce7gCWtnH+m3dCjzQ1PCuwl28DDIc3VNnvY29DlIA=
-golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20181112202954-3d3f9f413869 h1:kkXA53yGe04D0adEYJwEVQjeBppL01Exg+fnMjfUraU=
-golang.org/x/crypto v0.0.0-20181112202954-3d3f9f413869/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-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116161606-93218def8b18 h1:Wh+XCfg3kNpjhdq2LXrsiOProjtQZKme5XUx7VcxwAw=
-golang.org/x/sys v0.0.0-20181116161606-93218def8b18/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/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/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

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

matterbridge.conf.sample

@@ -0,0 +1,287 @@
+#This is configuration for matterbridge.
+###################################################################
+#IRC section
+###################################################################
+[IRC]
+#Enable enables this bridge
+#OPTIONAL (default false)
+Enable=true
+#irc server to connect to. 
+#REQUIRED
+Server="irc.freenode.net:6667"
+
+#Enable to use TLS connection to your irc server. 
+#OPTIONAL (default false)
+UseTLS=false
+
+#Enable SASL (PLAIN) authentication. (freenode requires this from eg AWS hosts)
+#It uses NickServNick and NickServPassword as login and password
+#OPTIONAL (default false)
+UseSASL=false
+
+#Enable to not verify the certificate on your irc server. i
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#Your nick on irc. 
+#REQUIRED
+Nick="matterbot"
+
+#If you registered your bot with a service like Nickserv on freenode. 
+#Also being used when UseSASL=true
+#OPTIONAL
+NickServNick="nickserv"
+NickServPassword="secret"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#OPTIONAL (default {BRIDGE}-{NICK})
+RemoteNickFormat="[{BRIDGE}] <{NICK}> "
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+###################################################################
+#XMPP section
+###################################################################
+[XMPP]
+#Enable enables this bridge
+#OPTIONAL (default false)
+Enable=true
+
+#xmpp server to connect to. 
+#REQUIRED
+Server="jabber.example.com:5222"
+
+#Jid
+#REQUIRED
+Jid="user@example.com"
+
+#Password
+#REQUIRED
+Password="yourpass"
+
+#MUC
+#REQUIRED
+Muc="conference.jabber.example.com"
+
+#Your nick in the rooms
+#REQUIRED
+Nick="xmppbot"
+
+
+###################################################################
+#mattermost section
+###################################################################
+
+[mattermost]
+#Enable enables this bridge
+#OPTIONAL (default false)
+Enable=true
+
+#### Settings for webhook matterbridge.
+#### These settings will not be used when using -plus switch which doesn't use 
+#### webhooks.
+
+#Url is your incoming webhook url as specified in mattermost. 
+#See account settings - integrations - incoming webhooks on mattermost.
+#REQUIRED
+URL="https://yourdomain/hooks/yourhookkey"
+
+#Address to listen on for outgoing webhook requests from mattermost.
+#See account settings - integrations - outgoing webhooks on mattermost.
+#This setting will not be used when using -plus switch which doesn't use 
+#webhooks
+#REQUIRED
+BindAddress="0.0.0.0:9999"
+
+#Icon that will be showed in mattermost. 
+#OPTIONAL
+IconURL="http://youricon.png"
+
+#### Settings for matterbridge -plus
+#### Thse settings will only be used when using the -plus switch.
+
+#The mattermost hostname. 
+#REQUIRED
+Server="yourmattermostserver.domain"
+
+#Your team on mattermost. 
+#REQUIRED
+Team="yourteam"
+
+#login/pass of your bot. 
+#Use a dedicated user for this and not your own! 
+#REQUIRED
+Login="yourlogin"
+Password="yourpass"
+
+#Enable this to make a http connection (instead of https) to your mattermost. 
+#OPTIONAL (default false)
+NoTLS=false
+
+#### Shared settings for matterbridge and -plus
+
+#Enable to not verify the certificate on your mattermost server. 
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#Enable to show IRC joins/parts in mattermost. 
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+#Whether to prefix messages from other bridges to mattermost with the sender's nick. 
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#mattermost server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to Mattermost will by default be prefixed by "bridge-" + nick. You can, 
+#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#OPTIONAL (default {BRIDGE}-{NICK})
+RemoteNickFormat="[{BRIDGE}] <{NICK}> "
+
+#how to format the list of IRC nicks when displayed in mattermost. 
+#Possible options are "table" and "plain"
+#OPTIONAL (default plain)
+NickFormatter=plain
+#How many nicks to list per row for formatters that support this. 
+#OPTIONAL (default 4)
+NicksPerRow=4
+
+#Nicks you want to ignore. Messages from those users will not be bridged.
+#OPTIONAL 
+IgnoreNicks="mmbot spammer2"
+
+###################################################################
+#Gitter section
+#Best to make a dedicated gitter account for the bot.
+###################################################################
+[Gitter]
+#Enable enables this bridge
+#OPTIONAL (default false)
+Enable=true
+
+#Token to connect with Gitter API
+#You can get your token by going to https://developer.gitter.im/docs/welcome and SIGN IN
+#REQUIRED
+Token="Yourtokenhere"
+
+#Nicks you want to ignore. Messages of those users will not be bridged.
+#OPTIONAL 
+IgnoreNicks="spammer1 spammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#OPTIONAL (default {BRIDGE}-{NICK})
+RemoteNickFormat="[{BRIDGE}] <{NICK}> "
+
+###################################################################
+#slack section
+###################################################################
+
+[slack]
+#Enable enables this bridge
+#OPTIONAL (default false)
+Enable=true
+
+#### Settings for webhook matterbridge.
+#### These settings will not be used when useAPI is enabled
+
+#Url is your incoming webhook url as specified in slack
+#See account settings - integrations - incoming webhooks on slack
+#REQUIRED (unless useAPI=true)
+URL="https://hooks.slack.com/services/yourhook"
+
+#Address to listen on for outgoing webhook requests from slack
+#See account settings - integrations - outgoing webhooks on slack
+#This setting will not be used when useAPI is eanbled
+#webhooks
+#REQUIRED (unless useAPI=true)
+BindAddress="0.0.0.0:9999"
+
+#Icon that will be showed in slack
+#OPTIONAL
+IconURL="http://youricon.png"
+
+#### Settings for using slack API
+#OPTIONAL
+useAPI=false
+
+#Token to connect with the Slack API
+#REQUIRED (when useAPI=true)
+Token="yourslacktoken"
+
+#### Shared settings for webhooks and API
+
+#Whether to prefix messages from other bridges to mattermost with the sender's nick. 
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#slack server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to Slack will by default be prefixed by "bridge-" + nick. You can, 
+#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#OPTIONAL (default {BRIDGE}-{NICK})
+RemoteNickFormat="[{BRIDGE}] <{NICK}> 
+
+#how to format the list of IRC nicks when displayed in slack
+#Possible options are "table" and "plain"
+#OPTIONAL (default plain)
+NickFormatter=plain
+#How many nicks to list per row for formatters that support this. 
+#OPTIONAL (default 4)
+NicksPerRow=4
+
+#Nicks you want to ignore. Messages from those users will not be bridged.
+#OPTIONAL 
+IgnoreNicks="mmbot spammer2"
+
+###################################################################
+#multiple channel config
+###################################################################
+#You can specify multiple channels. 
+#The name is just an identifier for you.
+#REQUIRED (at least 1 channel)
+[Channel "channel1"] 
+#Choose the IRC channel to send messages to.
+IRC="#off-topic"
+#Choose the mattermost channel to messages to.
+mattermost="off-topic"
+#Choose the xmpp channel to send messages to.
+xmpp="off-topic"
+#Choose the Gitter channel to send messages to.
+#Gitter channels are named "user/repo"
+gitter="42wim/matterbridge"
+#Choose the slack channel to send messages to.
+slack="general"
+
+[Channel "testchannel"]
+IRC="#testing"
+mattermost="testing"
+xmpp="testing"
+gitter="user/repo"
+slack="testing"
+
+###################################################################
+#general
+###################################################################
+[general]
+#request your API key on https://github.com/giphy/GiphyAPI. This is a public beta key. 
+#OPTIONAL
+GiphyApiKey="dc6zaTOxFJmzC"
+
+#Enabling plus means you'll use the API version instead of the webhooks one
+Plus=false

matterbridge.go

@@ -3,56 +3,58 @@ package main
 import (
 	"flag"
 	"fmt"
-	"os"
-	"strings"
-
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/gateway"
-	"github.com/google/gops/agent"
+	"github.com/42wim/matterbridge/gateway/samechannel"
-	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
+	log "github.com/Sirupsen/logrus"
-	log "github.com/sirupsen/logrus"
 )
 
-var (
+var version = "0.8.0"
-	version = "1.12.2"
+
-	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")
-	flagGops := flag.Bool("gops", false, "enable gops agent")
 	flag.Parse()
-	if *flagGops {
-		agent.Listen(&agent.Options{})
-		defer agent.Close()
-	}
 	if *flagVersion {
-		fmt.Printf("version: %s %s\n", version, githash)
+		fmt.Println("version:", version)
 		return
 	}
-	if *flagDebug || os.Getenv("DEBUG") == "1" {
+	flag.Parse()
-		log.SetFormatter(&prefixed.TextFormatter{PrefixPadding: 13, DisableColors: true, FullTimestamp: false, ForceFormatting: true})
+	if *flagDebug {
-		flog.Info("Enabling debug")
+		log.Info("enabling debug")
 		log.SetLevel(log.DebugLevel)
 	}
-	flog.Printf("Running version %s %s", version, githash)
+	fmt.Println("running version", version)
-	if strings.Contains(version, "-dev") {
-		flog.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
-	}
 	cfg := config.NewConfig(*flagConfig)
-	cfg.BridgeValues().General.Debug = *flagDebug
+	for _, gw := range cfg.SameChannelGateway {
-	r, err := gateway.NewRouter(cfg)
+		if !gw.Enable {
-	if err != nil {
+			continue
-		flog.Fatalf("Starting gateway failed: %s", err)
+		}
+		fmt.Printf("starting samechannel gateway %#v\n", gw.Name)
+		go func(gw config.SameChannelGateway) {
+			err := samechannelgateway.New(cfg, &gw)
+			if err != nil {
+				log.Debugf("starting gateway failed %#v", err)
+			}
+		}(gw)
 	}
-	err = r.Start()
+
-	if err != nil {
+	for _, gw := range cfg.Gateway {
-		flog.Fatalf("Starting gateway failed: %s", err)
+		if !gw.Enable {
+			continue
+		}
+		fmt.Printf("starting gateway %#v\n", gw.Name)
+		go func(gw config.Gateway) {
+			err := gateway.New(cfg, &gw)
+			if err != nil {
+				log.Debugf("starting gateway failed %#v", err)
+			}
+		}(gw)
 	}
-	flog.Printf("Gateway(s) started succesfully. Now relaying messages")
 	select {}
 }

matterbridge.toml.simple

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

matterhook/matterhook.go

@@ -6,27 +6,23 @@ 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"`
+	Channel     string      `json:"channel,omitempty"`
-	IconURL     string                 `json:"icon_url,omitempty"`
+	IconURL     string      `json:"icon_url,omitempty"`
-	IconEmoji   string                 `json:"icon_emoji,omitempty"`
+	IconEmoji   string      `json:"icon_emoji,omitempty"`
-	UserName    string                 `json:"username,omitempty"`
+	UserName    string      `json:"username,omitempty"`
-	Text        string                 `json:"text"`
+	Text        string      `json:"text"`
-	Attachments []slack.Attachment     `json:"attachments,omitempty"`
+	Attachments interface{} `json:"attachments,omitempty"`
-	Type        string                 `json:"type,omitempty"`
+	Type        string      `json:"type,omitempty"`
-	Props       map[string]interface{} `json:"props"`
 }
 
 // IMessage for mattermost outgoing webhook. (received from mattermost)
@@ -41,18 +37,16 @@ type IMessage struct {
 	Timestamp   string `schema:"timestamp"`
 	UserID      string `schema:"user_id"`
 	UserName    string `schema:"user_name"`
-	PostId      string `schema:"post_id"` //nolint:golint
+	PostId      string `schema:"post_id"`
 	RawText     string `schema:"raw_text"`
-	ServiceId   string `schema:"service_id"` //nolint:golint
+	ServiceId   string `schema:"service_id"`
 	Text        string `schema:"text"`
 	TriggerWord string `schema:"trigger_word"`
-	FileIDs     string `schema:"file_ids"`
 }
 
 // Client for Mattermost.
 type Client struct {
-	// URL for incoming webhooks on mattermost.
+	Url        string // URL for incoming webhooks on mattermost.
-	Url        string // nolint:golint
 	In         chan IMessage
 	Out        chan OMessage
 	httpclient *http.Client
@@ -88,14 +82,8 @@ func New(url string, config Config) *Client {
 func (c *Client) StartServer() {
 	mux := http.NewServeMux()
 	mux.Handle("/", c)
-	srv := &http.Server{
-		ReadTimeout:  5 * time.Second,
-		WriteTimeout: 10 * time.Second,
-		Handler:      mux,
-		Addr:         c.BindAddress,
-	}
 	log.Printf("Listening on http://%v...\n", c.BindAddress)
-	if err := srv.ListenAndServe(); err != nil {
+	if err := http.ListenAndServe(c.BindAddress, mux); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -139,11 +127,12 @@ 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 {
-	var msg IMessage
+	for {
-	for msg := range c.In {
+		select {
-		return msg
+		case msg := <-c.In:
+			return msg
+		}
 	}
-	return msg
 }
 
 // Send sends a msg to mattermost incoming webhooks URL.

migration.md

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

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

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

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

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

@@ -127,6 +127,7 @@ func (gitter *Gitter) GetRooms() ([]Room, error) {
 
 // GetUsersInRoom returns the users in the room with the passed id
 func (gitter *Gitter) GetUsersInRoom(roomID string) ([]User, error) {
+
 	var users []User
 	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/users")
 	if err != nil {
@@ -205,43 +206,17 @@ func (gitter *Gitter) GetMessage(roomID, messageID string) (*Message, error) {
 }
 
 // SendMessage sends a message to a room
-func (gitter *Gitter) SendMessage(roomID, text string) (*Message, error) {
+func (gitter *Gitter) SendMessage(roomID, text string) error {
 
 	message := Message{Text: text}
 	body, _ := json.Marshal(message)
-	response, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
+	_, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
 	if err != nil {
 		gitter.log(err)
-		return nil, err
+		return err
 	}
 
-	err = json.Unmarshal(response, &message)
+	return nil
-	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
@@ -284,45 +259,6 @@ func (gitter *Gitter) SetDebug(debug bool, logWriter io.Writer) {
 	gitter.logWriter = logWriter
 }
 
-// SearchRooms queries the Rooms resources of gitter API
-func (gitter *Gitter) SearchRooms(room string) ([]Room, error) {
-
-	var rooms struct {
-		Results []Room `json:"results"`
-	}
-
-	response, err := gitter.get(gitter.config.apiBaseURL + "rooms?q=" + room)
-
-	if err != nil {
-		gitter.log(err)
-		return nil, err
-	}
-
-	err = json.Unmarshal(response, &rooms)
-	if err != nil {
-		gitter.log(err)
-		return nil, err
-	}
-	return rooms.Results, nil
-}
-
-// GetRoomId returns the room ID of a given URI
-func (gitter *Gitter) GetRoomId(uri string) (string, error) {
-
-	rooms, err := gitter.SearchRooms(uri)
-	if err != nil {
-		gitter.log(err)
-		return "", err
-	}
-
-	for _, element := range rooms {
-		if element.URI == uri {
-			return element.ID, nil
-		}
-	}
-	return "", APIError{What: "Room not found."}
-}
-
 // Pagination params
 type Pagination struct {
 
@@ -440,39 +376,6 @@ func (gitter *Gitter) post(url string, body []byte) ([]byte, error) {
 	return result, nil
 }
 
-func (gitter *Gitter) put(url string, body []byte) ([]byte, error) {
-	r, err := http.NewRequest("PUT", url, bytes.NewBuffer(body))
-	if err != nil {
-		gitter.log(err)
-		return nil, err
-	}
-
-	r.Header.Set("Content-Type", "application/json")
-	r.Header.Set("Accept", "application/json")
-	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
-
-	resp, err := gitter.config.client.Do(r)
-	if err != nil {
-		gitter.log(err)
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
-		gitter.log(err)
-		return nil, err
-	}
-
-	result, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		gitter.log(err)
-		return nil, err
-	}
-
-	return result, nil
-}
-
 func (gitter *Gitter) delete(url string) ([]byte, error) {
 	r, err := http.NewRequest("delete", url, nil)
 	if err != nil {

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

@@ -47,13 +47,13 @@ Loop:
 			}
 			break Loop
 		}
-		
+
 		resp := stream.getResponse()
 		if resp.StatusCode != 200 {
 			gitter.log(fmt.Sprintf("Unexpected response code %v", resp.StatusCode))
 			continue
 		}
-		
+
 		//"The JSON stream returns messages as JSON objects that are delimited by carriage return (\r)" <- Not true crap it's (\n) only
 		reader = bufio.NewReader(resp.Body)
 		line, err := reader.ReadBytes('\n')
@@ -112,7 +112,6 @@ type Stream struct {
 
 func (stream *Stream) destroy() {
 	close(stream.Event)
-	stream.streamConnection.currentRetries = 0
 }
 
 type Event struct {
@@ -136,11 +135,10 @@ func (stream *Stream) connect() {
 	}
 
 	res, err := stream.gitter.getResponse(stream.url, stream)
-	if err != nil || res.StatusCode != 200 {
+	if stream.streamConnection.canceled {
-		stream.gitter.log("Failed to get response, trying reconnect")
+		// do nothing
-		if res != nil {
+	} else if err != nil || res.StatusCode != 200 {
-			stream.gitter.log(fmt.Sprintf("Status code: %v", res.StatusCode))
+		stream.gitter.log("Failed to get response, trying reconnect ")
-		}
 		stream.gitter.log(err)
 
 		// sleep and wait
@@ -163,6 +161,9 @@ type streamConnection struct {
 	// connection was closed
 	closed bool
 
+	// canceled
+	canceled bool
+
 	// wait time till next try
 	wait time.Duration
 
@@ -191,10 +192,13 @@ func (stream *Stream) Close() {
 		stream.gitter.log("Stream connection close request")
 		switch transport := stream.gitter.config.client.Transport.(type) {
 		case *httpclient.Transport:
+			stream.streamConnection.canceled = true
 			transport.CancelRequest(conn.request)
 		default:
 		}
+
 	}
+	conn.currentRetries = 0
 }
 
 func (stream *Stream) isClosed() bool {

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

@@ -199,3 +199,4 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-                                Apache License
+                                 Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
@@ -172,3 +172,31 @@
       defend, and hold each Contributor harmless for any liability
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

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

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

vendor/github.com/BurntSushi/toml/COPYING

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

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

@@ -0,0 +1,90 @@
+// 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

@@ -0,0 +1,131 @@
+// 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

@@ -0,0 +1,61 @@
+// 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/decode.go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

vendor/github.com/Philipp15b/go-steam/README.md

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

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

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

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

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

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

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

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

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

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

@@ -1,53 +0,0 @@
-/*
-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

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

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

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

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

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

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