Release v1.18.1 (#1207)

This is half a fix for #874

This patch introduces a new config flag:
- MediaConvertTgs

These need to be treated independently from the existing
MediaConvertWebPToPNG flag because Tgs→WebP results in an
*animated* WebP, and the WebP→PNG converter can't handle
animated WebP files yet.

Furthermore, some platforms (like discord) don't even support
animated WebP files, so the user may want to fall back to
static PNGs (not APNGs).

The final reason why this is only half a fix is that this
introduces an external dependency, namely lottie, to be
installed like this:

$ pip3 install lottie cairosvg

This patch works by writing the tgs to a temporary file in /tmp,
calling lottie to convert it (this conversion may take several seconds!),
and then deleting the temporary file.
The temporary file is absolutely necessary, as lottie refuses to
work on non-seekable files.
If anyone comes up with a reasonable use case where /tmp is
unavailable, I can add yet another config option for that, if desired.

Telegram will bail out if the option is configured but lottie isn't found.

.fixmie.yml

@@ -0,0 +1,3 @@
+go:
+  comments:
+    disabled: true

.github/ISSUE_TEMPLATE.md

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

.github/ISSUE_TEMPLATE/Bug_report.md

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

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+labels: enhancement
+
+---
+
+**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.

.github/workflows/development.yml

@@ -0,0 +1,57 @@
+name: Development
+on: [push, pull_request]
+jobs:
+  lint:
+    name: golangci-lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 20
+      - name: Run golangci-lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: v1.29
+          args: "-v --new-from-rev HEAD~5"
+  test-build-upload:
+    strategy:
+      matrix:
+        go-version: [1.14.x, 1.15.x]
+        platform: [ubuntu-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go-version }}
+    - name: Checkout code
+      uses: actions/checkout@v2
+      with:
+          fetch-depth: 0
+    - name: Test
+      run: go test ./... -mod=vendor
+    - name: Build
+      run: |
+        mkdir -p output/{win,lin,arm,mac}
+        VERSION=$(git describe --tags)
+        GOOS=linux GOARCH=amd64 go build -mod=vendor -ldflags "-s -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o output/lin/matterbridge-$VERSION-linux-amd64
+        GOOS=windows GOARCH=amd64 go build -mod=vendor -ldflags "-s -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o output/win/matterbridge-$VERSION-windows-amd64.exe
+        GOOS=darwin GOARCH=amd64 go build -mod=vendor -ldflags "-s -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o output/mac/matterbridge-$VERSION-darwin-amd64
+    - name: Upload linux 64-bit
+      if: startsWith(matrix.go-version,'1.15')
+      uses: actions/upload-artifact@v2
+      with:
+        name: matterbridge-linux-64bit
+        path: output/lin
+    - name: Upload windows 64-bit
+      if: startsWith(matrix.go-version,'1.15')
+      uses: actions/upload-artifact@v2
+      with:
+        name: matterbridge-windows-64bit
+        path: output/win
+    - name: Upload darwin 64-bit
+      if: startsWith(matrix.go-version,'1.15')
+      uses: actions/upload-artifact@v2
+      with:
+        name: matterbridge-darwin-64bit
+        path: output/mac

.gitignore

@@ -0,0 +1,6 @@
+# Exclude matterbridge binary
+/matterbridge
+/matterbridge.exe
+
+# Exclude configuration file
+matterbridge.toml

.golangci.yaml

@@ -0,0 +1,216 @@
+# For full documentation of the configuration options please
+# see: https://github.com/golangci/golangci-lint#config-file.
+
+# options for analysis running
+run:
+  # default concurrency is the available CPU number
+  # concurrency: 4
+
+  # timeout for analysis, e.g. 30s, 5m, default is 1m
+  deadline: 2m
+
+  # exit code when at least one issue was found, default is 1
+  issues-exit-code: 1
+
+  # include test files or not, default is true
+  tests: true
+
+  # list of build tags, all linters use it. Default is empty list.
+  build-tags:
+
+  # which dirs to skip: they won't be analyzed;
+  # can use regexp here: generated.*, regexp is applied on full path;
+  # default value is empty list, but next dirs are always skipped independently
+  # from this option's value:
+  #   	vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
+  skip-dirs: gateway/bridgemap$
+
+  # which files to skip: they will be analyzed, but issues from them
+  # won't be reported. Default value is empty list, but there is
+  # no need to include all autogenerated files, we confidently recognize
+  # autogenerated files. If it's not please let us know.
+  skip-files:
+
+
+# output configuration options
+output:
+  # colored-line-number|line-number|json|tab|checkstyle, default is "colored-line-number"
+  format: colored-line-number
+
+  # print lines of code with issue, default is true
+  print-issued-lines: true
+
+  # print linter name in the end of issue text, default is true
+  print-linter-name: true
+
+
+# all available settings of specific linters, we can set an option for
+# a given linter even if we deactivate that same linter at runtime
+linters-settings:
+  errcheck:
+    # report about not checking of errors in type assertions: `a := b.(MyStruct)`;
+    # default is false: such cases aren't reported by default.
+    check-type-assertions: false
+
+    # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`;
+    # default is false: such cases aren't reported by default.
+    check-blank: false
+  govet:
+    # report about shadowed variables
+    check-shadowing: true
+  golint:
+    # minimal confidence for issues, default is 0.8
+    min-confidence: 0.8
+  gofmt:
+    # simplify code: gofmt with `-s` option, true by default
+    simplify: true
+  goimports:
+    # put imports beginning with prefix after 3rd-party packages;
+    # it's a comma-separated list of prefixes
+    local-prefixes: github.com
+  gocyclo:
+    # minimal code complexity to report, 30 by default (but we recommend 10-20)
+    min-complexity: 15
+  maligned:
+    # print struct with more effective memory layout or not, false by default
+    suggest-new: true
+  dupl:
+    # tokens count to trigger issue, 150 by default
+    threshold: 150
+  goconst:
+    # minimal length of string constant, 3 by default
+    min-len: 3
+    # minimal occurrences count to trigger, 3 by default
+    min-occurrences: 3
+  depguard:
+    list-type: blacklist
+    include-go-root: false
+    packages:
+    # List of packages that we would want to blacklist for... reasons.
+  misspell:
+    # Correct spellings using locale preferences for US or UK.
+    # Default is to use a neutral variety of English.
+    # Setting locale to US will correct the British spelling of 'colour' to 'color'.
+    locale: US
+  lll:
+    # max line length, lines longer will be reported. Default is 120.
+    # '\t' is counted as 1 character by default, and can be changed with the tab-width option
+    line-length: 150
+    # tab width in spaces. Default to 1.
+    tab-width: 1
+  unused:
+    # treat code as a program (not a library) and report unused exported identifiers; default is false.
+    # XXX: if you enable this setting, unused will report a lot of false-positives in text editors:
+    # if it's called for subdir of a project it can't find funcs usages. All text editor integrations
+    # with golangci-lint call it on a directory with the changed file.
+    check-exported: false
+  unparam:
+    # Inspect exported functions, default is false. Set to true if no external program/library imports your code.
+    # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors:
+    # if it's called for subdir of a project it can't find external interfaces. All text editor integrations
+    # with golangci-lint call it on a directory with the changed file.
+    check-exported: false
+  nakedret:
+    # make an issue if func has more lines of code than this setting and it has naked returns; default is 30
+    max-func-lines: 0 # Warn on all naked returns.
+  prealloc:
+    # XXX: we don't recommend using this linter before doing performance profiling.
+    # For most programs usage of prealloc will be a premature optimization.
+
+    # Report preallocation suggestions only on simple loops that have no returns/breaks/continues/gotos in them.
+    # True by default.
+    simple: true
+    range-loops: true # Report preallocation suggestions on range loops, true by default
+    for-loops: false # Report preallocation suggestions on for loops, false by default
+  gocritic:
+    # which checks should be enabled; can't be combined with 'disabled-checks';
+    # default are: [appendAssign assignOp caseOrder dupArg dupBranchBody dupCase flagDeref
+    # ifElseChain regexpMust singleCaseSwitch sloppyLen switchTrue typeSwitchVar underef
+    # unlambda unslice rangeValCopy defaultCaseOrder];
+    # all checks list: https://github.com/go-critic/checkers
+    # disabled for now - hugeParam
+    enabled-checks:
+      - appendAssign
+      - assignOp
+      - boolExprSimplify
+      - builtinShadow
+      - captLocal
+      - caseOrder
+      - commentedOutImport
+      - defaultCaseOrder
+      - dupArg
+      - dupBranchBody
+      - dupCase
+      - dupSubExpr
+      - elseif
+      - emptyFallthrough
+      - ifElseChain
+      - importShadow
+      - indexAlloc
+      - methodExprCall
+      - nestingReduce
+      - offBy1
+      - ptrToRefParam
+      - regexpMust
+      - singleCaseSwitch
+      - sloppyLen
+      - switchTrue
+      - typeSwitchVar
+      - typeUnparen
+      - underef
+      - unlambda
+      - unnecessaryBlock
+      - unslice
+      - valSwap
+      - wrapperFunc
+      - yodaStyleExpr
+
+
+# linters that we should / shouldn't run
+linters:
+  enable-all: true
+  disable:
+    - gochecknoglobals
+    - lll
+    - maligned
+    - prealloc
+    - wsl
+    - gomnd
+    - godox
+    - goerr113
+    - testpackage
+    - godot
+    - interfacer
+    - goheader
+    - noctx
+
+# rules to deal with reported isues
+issues:
+  # List of regexps of issue texts to exclude, empty list by default.
+  # But independently from this option we use default exclude patterns,
+  # it can be disabled by `exclude-use-default: false`. To list all
+  # excluded by default patterns execute `golangci-lint run --help`
+  exclude:
+
+  # Independently from option `exclude` we use default exclude patterns,
+  # it can be disabled by this option. To list all
+  # excluded by default patterns execute `golangci-lint run --help`.
+  # Default value for this option is true.
+  exclude-use-default: true
+
+  # Maximum issues count per one linter. Set to 0 to disable. Default is 50.
+  max-per-linter: 0
+
+  # Maximum count of issues with the same text. Set to 0 to disable. Default is 3.
+  max-same-issues: 0
+
+  # Show only new issues: if there are unstaged changes or untracked files,
+  # only those changes are analyzed, else only changes in HEAD~ are analyzed.
+  # It's a super-useful option for integration of golangci-lint into existing
+  # large codebase. It's not practical to fix all existing issues at the moment
+  # of integration: much better don't allow issues in new code.
+  # Default is false.
+  new: false
+
+  # Show only new issues created after git revision `REV`
+  new-from-rev: "HEAD~1"

.goreleaser.yml

@@ -0,0 +1,38 @@
+release:
+  prerelease: auto
+  name_template: "{{.ProjectName}} v{{.Version}}"
+
+builds:
+- env:
+    - CGO_ENABLED=0
+  goos:
+    - freebsd
+    - windows
+    - darwin
+    - linux
+    - dragonfly
+    - netbsd
+    - openbsd
+  goarch:
+    - amd64
+    - arm
+    - arm64
+    - 386
+  ldflags:
+    - -s -w -X main.githash={{.ShortCommit}}
+
+archives:
+  -
+    id: matterbridge
+    builds:
+    - matterbridge
+    name_template: "{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+    format: binary
+    files:
+      - none*
+    replacements:
+      386: 32bit
+      amd64: 64bit
+
+checksum:
+  name_template: 'checksums.txt'

Dockerfile

@@ -0,0 +1,16 @@
+FROM alpine:edge AS builder
+
+COPY . /go/src/github.com/42wim/matterbridge
+RUN apk update && apk add go git gcc musl-dev \
+        && 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
+
+FROM alpine:edge
+RUN apk --no-cache add ca-certificates mailcap
+COPY --from=builder /bin/matterbridge /bin/matterbridge
+RUN mkdir /etc/matterbridge \
+  && touch /etc/matterbridge/matterbridge.toml \
+  && ln -sf /matterbridge.toml /etc/matterbridge/matterbridge.toml
+ENTRYPOINT ["/bin/matterbridge", "-conf", "/etc/matterbridge/matterbridge.toml"]

README.md

@@ -1,83 +1,358 @@
+<div align="center">
+
 # matterbridge
 
-Simple bridge between mattermost and IRC. Uses the in/outgoing webhooks.  
-Relays public channel messages between mattermost and IRC.  
+![Matterbridge Logo](img/matterbridge-notext.gif)<br />
+**A simple chat bridge**<br />
+Letting people be where they want to be.<br />
+<sub>Bridges between a growing number of protocols. Click below to demo or join the development chat.</sub>
 
-Work in progress.  
+   <sup>
 
-Requires mattermost build from master (or 1.2.0 when released).
+[Discord][mb-discord] |
+[Gitter][mb-gitter] |
+[IRC][mb-irc] |
+[Keybase][mb-keybase] |
+[Matrix][mb-matrix] |
+[Mattermost][mb-mattermost] |
+[MSTeams][mb-msteams] |
+[Rocket.Chat][mb-rocketchat] |
+[Slack][mb-slack] |
+[Telegram][mb-telegram] |
+[Twitch][mb-twitch] |
+[WhatsApp][mb-whatsapp] |
+[XMPP][mb-xmpp] |
+[Zulip][mb-zulip] |
+And more...
+</sup>
 
-## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/tag/v0.1)
+---
+
+[![Download stable](https://img.shields.io/github/release/42wim/matterbridge.svg?label=download%20stable)](https://github.com/42wim/matterbridge/releases/latest)
+[![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>
+
+<p>
+  <a href="https://www.digitalocean.com/">
+    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/PoweredByDO/DO_Powered_by_Badge_blue.svg" width="201px">
+  </a>
+</p>
+
+# Table of Contents
+
+- [matterbridge](#matterbridge)
+- [Table of Contents](#table-of-contents)
+  - [Features](#features)
+    - [Natively supported](#natively-supported)
+    - [3rd party via matterbridge api](#3rd-party-via-matterbridge-api)
+    - [API](#api)
+  - [Chat with us](#chat-with-us)
+  - [Screenshots](#screenshots)
+  - [Installing / upgrading](#installing--upgrading)
+    - [Binaries](#binaries)
+    - [Packages](#packages)
+  - [Building](#building)
+  - [Configuration](#configuration)
+    - [Basic configuration](#basic-configuration)
+    - [Settings](#settings)
+    - [Advanced configuration](#advanced-configuration)
+    - [Examples](#examples)
+      - [Bridge mattermost (off-topic) - irc (#testing)](#bridge-mattermost-off-topic---irc-testing)
+      - [Bridge slack (#general) - discord (general)](#bridge-slack-general---discord-general)
+  - [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)
+
+### Natively supported
+
+- [Discord](https://discordapp.com)
+- [Gitter](https://gitter.im)
+- [IRC](http://www.mirc.com/servers.html)
+- [Keybase](https://keybase.io)
+- [Matrix](https://matrix.org)
+- [Mattermost](https://github.com/mattermost/mattermost-server/) 4.x, 5.x
+- [Microsoft Teams](https://teams.microsoft.com)
+- [Nextcloud Talk](https://nextcloud.com/talk/)
+- [Rocket.chat](https://rocket.chat)
+- [Slack](https://slack.com)
+- [Ssh-chat](https://github.com/shazow/ssh-chat)
+- [Steam](https://store.steampowered.com/)
+- [Telegram](https://telegram.org)
+- [Twitch](https://twitch.tv)
+- [WhatsApp](https://www.whatsapp.com/)
+- [XMPP](https://xmpp.org)
+- [Zulip](https://zulipchat.com)
+
+### 3rd party via matterbridge api
+
+- [Discourse](https://github.com/DeclanHoare/matterbabble)
+- [Facebook messenger](https://github.com/VictorNine/fbridge)
+- [Minecraft](https://github.com/elytra/MatterLink)
+- [Reddit](https://github.com/bonehurtingjuice/mattereddit)
+- [Counter-Strike, half-life and more](https://forums.alliedmods.net/showthread.php?t=319430)
+- [MatterAMXX](https://github.com/GabeIggy/MatterAMXX)
+
+### API
+
+The API is basic at the moment.
+More info and examples on the [wiki](https://github.com/42wim/matterbridge/wiki/Api).
+
+Used by the projects below. Feel free to make a PR to add your project to this list.
+
+- [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
+- [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
+- [Mattereddit](https://github.com/bonehurtingjuice/mattereddit) (Reddit chat support)
+- [fbridge](https://github.com/VictorNine/fbridge) (Facebook messenger support)
+- [matterbabble](https://github.com/DeclanHoare/matterbabble) (Discourse support)
+- [MatterAMXX](https://forums.alliedmods.net/showthread.php?t=319430) (Counter-Strike, half-life and more via AMXX mod)
+
+## Chat with us
+
+Questions or want to test on your favorite platform? Join below:
+
+- [Discord][mb-discord]
+- [Gitter][mb-gitter]
+- [IRC][mb-irc]
+- [Keybase][mb-keybase]
+- [Matrix][mb-matrix]
+- [Mattermost][mb-mattermost]
+- [Rocket.Chat][mb-rocketchat]
+- [Slack][mb-slack]
+- [Telegram][mb-telegram]
+- [Twitch][mb-twitch]
+- [XMPP][mb-xmpp] (matterbridge@conference.jabber.de)
+- [Zulip][mb-zulip]
+
+## Screenshots
+
+See https://github.com/42wim/matterbridge/wiki
+
+## Installing / upgrading
+
+### Binaries
+
+- Latest stable release [v1.18.1](https://github.com/42wim/matterbridge/releases/latest)
+- Development releases (follows master) can be downloaded [here](https://github.com/42wim/matterbridge/actions) selecting the latest green build and then artifacts.
+
+To install or upgrade just download the latest [binary](https://github.com/42wim/matterbridge/releases/latest) and follow the instructions on the [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
+
+### Packages
+
+- [Overview](https://repology.org/metapackage/matterbridge/versions)
+- [snap](https://snapcraft.io/matterbridge)
+
+## Building
+
+Most people just want to use binaries, you can find those [here](https://github.com/42wim/matterbridge/releases/latest)
+
+If you really want to build from source, follow these instructions:
+Go 1.12+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed.
 
-## building
-Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
 
 ```
-cd $GOPATH
 go get github.com/42wim/matterbridge
 ```
 
-You should now have matterbridge binary in the bin directory:
+You should now have matterbridge binary in the ~/go/bin directory:
 
 ```
-$ ls bin/
+$ ls ~/go/bin/
 matterbridge
 ```
 
-## running
-1) Copy the matterbridge.conf.sample to matterbridge.conf in the same directory as the matterbridge binary.  
-2) Edit matterbridge.conf with the settings for your environment. See below for more config information.  
-3) Now you can run matterbridge.  
+## Configuration
 
-Matterbridge will:
-* start a webserver listening on the port specified in the configuration.
-* connect to specified irc server and channel.
-* send messages from mattermost to irc and vice versa, messages in mattermost will appear with irc-nick
+### Basic configuration
 
-## config
-### matterbridge
-matterbridge looks for matterbridge.conf in current directory.
+See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
 
-Look at matterbridge.conf.sample for an example
+### Settings
 
+All possible [settings](https://github.com/42wim/matterbridge/wiki/Settings) for each bridge.
 
-```
-[IRC]
-server="irc.freenode.net"
-port=6667
-UseTLS=false
-SkipTLSVerify=true
-nick="matterbot"
-channel="#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]
-#url is your incoming webhook url (account settings - integrations - incoming webhooks)
-url="http://mattermost.yourdomain.com/hooks/incomingwebhookkey"  
-#port the bridge webserver will listen on
-port=9999
-showjoinpart=true #show irc users joining and parting
-#the token you get from the outgoing webhook in mattermost. If empty no token check will be done.
-token=yourtokenfrommattermost
-#disable certificate checking (selfsigned certificates)
-#SkipTLSVerify=true
+    [mattermost.work]
+    Server="yourmattermostserver.tld"
+    Team="yourteam"
+    Login="yourlogin"
+    Password="yourpass"
+    PrefixMessagesWithNick=true
+    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 
-[general]
-#request your API key on https://github.com/giphy/GiphyAPI. This is a public beta key
-GiphyApiKey="dc6zaTOxFJmzC"
+[[gateway]]
+name="mygateway"
+enable=true
+    [[gateway.inout]]
+    account="irc.freenode"
+    channel="#testing"
+
+    [[gateway.inout]]
+    account="mattermost.work"
+    channel="off-topic"
 ```
 
-### mattermost
-You'll have to configure the incoming en outgoing webhooks. 
+#### Bridge slack (#general) - discord (general)
 
-* 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)  
+```toml
+[slack]
+[slack.test]
+Token="yourslacktoken"
+PrefixMessagesWithNick=true
 
-* 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.  
+[discord]
+[discord.test]
+Token="yourdiscordtoken"
+Server="yourdiscordservername"
 
-e.g. http://192.168.1.1:9999 (9999 is the port specified in [mattermost] section of matterbridge.conf)
+[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:
+  -conf string
+        config file (default "matterbridge.toml")
+  -debug
+        enable debug
+  -gops
+        enable gops agent
+  -version
+        show version
+```
+
+### Docker
+
+Please take a look at the [Docker Wiki page](https://github.com/42wim/matterbridge/wiki/Deploy:-Docker) for more information.
+
+## Changelog
+
+See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.md)
+
+## FAQ
+
+See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
+
+## Related projects
+
+- [jwflory/ansible-role-matterbridge](https://galaxy.ansible.com/jwflory/matterbridge) (Ansible role to simplify deploying Matterbridge)
+- [matterbridge autoconfig](https://github.com/patcon/matterbridge-autoconfig)
+- [matterbridge config viewer](https://github.com/patcon/matterbridge-heroku-viewer)
+- [matterbridge-heroku](https://github.com/cadecairos/matterbridge-heroku)
+- [mattereddit](https://github.com/bonehurtingjuice/mattereddit)
+- [matterlink](https://github.com/elytra/MatterLink)
+- [mattermost-plugin](https://github.com/matterbridge/mattermost-plugin) - Run matterbridge as a plugin in mattermost
+- [pyCord](https://github.com/NikkyAI/pyCord) (crossplatform chatbot)
+- [fbridge](https://github.com/VictorNine/fbridge) (Facebook messenger support)
+- [isla](https://github.com/alphachung/isla) (Bot for Discord-Telegram groups used alongside matterbridge)
+- [matterbabble](https://github.com/DeclanHoare/matterbabble) (Connect Discourse threads to Matterbridge)
+
+## Articles
+
+- [matterbridge on kubernetes](https://medium.freecodecamp.org/using-kubernetes-to-deploy-a-chat-gateway-or-when-technology-works-like-its-supposed-to-a169a8cd69a3)
+- 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
+- https://daniele.tech/2019/02/how-to-use-matterbridge-to-connect-2-different-slack-workspaces/
+- https://userlinux.net/mattermost-and-matterbridge.html
+
+## Thanks
+
+<p>This project is supported by:</p>
+<p>
+  <a href="https://www.digitalocean.com/">
+    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
+  </a>
+</p>
+
+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
+- keybase - https://github.com/keybase/go-keybase-chat-bot
+- matrix - https://github.com/matrix-org/gomatrix
+- mattermost - https://github.com/mattermost/mattermost-server
+- msgraph.go - https://github.com/yaegashi/msgraph.go
+- slack - https://github.com/nlopes/slack
+- sshchat - https://github.com/shazow/ssh-chat
+- steam - https://github.com/Philipp15b/go-steam
+- telegram - https://github.com/go-telegram-bot-api/telegram-bot-api
+- tengo - https://github.com/d5/tengo
+- whatsapp - https://github.com/Rhymen/go-whatsapp/
+- xmpp - https://github.com/mattn/go-xmpp
+- zulip - https://github.com/ifo/gozulipbot
+
+<!-- Links -->
+
+[mb-discord]: https://discord.gg/AkKPtrQ
+[mb-gitter]: https://gitter.im/42wim/matterbridge
+[mb-irc]: https://webchat.freenode.net/?channels=matterbridgechat
+[mb-keybase]: https://keybase.io/team/matterbridge
+[mb-matrix]: https://riot.im/app/#/room/#matterbridge:matrix.org
+[mb-mattermost]: https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e
+[mb-msteams]: https://teams.microsoft.com/join/hj92x75gd3y7
+[mb-rocketchat]: https://open.rocket.chat/channel/matterbridge
+[mb-slack]: https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA
+[mb-telegram]: https://t.me/Matterbridge
+[mb-twitch]: https://www.twitch.tv/matterbridge
+[mb-whatsapp]: https://www.whatsapp.com/
+[mb-xmpp]: https://inverse.chat/
+[mb-zulip]: https://matterbridge.zulipchat.com/register/

bridge/api/api.go

@@ -0,0 +1,192 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/gorilla/websocket"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	ring "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
+		}))
+	}
+
+	// Set RemoteNickFormat to a sane default
+	if !b.IsKeySet("RemoteNickFormat") {
+		b.Log.Debugln("RemoteNickFormat is unset, defaulting to \"{NICK}\"")
+		b.Config.Config.Viper().Set(b.GetConfigKey("RemoteNickFormat"), "{NICK}")
+	}
+
+	e.GET("/api/health", b.handleHealthcheck)
+	e.GET("/api/messages", b.handleMessages)
+	e.GET("/api/stream", b.handleStream)
+	e.GET("/api/websocket", b.handleWebsocket)
+	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) getGreeting() config.Message {
+	return config.Message{
+		Event:     config.EventAPIConnected,
+		Timestamp: time.Now(),
+	}
+}
+
+func (b *API) handleStream(c echo.Context) error {
+	c.Response().Header().Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	c.Response().WriteHeader(http.StatusOK)
+	greet := b.getGreeting()
+	if err := json.NewEncoder(c.Response()).Encode(greet); err != nil {
+		return err
+	}
+	c.Response().Flush()
+	for {
+		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)
+	}
+}
+
+func (b *API) handleWebsocketMessage(message config.Message) {
+	message.Channel = "api"
+	message.Protocol = "api"
+	message.Account = b.Account
+	message.ID = ""
+	message.Timestamp = time.Now()
+
+	b.Log.Debugf("Sending websocket message from %s on %s to gateway", message.Username, "api")
+	b.Remote <- message
+}
+
+func (b *API) writePump(conn *websocket.Conn) {
+	for {
+		msg := b.Messages.Dequeue()
+		if msg != nil {
+			err := conn.WriteJSON(msg)
+			if err != nil {
+				break
+			}
+		}
+	}
+}
+
+func (b *API) readPump(conn *websocket.Conn) {
+	for {
+		message := config.Message{}
+		err := conn.ReadJSON(&message)
+		if err != nil {
+			break
+		}
+		b.handleWebsocketMessage(message)
+	}
+}
+
+func (b *API) handleWebsocket(c echo.Context) error {
+	conn, err := websocket.Upgrade(c.Response().Writer, c.Request(), nil, 1024, 1024)
+	if err != nil {
+		return err
+	}
+
+	greet := b.getGreeting()
+	_ = conn.WriteJSON(greet)
+
+	go b.writePump(conn)
+	go b.readPump(conn)
+
+	return nil
+}

bridge/bridge.go

@@ -0,0 +1,135 @@
+package bridge
+
+import (
+	"log"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/sirupsen/logrus"
+)
+
+type Bridger interface {
+	Send(msg config.Message) (string, error)
+	Connect() error
+	JoinChannel(channel config.ChannelInfo) error
+	Disconnect() error
+}
+
+type Bridge struct {
+	Bridger
+	*sync.RWMutex
+
+	Name           string
+	Account        string
+	Protocol       string
+	Channels       map[string]config.ChannelInfo
+	Joined         map[string]bool
+	ChannelMembers *config.ChannelMembers
+	Log            *logrus.Entry
+	Config         config.Config
+	General        *config.Protocol
+}
+
+type Config struct {
+	*Bridge
+
+	Remote chan config.Message
+}
+
+// Factory is the factory function to create a bridge
+type Factory func(*Config) Bridger
+
+func New(bridge *config.Bridge) *Bridge {
+	accInfo := strings.Split(bridge.Account, ".")
+	if len(accInfo) != 2 {
+		log.Fatalf("config failure, account incorrect: %s", bridge.Account)
+	}
+
+	protocol := accInfo[0]
+	name := accInfo[1]
+
+	return &Bridge{
+		RWMutex:  new(sync.RWMutex),
+		Channels: make(map[string]config.ChannelInfo),
+		Name:     name,
+		Protocol: protocol,
+		Account:  bridge.Account,
+		Joined:   make(map[string]bool),
+	}
+}
+
+func (b *Bridge) JoinChannels() error {
+	return b.joinChannels(b.Channels, b.Joined)
+}
+
+// SetChannelMembers sets the newMembers to the bridge ChannelMembers
+func (b *Bridge) SetChannelMembers(newMembers *config.ChannelMembers) {
+	b.Lock()
+	b.ChannelMembers = newMembers
+	b.Unlock()
+}
+
+func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map[string]bool) error {
+	for ID, channel := range channels {
+		if !exists[ID] {
+			b.Log.Infof("%s: joining %s (ID: %s)", b.Account, channel.Name, ID)
+			time.Sleep(time.Duration(b.GetInt("JoinDelay")) * time.Millisecond)
+			err := b.JoinChannel(channel)
+			if err != nil {
+				return err
+			}
+			exists[ID] = true
+		}
+	}
+	return nil
+}
+
+func (b *Bridge) GetConfigKey(key string) string {
+	return b.Account + "." + key
+}
+
+func (b *Bridge) IsKeySet(key string) bool {
+	return b.Config.IsKeySet(b.GetConfigKey(key)) || b.Config.IsKeySet("general."+key)
+}
+
+func (b *Bridge) GetBool(key string) bool {
+	val, ok := b.Config.GetBool(b.GetConfigKey(key))
+	if !ok {
+		val, _ = b.Config.GetBool("general." + key)
+	}
+	return val
+}
+
+func (b *Bridge) GetInt(key string) int {
+	val, ok := b.Config.GetInt(b.GetConfigKey(key))
+	if !ok {
+		val, _ = b.Config.GetInt("general." + key)
+	}
+	return val
+}
+
+func (b *Bridge) GetString(key string) string {
+	val, ok := b.Config.GetString(b.GetConfigKey(key))
+	if !ok {
+		val, _ = b.Config.GetString("general." + key)
+	}
+	return val
+}
+
+func (b *Bridge) GetStringSlice(key string) []string {
+	val, ok := b.Config.GetStringSlice(b.GetConfigKey(key))
+	if !ok {
+		val, _ = b.Config.GetStringSlice("general." + key)
+	}
+	return val
+}
+
+func (b *Bridge) GetStringSlice2D(key string) [][]string {
+	val, ok := b.Config.GetStringSlice2D(b.GetConfigKey(key))
+	if !ok {
+		val, _ = b.Config.GetStringSlice2D("general." + key)
+	}
+	return val
+}

bridge/config/config.go

@@ -0,0 +1,423 @@
+package config
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"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"
+	EventGetChannelMembers = "get_channel_members"
+)
+
+type Message struct {
+	Text      string    `json:"text"`
+	Channel   string    `json:"channel"`
+	Username  string    `json:"username"`
+	UserID    string    `json:"userid"` // userid on the bridge
+	Avatar    string    `json:"avatar"`
+	Account   string    `json:"account"`
+	Event     string    `json:"event"`
+	Protocol  string    `json:"protocol"`
+	Gateway   string    `json:"gateway"`
+	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 ChannelMember struct {
+	Username    string
+	Nick        string
+	UserID      string
+	ChannelID   string
+	ChannelName string
+}
+
+type ChannelMembers []ChannelMember
+
+type Protocol struct {
+	AuthCode               string // steam
+	BindAddress            string // mattermost, slack // DEPRECATED
+	Buffer                 int    // api
+	Charset                string // irc
+	ClientID               string // msteams
+	ColorNicks             bool   // only irc for now
+	Debug                  bool   // general
+	DebugLevel             int    // only for irc now
+	DisableWebPagePreview  bool   // telegram
+	EditSuffix             string // mattermost, slack, discord, telegram, gitter
+	EditDisable            bool   // mattermost, slack, discord, telegram, gitter
+	HTMLDisable            bool   // matrix
+	IconURL                string // mattermost, slack
+	IgnoreFailureOnStart   bool   // general
+	IgnoreNicks            string // all protocols
+	IgnoreMessages         string // all protocols
+	Jid                    string // xmpp
+	JoinDelay              string // all protocols
+	Label                  string // all protocols
+	Login                  string // mattermost, matrix
+	LogFile                string // general
+	MediaDownloadBlackList []string
+	MediaDownloadPath      string // Basically MediaServerUpload, but instead of uploading it, just write it to a file on the same server.
+	MediaDownloadSize      int    // all protocols
+	MediaServerDownload    string
+	MediaServerUpload      string
+	MediaConvertTgs        string     // telegram
+	MediaConvertWebPToPNG  bool       // telegram
+	MessageDelay           int        // IRC, time in millisecond to wait between messages
+	MessageFormat          string     // telegram
+	MessageLength          int        // IRC, max length of a message allowed
+	MessageQueue           int        // IRC, size of message queue for flood control
+	MessageSplit           bool       // IRC, split long messages with newlines on MessageLength instead of clipping
+	Muc                    string     // xmpp
+	Name                   string     // all protocols
+	Nick                   string     // all protocols
+	NickFormatter          string     // mattermost, slack
+	NickServNick           string     // IRC
+	NickServUsername       string     // IRC
+	NickServPassword       string     // IRC
+	NicksPerRow            int        // mattermost, slack
+	NoHomeServerSuffix     bool       // matrix
+	NoSendJoinPart         bool       // all protocols
+	NoTLS                  bool       // mattermost
+	Password               string     // IRC,mattermost,XMPP,matrix
+	PrefixMessagesWithNick bool       // mattemost, slack
+	PreserveThreading      bool       // slack
+	Protocol               string     // all protocols
+	QuoteDisable           bool       // telegram
+	QuoteFormat            string     // telegram
+	QuoteLengthLimit       int        // telegram
+	RejoinDelay            int        // IRC
+	ReplaceMessages        [][]string // all protocols
+	ReplaceNicks           [][]string // all protocols
+	RemoteNickFormat       string     // all protocols
+	RunCommands            []string   // IRC
+	Server                 string     // IRC,mattermost,XMPP,discord
+	SessionFile            string     // msteams,whatsapp
+	ShowJoinPart           bool       // all protocols
+	ShowTopicChange        bool       // slack
+	ShowUserTyping         bool       // slack
+	ShowEmbeds             bool       // discord
+	SkipTLSVerify          bool       // IRC, mattermost
+	SkipVersionCheck       bool       // mattermost
+	StripNick              bool       // all protocols
+	StripMarkdown          bool       // irc
+	SyncTopic              bool       // slack
+	TengoModifyMessage     string     // general
+	Team                   string     // mattermost, keybase
+	TeamID                 string     // msteams
+	TenantID               string     // msteams
+	Token                  string     // gitter, slack, discord, api
+	Topic                  string     // zulip
+	URL                    string     // mattermost, slack // DEPRECATED
+	UseAPI                 bool       // mattermost, slack
+	UseLocalAvatar         []string   // discord
+	UseSASL                bool       // IRC
+	UseTLS                 bool       // IRC
+	UseDiscriminator       bool       // discord
+	UseFirstName           bool       // telegram
+	UseUserName            bool       // discord
+	UseInsecureURL         bool       // telegram
+	VerboseJoinPart        bool       // IRC
+	WebhookBindAddress     string     // mattermost, slack
+	WebhookURL             string     // mattermost, slack
+}
+
+type ChannelOptions struct {
+	Key        string // irc, xmpp
+	WebhookURL string // discord
+	Topic      string // zulip
+}
+
+type Bridge struct {
+	Account     string
+	Channel     string
+	Options     ChannelOptions
+	SameChannel bool
+}
+
+type Gateway struct {
+	Name   string
+	Enable bool
+	In     []Bridge
+	Out    []Bridge
+	InOut  []Bridge
+}
+
+type Tengo struct {
+	InMessage        string
+	Message          string
+	RemoteNickFormat string
+	OutMessage       string
+}
+
+type SameChannelGateway struct {
+	Name     string
+	Enable   bool
+	Channels []string
+	Accounts []string
+}
+
+type BridgeValues 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
+	Discord            map[string]Protocol
+	Telegram           map[string]Protocol
+	Rocketchat         map[string]Protocol
+	SSHChat            map[string]Protocol
+	WhatsApp           map[string]Protocol // TODO is this struct used? Search for "SlackLegacy" for example didn't return any results
+	Zulip              map[string]Protocol
+	Keybase            map[string]Protocol
+	General            Protocol
+	Tengo              Tengo
+	Gateway            []Gateway
+	SameChannelGateway []SameChannelGateway
+}
+
+type Config interface {
+	Viper() *viper.Viper
+	BridgeValues() *BridgeValues
+	IsKeySet(key string) bool
+	GetBool(key string) (bool, bool)
+	GetInt(key string) (int, bool)
+	GetString(key string) (string, bool)
+	GetStringSlice(key string) ([]string, bool)
+	GetStringSlice2D(key string) ([][]string, bool)
+}
+
+type config struct {
+	sync.RWMutex
+
+	logger *logrus.Entry
+	v      *viper.Viper
+	cv     *BridgeValues
+}
+
+// NewConfig instantiates a new configuration based on the specified configuration file path.
+func NewConfig(rootLogger *logrus.Logger, cfgfile string) Config {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "config"})
+
+	viper.SetConfigFile(cfgfile)
+	input, err := ioutil.ReadFile(cfgfile)
+	if err != nil {
+		logger.Fatalf("Failed to read configuration file: %#v", err)
+	}
+
+	cfgtype := detectConfigType(cfgfile)
+	mycfg := newConfigFromString(logger, input, cfgtype)
+	if mycfg.cv.General.LogFile != "" {
+		logfile, err := os.OpenFile(mycfg.cv.General.LogFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
+		if err == nil {
+			logger.Info("Opening log file ", mycfg.cv.General.LogFile)
+			rootLogger.Out = logfile
+		} else {
+			logger.Warn("Failed to open ", mycfg.cv.General.LogFile)
+		}
+	}
+	if mycfg.cv.General.MediaDownloadSize == 0 {
+		mycfg.cv.General.MediaDownloadSize = 1000000
+	}
+	viper.WatchConfig()
+	viper.OnConfigChange(func(e fsnotify.Event) {
+		logger.Println("Config file changed:", e.Name)
+	})
+	return mycfg
+}
+
+// detectConfigType detects JSON and YAML formats, defaults to TOML.
+func detectConfigType(cfgfile string) string {
+	fileExt := filepath.Ext(cfgfile)
+	switch fileExt {
+	case ".json":
+		return "json"
+	case ".yaml", ".yml":
+		return "yaml"
+	}
+	return "toml"
+}
+
+// NewConfigFromString instantiates a new configuration based on the specified string.
+func NewConfigFromString(rootLogger *logrus.Logger, input []byte) Config {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "config"})
+	return newConfigFromString(logger, input, "toml")
+}
+
+func newConfigFromString(logger *logrus.Entry, input []byte, cfgtype string) *config {
+	viper.SetConfigType(cfgtype)
+	viper.SetEnvPrefix("matterbridge")
+	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
+	viper.AutomaticEnv()
+
+	if err := viper.ReadConfig(bytes.NewBuffer(input)); err != nil {
+		logger.Fatalf("Failed to parse the configuration: %s", err)
+	}
+
+	cfg := &BridgeValues{}
+	if err := viper.Unmarshal(cfg); err != nil {
+		logger.Fatalf("Failed to load the configuration: %s", err)
+	}
+	return &config{
+		logger: logger,
+		v:      viper.GetViper(),
+		cv:     cfg,
+	}
+}
+
+func (c *config) BridgeValues() *BridgeValues {
+	return c.cv
+}
+
+func (c *config) Viper() *viper.Viper {
+	return c.v
+}
+
+func (c *config) IsKeySet(key string) bool {
+	c.RLock()
+	defer c.RUnlock()
+	return c.v.IsSet(key)
+}
+
+func (c *config) GetBool(key string) (bool, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return c.v.GetBool(key), c.v.IsSet(key)
+}
+
+func (c *config) GetInt(key string) (int, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return c.v.GetInt(key), c.v.IsSet(key)
+}
+
+func (c *config) GetString(key string) (string, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return c.v.GetString(key), c.v.IsSet(key)
+}
+
+func (c *config) GetStringSlice(key string) ([]string, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return c.v.GetStringSlice(key), c.v.IsSet(key)
+}
+
+func (c *config) GetStringSlice2D(key string) ([][]string, bool) {
+	c.RLock()
+	defer c.RUnlock()
+
+	res, ok := c.v.Get(key).([]interface{})
+	if !ok {
+		return nil, false
+	}
+	var result [][]string
+	for _, entry := range res {
+		result2 := []string{}
+		for _, entry2 := range entry.([]interface{}) {
+			result2 = append(result2, entry2.(string))
+		}
+		result = append(result, result2)
+	}
+	return result, true
+}
+
+func GetIconURL(msg *Message, iconURL string) string {
+	info := strings.Split(msg.Account, ".")
+	protocol := info[0]
+	name := info[1]
+	iconURL = strings.Replace(iconURL, "{NICK}", msg.Username, -1)
+	iconURL = strings.Replace(iconURL, "{BRIDGE}", name, -1)
+	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
+	return iconURL
+}
+
+type TestConfig struct {
+	Config
+
+	Overrides map[string]interface{}
+}
+
+func (c *TestConfig) IsKeySet(key string) bool {
+	_, ok := c.Overrides[key]
+	return ok || c.Config.IsKeySet(key)
+}
+
+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

@@ -0,0 +1,470 @@
+package bdiscord
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/matterbridge/discordgo"
+)
+
+const MessageLength = 1950
+
+type Bdiscord struct {
+	*bridge.Config
+
+	c *discordgo.Session
+
+	nick            string
+	userID          string
+	guildID         string
+	webhookID       string
+	webhookToken    string
+	canEditWebhooks bool
+
+	channelsMutex  sync.RWMutex
+	channels       []*discordgo.Channel
+	channelInfoMap map[string]*config.ChannelInfo
+
+	membersMutex  sync.RWMutex
+	userMemberMap map[string]*discordgo.Member
+	nickMemberMap map[string]*discordgo.Member
+	webhookCache  map[string]string
+	webhookMutex  sync.RWMutex
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bdiscord{Config: cfg}
+	b.userMemberMap = make(map[string]*discordgo.Member)
+	b.nickMemberMap = make(map[string]*discordgo.Member)
+	b.channelInfoMap = make(map[string]*config.ChannelInfo)
+	b.webhookCache = make(map[string]string)
+	if b.GetString("WebhookURL") != "" {
+		b.Log.Debug("Configuring Discord Incoming Webhook")
+		b.webhookID, b.webhookToken = b.splitURL(b.GetString("WebhookURL"))
+	}
+	return b
+}
+
+func (b *Bdiscord) Connect() error {
+	var err error
+	var guildFound bool
+	token := b.GetString("Token")
+	b.Log.Info("Connecting")
+	if b.GetString("WebhookURL") == "" {
+		b.Log.Info("Connecting using token")
+	} else {
+		b.Log.Info("Connecting using webhookurl (for posting) and token")
+	}
+	if !strings.HasPrefix(b.GetString("Token"), "Bot ") {
+		token = "Bot " + b.GetString("Token")
+	}
+	// if we have a User token, remove the `Bot` prefix
+	if strings.HasPrefix(b.GetString("Token"), "User ") {
+		token = strings.Replace(b.GetString("Token"), "User ", "", -1)
+	}
+
+	b.c, err = discordgo.New(token)
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	b.c.AddHandler(b.messageCreate)
+	b.c.AddHandler(b.messageTyping)
+	b.c.AddHandler(b.memberUpdate)
+	b.c.AddHandler(b.messageUpdate)
+	b.c.AddHandler(b.messageDelete)
+	b.c.AddHandler(b.messageDeleteBulk)
+	b.c.AddHandler(b.memberAdd)
+	b.c.AddHandler(b.memberRemove)
+	err = b.c.Open()
+	if err != nil {
+		return err
+	}
+	guilds, err := b.c.UserGuilds(100, "", "")
+	if err != nil {
+		return err
+	}
+	userinfo, err := b.c.User("@me")
+	if err != nil {
+		return err
+	}
+	serverName := strings.Replace(b.GetString("Server"), "ID:", "", -1)
+	b.nick = userinfo.Username
+	b.userID = userinfo.ID
+	b.channelsMutex.Lock()
+	for _, guild := range guilds {
+		if guild.Name == serverName || guild.ID == serverName {
+			b.channels, err = b.c.GuildChannels(guild.ID)
+			if err != nil {
+				break
+			}
+			b.guildID = guild.ID
+			guildFound = true
+		}
+	}
+	b.channelsMutex.Unlock()
+	if !guildFound {
+		msg := fmt.Sprintf("Server \"%s\" not found", b.GetString("Server"))
+		err = errors.New(msg)
+		b.Log.Error(msg)
+		b.Log.Info("Possible values:")
+		for _, guild := range guilds {
+			b.Log.Infof("Server=\"%s\" # Server name", guild.Name)
+			b.Log.Infof("Server=\"%s\" # Server ID", guild.ID)
+		}
+	}
+	if err != nil {
+		return err
+	}
+
+	b.channelsMutex.RLock()
+	if b.GetString("WebhookURL") == "" {
+		for _, channel := range b.channels {
+			b.Log.Debugf("found channel %#v", channel)
+		}
+	} else {
+		manageWebhooks := discordgo.PermissionManageWebhooks
+		var channelsDenied []string
+		for _, info := range b.Channels {
+			id := b.getChannelID(info.Name) // note(qaisjp): this readlocks channelsMutex
+			b.Log.Debugf("Verifying PermissionManageWebhooks for %s with ID %s", info.ID, id)
+
+			perms, permsErr := b.c.UserChannelPermissions(userinfo.ID, id)
+			if permsErr != nil {
+				b.Log.Warnf("Failed to check PermissionManageWebhooks in channel \"%s\": %s", info.Name, permsErr.Error())
+			} else if perms&manageWebhooks == manageWebhooks {
+				continue
+			}
+			channelsDenied = append(channelsDenied, fmt.Sprintf("%#v", info.Name))
+		}
+
+		b.canEditWebhooks = len(channelsDenied) == 0
+		if b.canEditWebhooks {
+			b.Log.Info("Can manage webhooks; will edit channel for global webhook on send")
+		} else {
+			b.Log.Warn("Can't manage webhooks; won't edit channel for global webhook on send")
+			b.Log.Warn("Can't manage webhooks in channels: ", strings.Join(channelsDenied, ", "))
+		}
+	}
+	b.channelsMutex.RUnlock()
+
+	// Obtaining guild members and initializing nickname mapping.
+	b.membersMutex.Lock()
+	defer b.membersMutex.Unlock()
+	members, err := b.c.GuildMembers(b.guildID, "", 1000)
+	if err != nil {
+		b.Log.Error("Error obtaining server members: ", err)
+		return err
+	}
+	for _, member := range members {
+		if member == nil {
+			b.Log.Warnf("Skipping missing information for a user.")
+			continue
+		}
+		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 {
+	return b.c.Close()
+}
+
+func (b *Bdiscord) JoinChannel(channel config.ChannelInfo) error {
+	b.channelsMutex.Lock()
+	defer b.channelsMutex.Unlock()
+
+	b.channelInfoMap[channel.ID] = &channel
+	return nil
+}
+
+func (b *Bdiscord) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	origMsgID := msg.ID
+
+	channelID := b.getChannelID(msg.Channel)
+	if channelID == "" {
+		return "", fmt.Errorf("Could not find channelID for %v", msg.Channel)
+	}
+
+	if msg.Event == config.EventUserTyping {
+		if b.GetBool("ShowUserTyping") {
+			err := b.c.ChannelTyping(channelID)
+			return "", err
+		}
+		return "", nil
+	}
+
+	// Make a action /me of the message
+	if msg.Event == config.EventUserAction {
+		msg.Text = "_" + msg.Text + "_"
+	}
+
+	// use initial webhook configured for the entire Discord account
+	isGlobalWebhook := true
+	wID := b.webhookID
+	wToken := b.webhookToken
+
+	// check if have a channel specific webhook
+	b.channelsMutex.RLock()
+	if ci, ok := b.channelInfoMap[msg.Channel+b.Account]; ok {
+		if ci.Options.WebhookURL != "" {
+			wID, wToken = b.splitURL(ci.Options.WebhookURL)
+			isGlobalWebhook = false
+		}
+	}
+	b.channelsMutex.RUnlock()
+
+	// Use webhook to send the message
+	if wID != "" && msg.Event != config.EventMsgDelete {
+		// skip events
+		if msg.Event != "" && msg.Event != config.EventUserAction && msg.Event != config.EventJoinLeave && msg.Event != config.EventTopicChange {
+			return "", nil
+		}
+
+		// If we are editing a message, delete the old message
+		if msg.ID != "" {
+			msg.ID = b.getCacheID(msg.ID)
+			b.Log.Debugf("Deleting edited webhook message")
+			err := b.c.ChannelMessageDelete(channelID, msg.ID)
+			if err != nil {
+				b.Log.Errorf("Could not delete edited webhook message: %s", err)
+			}
+		}
+
+		b.Log.Debugf("Broadcasting using Webhook")
+
+		// skip empty messages
+		if msg.Text == "" && (msg.Extra == nil || len(msg.Extra["file"]) == 0) {
+			b.Log.Debugf("Skipping empty message %#v", msg)
+			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]
+		}
+		// if we have a global webhook for this Discord account, and permission
+		// to modify webhooks (previously verified), then set its channel to
+		// the message channel before using it
+		// TODO: this isn't necessary if the last message from this webhook was
+		// sent to the current channel
+		if isGlobalWebhook && b.canEditWebhooks {
+			b.Log.Debugf("Setting webhook channel to \"%s\"", msg.Channel)
+			_, err := b.c.WebhookEdit(wID, "", "", channelID)
+			if err != nil {
+				b.Log.Errorf("Could not set webhook channel: %s", err)
+				return "", err
+			}
+		}
+		b.Log.Debugf("Processing webhook sending for message %#v", msg)
+		msg, err := b.webhookSend(&msg, wID, wToken)
+		if err != nil {
+			b.Log.Errorf("Could not broadcast via webook for message %#v: %s", msg, err)
+			return "", err
+		}
+		if msg == nil {
+			return "", nil
+		}
+
+		b.updateCacheID(origMsgID, msg.ID)
+		return msg.ID, nil
+	}
+
+	b.Log.Debugf("Broadcasting using token (API)")
+
+	// Delete message
+	if msg.Event == config.EventMsgDelete {
+		if msg.ID == "" {
+			return "", nil
+		}
+		msg.ID = b.getCacheID(msg.ID)
+		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)
+			if _, err := b.c.ChannelMessageSend(channelID, rmsg.Username+rmsg.Text); err != nil {
+				b.Log.Errorf("Could not send message %#v: %s", rmsg, err)
+			}
+		}
+		// 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, nil
+}
+
+// useWebhook returns true if we have a webhook defined somewhere
+func (b *Bdiscord) useWebhook() bool {
+	if b.GetString("WebhookURL") != "" {
+		return true
+	}
+
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+
+	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
+		}
+	}
+
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+
+	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: %s", err)
+		}
+	}
+	return "", nil
+}
+
+// webhookSend send one or more message via webhook, taking care of file
+// uploads (from slack, telegram or mattermost).
+// Returns messageID and error.
+func (b *Bdiscord) webhookSend(msg *config.Message, webhookID, token string) (*discordgo.Message, error) {
+	var (
+		res *discordgo.Message
+		err error
+	)
+
+	// If avatar is unset, check if UseLocalAvatar contains the message's
+	// account or protocol, and if so, try to find a local avatar
+	if msg.Avatar == "" {
+		for _, val := range b.GetStringSlice("UseLocalAvatar") {
+			if msg.Protocol == val || msg.Account == val {
+				if avatar := b.findAvatar(msg); avatar != "" {
+					msg.Avatar = avatar
+				}
+				break
+			}
+		}
+	}
+
+	// WebhookParams can have either `Content` or `File`.
+
+	// We can't send empty messages.
+	if msg.Text != "" {
+		res, err = b.c.WebhookExecute(
+			webhookID,
+			token,
+			true,
+			&discordgo.WebhookParams{
+				Content:   msg.Text,
+				Username:  msg.Username,
+				AvatarURL: msg.Avatar,
+			},
+		)
+		if err != nil {
+			b.Log.Errorf("Could not send text (%s) for message %#v: %s", msg.Text, msg, err)
+		}
+	}
+
+	if msg.Extra != nil {
+		for _, f := range msg.Extra["file"] {
+			fi := f.(config.FileInfo)
+			file := discordgo.File{
+				Name:        fi.Name,
+				ContentType: "",
+				Reader:      bytes.NewReader(*fi.Data),
+			}
+			content := ""
+			if msg.Text == "" {
+				content = fi.Comment
+			}
+			_, e2 := b.c.WebhookExecute(
+				webhookID,
+				token,
+				false,
+				&discordgo.WebhookParams{
+					Username:  msg.Username,
+					AvatarURL: msg.Avatar,
+					File:      &file,
+					Content:   content,
+				},
+			)
+			if e2 != nil {
+				b.Log.Errorf("Could not send file %#v for message %#v: %s", file, msg, e2)
+			}
+		}
+	}
+	return res, err
+}
+
+func (b *Bdiscord) findAvatar(m *config.Message) string {
+	member, err := b.getGuildMemberByNick(m.Username)
+	if err != nil {
+		return ""
+	}
+	return member.User.AvatarURL("")
+}

bridge/discord/handlers.go

@@ -0,0 +1,232 @@
+package bdiscord
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/matterbridge/discordgo"
+)
+
+func (b *Bdiscord) messageDelete(s *discordgo.Session, m *discordgo.MessageDelete) { //nolint:unparam
+	rmsg := config.Message{Account: b.Account, ID: m.ID, Event: config.EventMsgDelete, Text: config.EventMsgDelete}
+	rmsg.Channel = b.getChannelName(m.ChannelID)
+
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+// TODO(qaisjp): if other bridges support bulk deletions, it could be fanned out centrally
+func (b *Bdiscord) messageDeleteBulk(s *discordgo.Session, m *discordgo.MessageDeleteBulk) { //nolint:unparam
+	for _, msgID := range m.Messages {
+		rmsg := config.Message{
+			Account: b.Account,
+			ID:      msgID,
+			Event:   config.EventMsgDelete,
+			Text:    config.EventMsgDelete,
+			Channel: b.getChannelName(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) messageTyping(s *discordgo.Session, m *discordgo.TypingStart) {
+	if !b.GetBool("ShowUserTyping") {
+		return
+	}
+
+	// Ignore our own typing messages
+	if m.UserID == b.userID {
+		return
+	}
+
+	rmsg := config.Message{Account: b.Account, Event: config.EventUserTyping}
+	rmsg.Channel = b.getChannelName(m.ChannelID)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) { //nolint:unparam
+	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")
+		msg := &discordgo.MessageCreate{
+			Message: m.Message,
+		}
+		b.messageCreate(s, msg)
+	}
+}
+
+func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) { //nolint:unparam
+	var err error
+
+	// not relay our own messages
+	if m.Author.Username == b.nick {
+		return
+	}
+	// if using webhooks, do not relay if it's ours
+	if b.useWebhook() && m.Author.Bot && b.isWebhookID(m.Author.ID) {
+		return
+	}
+
+	// add the url of the attachments to content
+	if len(m.Attachments) > 0 {
+		for _, attach := range m.Attachments {
+			m.Content = m.Content + "\n" + attach.URL
+		}
+	}
+
+	rmsg := config.Message{Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg", UserID: m.Author.ID, ID: m.ID}
+
+	if m.Content != "" {
+		b.Log.Debugf("== Receiving event %#v", m.Message)
+		m.Message.Content = b.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)
+
+	fromWebhook := m.WebhookID != ""
+	if !fromWebhook && !b.GetBool("UseUserName") {
+		rmsg.Username = b.getNick(m.Author, m.GuildID)
+	} else {
+		rmsg.Username = m.Author.Username
+		if !fromWebhook && b.GetBool("UseDiscriminator") {
+			rmsg.Username += "#" + m.Author.Discriminator
+		}
+	}
+
+	// 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 += handleEmbed(embed)
+		}
+	}
+
+	// no empty messages
+	if rmsg.Text == "" {
+		return
+	}
+
+	// do we have a /me action
+	var ok bool
+	rmsg.Text, ok = b.replaceAction(rmsg.Text)
+	if ok {
+		rmsg.Event = config.EventUserAction
+	}
+
+	// Replace emotes
+	rmsg.Text = replaceEmotes(rmsg.Text)
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
+	if m.Member == nil {
+		b.Log.Warnf("Received member update with no member information: %#v", m)
+	}
+
+	b.membersMutex.Lock()
+	defer b.membersMutex.Unlock()
+
+	if currMember, 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,
+		)
+		delete(b.nickMemberMap, currMember.User.Username)
+		delete(b.nickMemberMap, currMember.Nick)
+		delete(b.userMemberMap, m.Member.User.ID)
+	}
+	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
+	}
+}
+
+func (b *Bdiscord) memberAdd(s *discordgo.Session, m *discordgo.GuildMemberAdd) {
+	if m.Member == nil {
+		b.Log.Warnf("Received member update with no member information: %#v", m)
+		return
+	}
+	username := m.Member.User.Username
+	if m.Member.Nick != "" {
+		username = m.Member.Nick
+	}
+
+	rmsg := config.Message{
+		Account:  b.Account,
+		Event:    config.EventJoinLeave,
+		Username: "system",
+		Text:     username + " joins",
+	}
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func (b *Bdiscord) memberRemove(s *discordgo.Session, m *discordgo.GuildMemberRemove) {
+	if m.Member == nil {
+		b.Log.Warnf("Received member update with no member information: %#v", m)
+		return
+	}
+	username := m.Member.User.Username
+	if m.Member.Nick != "" {
+		username = m.Member.Nick
+	}
+
+	rmsg := config.Message{
+		Account:  b.Account,
+		Event:    config.EventJoinLeave,
+		Username: "system",
+		Text:     username + " leaves",
+	}
+	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+func handleEmbed(embed *discordgo.MessageEmbed) string {
+	var t []string
+	var result string
+
+	t = append(t, embed.Title)
+	t = append(t, embed.Description)
+	t = append(t, embed.URL)
+
+	i := 0
+	for _, e := range t {
+		if e == "" {
+			continue
+		}
+
+		i++
+		if i == 1 {
+			result += " embed: " + e
+			continue
+		}
+
+		result += " - " + e
+	}
+
+	if result != "" {
+		result += "\n"
+	}
+
+	return result
+}

bridge/discord/handlers_test.go

@@ -0,0 +1,58 @@
+package bdiscord
+
+import (
+	"testing"
+
+	"github.com/matterbridge/discordgo"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHandleEmbed(t *testing.T) {
+	testcases := map[string]struct {
+		embed  *discordgo.MessageEmbed
+		result string
+	}{
+		"allempty": {
+			embed:  &discordgo.MessageEmbed{},
+			result: "",
+		},
+		"one": {
+			embed: &discordgo.MessageEmbed{
+				Title: "blah",
+			},
+			result: " embed: blah\n",
+		},
+		"two": {
+			embed: &discordgo.MessageEmbed{
+				Title:       "blah",
+				Description: "blah2",
+			},
+			result: " embed: blah - blah2\n",
+		},
+		"three": {
+			embed: &discordgo.MessageEmbed{
+				Title:       "blah",
+				Description: "blah2",
+				URL:         "blah3",
+			},
+			result: " embed: blah - blah2 - blah3\n",
+		},
+		"twob": {
+			embed: &discordgo.MessageEmbed{
+				Description: "blah2",
+				URL:         "blah3",
+			},
+			result: " embed: blah2 - blah3\n",
+		},
+		"oneb": {
+			embed: &discordgo.MessageEmbed{
+				URL: "blah3",
+			},
+			result: " embed: blah3\n",
+		},
+	}
+
+	for name, tc := range testcases {
+		assert.Equalf(t, tc.result, handleEmbed(tc.embed), "Testcases %s", name)
+	}
+}

bridge/discord/helpers.go

@@ -0,0 +1,279 @@
+package bdiscord
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+	"unicode"
+
+	"github.com/matterbridge/discordgo"
+)
+
+func (b *Bdiscord) getNick(user *discordgo.User, guildID string) string {
+	b.membersMutex.RLock()
+	defer b.membersMutex.RUnlock()
+
+	if member, ok := b.userMemberMap[user.ID]; ok {
+		if member.Nick != "" {
+			// Only return if nick is set.
+			return member.Nick
+		}
+		// Otherwise return username.
+		return user.Username
+	}
+
+	// If we didn't find nick, search for it.
+	member, err := b.c.GuildMember(guildID, user.ID)
+	if err != nil {
+		b.Log.Warnf("Failed to fetch information for member %#v on guild %#v: %s", user, guildID, err)
+		return user.Username
+	} else if member == nil {
+		b.Log.Warnf("Got no information for member %#v", user)
+		return user.Username
+	}
+	b.userMemberMap[user.ID] = member
+	b.nickMemberMap[member.User.Username] = member
+	if member.Nick != "" {
+		b.nickMemberMap[member.Nick] = member
+		return member.Nick
+	}
+	return user.Username
+}
+
+func (b *Bdiscord) getGuildMemberByNick(nick string) (*discordgo.Member, error) {
+	b.membersMutex.RLock()
+	defer b.membersMutex.RUnlock()
+
+	if member, ok := b.nickMemberMap[nick]; ok {
+		return member, 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 {
+	if strings.Contains(name, "/") {
+		return b.getCategoryChannelID(name)
+	}
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+
+	idcheck := strings.Split(name, "ID:")
+	if len(idcheck) > 1 {
+		return idcheck[1]
+	}
+	for _, channel := range b.channels {
+		if channel.Name == name && channel.Type == discordgo.ChannelTypeGuildText {
+			return channel.ID
+		}
+	}
+	return ""
+}
+
+func (b *Bdiscord) getCategoryChannelID(name string) string {
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+	res := strings.Split(name, "/")
+	// shouldn't happen because function should be only called from getChannelID
+	if len(res) != 2 {
+		return ""
+	}
+	catName, chanName := res[0], res[1]
+	for _, channel := range b.channels {
+		// if we have a parentID, lookup the name of that parent (category)
+		// and if it matches return it
+		if channel.Name == chanName && channel.ParentID != "" {
+			for _, cat := range b.channels {
+				if cat.ID == channel.ParentID && cat.Name == catName {
+					return channel.ID
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func (b *Bdiscord) getChannelName(id string) string {
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+
+	for _, c := range b.channelInfoMap {
+		if c.Name == "ID:"+id {
+			// if we have ID: specified in our gateway configuration return this
+			return c.Name
+		}
+	}
+
+	for _, channel := range b.channels {
+		if channel.ID == id {
+			return b.getCategoryChannelName(channel.Name, channel.ParentID)
+		}
+	}
+	return ""
+}
+
+func (b *Bdiscord) getCategoryChannelName(name, parentID string) string {
+	var usesCat bool
+	// do we have a category configuration in the channel config
+	for _, c := range b.channelInfoMap {
+		if strings.Contains(c.Name, "/") {
+			usesCat = true
+			break
+		}
+	}
+	// configuration without category, return the normal channel name
+	if !usesCat {
+		return name
+	}
+	// create a category/channel response
+	for _, c := range b.channels {
+		if c.ID == parentID {
+			name = c.Name + "/" + name
+		}
+	}
+	return name
+}
+
+var (
+	// See https://discordapp.com/developers/docs/reference#message-formatting.
+	channelMentionRE = regexp.MustCompile("<#[0-9]+>")
+	userMentionRE    = regexp.MustCompile("@[^@\n]{1,32}")
+	emoteRE          = regexp.MustCompile(`<a?(:\w+:)\d+>`)
+)
+
+func (b *Bdiscord) replaceChannelMentions(text string) string {
+	replaceChannelMentionFunc := func(match string) string {
+		channelID := match[2 : len(match)-1]
+		channelName := b.getChannelName(channelID)
+
+		// If we don't have the channel refresh our list.
+		if channelName == "" {
+			var err error
+			b.channels, err = b.c.GuildChannels(b.guildID)
+			if err != nil {
+				return "#unknownchannel"
+			}
+			channelName = b.getChannelName(channelID)
+		}
+		return "#" + channelName
+	}
+	return channelMentionRE.ReplaceAllStringFunc(text, replaceChannelMentionFunc)
+}
+
+func (b *Bdiscord) replaceUserMentions(text string) string {
+	replaceUserMentionFunc := func(match string) string {
+		var (
+			err      error
+			member   *discordgo.Member
+			username string
+		)
+
+		usernames := enumerateUsernames(match[1:])
+		for _, username = range usernames {
+			b.Log.Debugf("Testing mention: '%s'", username)
+			member, err = b.getGuildMemberByNick(username)
+			if err == nil {
+				break
+			}
+		}
+		if member == nil {
+			return match
+		}
+		return strings.Replace(match, "@"+username, member.User.Mention(), 1)
+	}
+	return userMentionRE.ReplaceAllStringFunc(text, replaceUserMentionFunc)
+}
+
+func replaceEmotes(text string) string {
+	return emoteRE.ReplaceAllString(text, "$1")
+}
+
+func (b *Bdiscord) replaceAction(text string) (string, bool) {
+	length := len(text)
+	if length > 1 && text[0] == '_' && text[length-1] == '_' {
+		return text[1 : length-1], true
+	}
+	return text, false
+}
+
+// splitURL splits a webhookURL and returns the ID and token.
+func (b *Bdiscord) splitURL(url string) (string, string) {
+	const (
+		expectedWebhookSplitCount = 7
+		webhookIdxID              = 5
+		webhookIdxToken           = 6
+	)
+	webhookURLSplit := strings.Split(url, "/")
+	if len(webhookURLSplit) != expectedWebhookSplitCount {
+		b.Log.Fatalf("%s is no correct discord WebhookURL", url)
+	}
+	return webhookURLSplit[webhookIdxID], webhookURLSplit[webhookIdxToken]
+}
+
+// getcacheID tries to find a corresponding msgID in the webhook cache.
+// if not found returns the original request.
+func (b *Bdiscord) getCacheID(msgID string) string {
+	b.webhookMutex.RLock()
+	defer b.webhookMutex.RUnlock()
+	for k, v := range b.webhookCache {
+		if msgID == k {
+			return v
+		}
+	}
+	return msgID
+}
+
+// updateCacheID updates the cache so that the newID takes the place of
+// the original ID. This is used for edit/deletes in combination with webhooks
+// as editing a message via webhook means deleting the message and creating a
+// new message (with a new ID). This ID needs to be set instead of the original ID
+func (b *Bdiscord) updateCacheID(origID, newID string) {
+	b.webhookMutex.Lock()
+	match := false
+	for k, v := range b.webhookCache {
+		if v == origID {
+			delete(b.webhookCache, k)
+			b.webhookCache[origID] = newID
+			match = true
+			continue
+		}
+	}
+	if !match && origID != "" {
+		b.webhookCache[origID] = newID
+	}
+	b.webhookMutex.Unlock()
+}
+
+func enumerateUsernames(s string) []string {
+	onlySpace := true
+	for _, r := range s {
+		if !unicode.IsSpace(r) {
+			onlySpace = false
+			break
+		}
+	}
+	if onlySpace {
+		return nil
+	}
+
+	var username, endSpace string
+	var usernames []string
+	skippingSpace := true
+	for _, r := range s {
+		if unicode.IsSpace(r) {
+			if !skippingSpace {
+				usernames = append(usernames, username)
+				skippingSpace = true
+			}
+			endSpace += string(r)
+			username += string(r)
+		} else {
+			endSpace = ""
+			username += string(r)
+			skippingSpace = false
+		}
+	}
+	if endSpace == "" {
+		usernames = append(usernames, username)
+	}
+	return usernames
+}

bridge/discord/helpers_test.go

@@ -0,0 +1,46 @@
+package bdiscord
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnumerateUsernames(t *testing.T) {
+	testcases := map[string]struct {
+		match             string
+		expectedUsernames []string
+	}{
+		"only space": {
+			match:             "  \t\n \t",
+			expectedUsernames: nil,
+		},
+		"single word": {
+			match:             "veni",
+			expectedUsernames: []string{"veni"},
+		},
+		"single word with preceeding space": {
+			match:             " vidi",
+			expectedUsernames: []string{" vidi"},
+		},
+		"single word with suffixed space": {
+			match:             "vici ",
+			expectedUsernames: []string{"vici"},
+		},
+		"multi-word with varying whitespace": {
+			match: "just me  and\tmy friends \t",
+			expectedUsernames: []string{
+				"just",
+				"just me",
+				"just me  and",
+				"just me  and\tmy",
+				"just me  and\tmy friends",
+			},
+		},
+	}
+
+	for testname, testcase := range testcases {
+		foundUsernames := enumerateUsernames(testcase.match)
+		assert.Equalf(t, testcase.expectedUsernames, foundUsernames, "Should have found the expected usernames for testcase %s", testname)
+	}
+}

bridge/gitter/gitter.go

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

bridge/helper/helper.go

@@ -0,0 +1,258 @@
+package helper
+
+import (
+	"bytes"
+	"fmt"
+	"image/png"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"golang.org/x/image/webp"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/gomarkdown/markdown"
+	"github.com/gomarkdown/markdown/html"
+	"github.com/gomarkdown/markdown/parser"
+	"github.com/sirupsen/logrus"
+)
+
+// DownloadFile downloads the given non-authenticated URL.
+func DownloadFile(url string) (*[]byte, error) {
+	return DownloadFileAuth(url, "")
+}
+
+// DownloadFileAuth downloads the given URL using the specified authentication token.
+func DownloadFileAuth(url string, auth string) (*[]byte, error) {
+	var buf bytes.Buffer
+	client := &http.Client{
+		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 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
+}
+
+// HandleExtra manages the supplementary details stored inside a message's 'Extra' field map.
+func HandleExtra(msg *config.Message, general *config.Protocol) []config.Message {
+	extra := msg.Extra
+	rmsg := []config.Message{}
+	for _, f := range extra[config.EventFileFailureSize] {
+		fi := f.(config.FileInfo)
+		text := fmt.Sprintf("file %s too big to download (%#v > allowed size: %#v)", fi.Name, fi.Size, general.MediaDownloadSize)
+		rmsg = append(rmsg, config.Message{
+			Text:     text,
+			Username: "<system> ",
+			Channel:  msg.Channel,
+			Account:  msg.Account,
+		})
+	}
+	return rmsg
+}
+
+// GetAvatar constructs a URL for a given user-avatar if it is available in the cache.
+func GetAvatar(av map[string]string, userid string, general *config.Protocol) string {
+	if sha, ok := av[userid]; ok {
+		return general.MediaServerDownload + "/" + sha + "/" + userid + ".png"
+	}
+	return ""
+}
+
+// HandleDownloadSize checks a specified filename against the configured download blacklist
+// and checks a specified file-size against the configure limit.
+func HandleDownloadSize(logger *logrus.Entry, msg *config.Message, name string, size int64, general *config.Protocol) error {
+	// check blacklist here
+	for _, entry := range general.MediaDownloadBlackList {
+		if entry != "" {
+			re, err := regexp.Compile(entry)
+			if err != nil {
+				logger.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)
+			}
+		}
+	}
+	logger.Debugf("Trying to download %#v with size %#v", name, size)
+	if int(size) > general.MediaDownloadSize {
+		msg.Event = config.EventFileFailureSize
+		msg.Extra[msg.Event] = append(msg.Extra[msg.Event], config.FileInfo{
+			Name:    name,
+			Comment: msg.Text,
+			Size:    size,
+		})
+		return fmt.Errorf("File %#v to large to download (%#v). MediaDownloadSize is %#v", name, size, general.MediaDownloadSize)
+	}
+	return nil
+}
+
+// HandleDownloadData adds the data for a remote file into a Matterbridge gateway message.
+func HandleDownloadData(logger *logrus.Entry, msg *config.Message, name, comment, url string, data *[]byte, general *config.Protocol) {
+	var avatar bool
+	logger.Debugf("Download OK %#v %#v", name, len(*data))
+	if msg.Event == config.EventAvatarDownload {
+		avatar = true
+	}
+	msg.Extra["file"] = append(msg.Extra["file"], config.FileInfo{
+		Name:    name,
+		Data:    data,
+		URL:     url,
+		Comment: comment,
+		Avatar:  avatar,
+	})
+}
+
+var emptyLineMatcher = regexp.MustCompile("\n+")
+
+// RemoveEmptyNewLines collapses consecutive newline characters into a single one and
+// trims any preceding or trailing newline characters as well.
+func RemoveEmptyNewLines(msg string) string {
+	return emptyLineMatcher.ReplaceAllString(strings.Trim(msg, "\n"), "\n")
+}
+
+// ClipMessage trims a message to the specified length if it exceeds it and adds a warning
+// to the message in case it does so.
+func ClipMessage(text string, length int) string {
+	const clippingMessage = " <clipped message>"
+	if len(text) > length {
+		text = text[:length-len(clippingMessage)]
+		if r, size := utf8.DecodeLastRuneInString(text); r == utf8.RuneError {
+			text = text[:len(text)-size]
+		}
+		text += clippingMessage
+	}
+	return text
+}
+
+// ParseMarkdown takes in an input string as markdown and parses it to html
+func ParseMarkdown(input string) string {
+	extensions := parser.HardLineBreak | parser.NoIntraEmphasis
+	markdownParser := parser.NewWithExtensions(extensions)
+	renderer := html.NewRenderer(html.RendererOptions{
+		Flags: 0,
+	})
+	parsedMarkdown := markdown.ToHTML([]byte(input), markdownParser, renderer)
+	res := string(parsedMarkdown)
+	res = strings.TrimPrefix(res, "<p>")
+	res = strings.TrimSuffix(res, "</p>\n")
+	return res
+}
+
+// ConvertWebPToPNG converts input data (which should be WebP format) to PNG format
+func ConvertWebPToPNG(data *[]byte) error {
+	r := bytes.NewReader(*data)
+	m, err := webp.Decode(r)
+	if err != nil {
+		return err
+	}
+	var output []byte
+	w := bytes.NewBuffer(output)
+	if err := png.Encode(w, m); err != nil {
+		return err
+	}
+	*data = w.Bytes()
+	return nil
+}
+
+// CanConvertTgsToX Checks whether the external command necessary for ConvertTgsToX works.
+func CanConvertTgsToX() error {
+	// We depend on the fact that `lottie_convert.py --help` has exit status 0.
+	// Hyrum's Law predicted this, and Murphy's Law predicts that this will break eventually.
+	// However, there is no alternative like `lottie_convert.py --is-properly-installed`
+	cmd := exec.Command("lottie_convert.py", "--help")
+	return cmd.Run()
+}
+
+// ConvertTgsToWebP convert input data (which should be tgs format) to WebP format
+// This relies on an external command, which is ugly, but works.
+func ConvertTgsToX(data *[]byte, outputFormat string, logger *logrus.Entry) error {
+	// lottie can't handle input from a pipe, so write to a temporary file:
+	tmpFile, err := ioutil.TempFile(os.TempDir(), "matterbridge-lottie-*.tgs")
+	if err != nil {
+		return err
+	}
+	tmpFileName := tmpFile.Name()
+	defer func() {
+		if removeErr := os.Remove(tmpFileName); removeErr != nil {
+			logger.Errorf("Could not delete temporary file %s: %v", tmpFileName, removeErr)
+		}
+	}()
+
+	if _, writeErr := tmpFile.Write(*data); writeErr != nil {
+		return writeErr
+	}
+	// Must close before calling lottie to avoid data races:
+	if closeErr := tmpFile.Close(); closeErr != nil {
+		return closeErr
+	}
+
+	// Call lottie to transform:
+	cmd := exec.Command("lottie_convert.py", "--input-format", "lottie", "--output-format", outputFormat, tmpFileName, "/dev/stdout")
+	cmd.Stderr = nil
+	// NB: lottie writes progress into to stderr in all cases.
+	stdout, stderr := cmd.Output()
+	if stderr != nil {
+		// 'stderr' already contains some parts of Stderr, because it was set to 'nil'.
+		return stderr
+	}
+
+	*data = stdout
+	return nil
+}

bridge/helper/helper_test.go

@@ -0,0 +1,126 @@
+package helper
+
+import (
+	"io/ioutil"
+	"os"
+	"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)
+	}
+}
+
+func TestConvertWebPToPNG(t *testing.T) {
+	if os.Getenv("LOCAL_TEST") == "" {
+		t.Skip()
+	}
+	input, err := ioutil.ReadFile("test.webp")
+	if err != nil {
+		t.Fail()
+	}
+	d := &input
+	err = ConvertWebPToPNG(d)
+	if err != nil {
+		t.Fail()
+	}
+	err = ioutil.WriteFile("test.png", *d, 0644)
+	if err != nil {
+		t.Fail()
+	}
+}

bridge/irc/handlers.go

@@ -0,0 +1,238 @@
+package birc
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/lrstanley/girc"
+	"github.com/missdeer/golib/ic"
+	"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"
+)
+
+func (b *Birc) handleCharset(msg *config.Message) error {
+	if b.GetString("Charset") != "" {
+		switch b.GetString("Charset") {
+		case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
+			msg.Text = ic.ConvertString("utf-8", b.GetString("Charset"), msg.Text)
+		default:
+			buf := new(bytes.Buffer)
+			w, err := charset.NewWriter(b.GetString("Charset"), buf)
+			if err != nil {
+				b.Log.Errorf("charset from utf-8 conversion failed: %s", err)
+				return err
+			}
+			fmt.Fprint(w, msg.Text)
+			w.Close()
+			msg.Text = buf.String()
+		}
+	}
+	return nil
+}
+
+// handleFiles returns true if we have handled the files, otherwise return false
+func (b *Birc) handleFiles(msg *config.Message) bool {
+	if msg.Extra == nil {
+		return false
+	}
+	for _, rmsg := range helper.HandleExtra(msg, b.General) {
+		b.Local <- rmsg
+	}
+	if len(msg.Extra["file"]) == 0 {
+		return false
+	}
+	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 true
+}
+
+func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
+	if len(event.Params) == 0 {
+		b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
+		return
+	}
+	channel := strings.ToLower(event.Params[0])
+	if event.Command == "KICK" && event.Params[1] == b.Nick {
+		b.Log.Infof("Got kicked from %s by %s", channel, event.Source.Name)
+		time.Sleep(time.Duration(b.GetInt("RejoinDelay")) * time.Second)
+		b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: channel, Account: b.Account, Event: config.EventRejoinChannels}
+		return
+	}
+	if event.Command == "QUIT" {
+		if event.Source.Name == b.Nick && strings.Contains(event.Last(), "Ping timeout") {
+			b.Log.Infof("%s reconnecting ..", b.Account)
+			b.Remote <- config.Message{Username: "system", Text: "reconnect", Channel: channel, Account: b.Account, Event: config.EventFailure}
+			return
+		}
+	}
+	if event.Source.Name != b.Nick {
+		if b.GetBool("nosendjoinpart") {
+			return
+		}
+		msg := config.Message{Username: "system", Text: event.Source.Name + " " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
+		if b.GetBool("verbosejoinpart") {
+			b.Log.Debugf("<= Sending verbose JOIN_LEAVE event from %s to gateway", b.Account)
+			msg = config.Message{Username: "system", Text: event.Source.Name + " (" + event.Source.Ident + "@" + event.Source.Host + ") " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
+		} else {
+			b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
+		}
+		b.Log.Debugf("<= Message is %#v", msg)
+		b.Remote <- msg
+		return
+	}
+	b.Log.Debugf("handle %#v", event)
+}
+
+func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
+	b.Log.Debug("Registering callbacks")
+	i := b.i
+	b.Nick = event.Params[0]
+
+	i.Handlers.Add("PRIVMSG", b.handlePrivMsg)
+	i.Handlers.Add("CTCP_ACTION", b.handlePrivMsg)
+	i.Handlers.Add(girc.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
+	i.Handlers.Add(girc.NOTICE, b.handleNotice)
+	i.Handlers.Add("JOIN", b.handleJoinPart)
+	i.Handlers.Add("PART", b.handleJoinPart)
+	i.Handlers.Add("QUIT", b.handleJoinPart)
+	i.Handlers.Add("KICK", b.handleJoinPart)
+}
+
+func (b *Birc) handleNickServ() {
+	if !b.GetBool("UseSASL") && b.GetString("NickServNick") != "" && b.GetString("NickServPassword") != "" {
+		b.Log.Debugf("Sending identify to nickserv %s", b.GetString("NickServNick"))
+		b.i.Cmd.Message(b.GetString("NickServNick"), "IDENTIFY "+b.GetString("NickServPassword"))
+	}
+	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
+}
+
+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)
+	}
+}
+
+func (b *Birc) handleOther(client *girc.Client, event girc.Event) {
+	if b.GetInt("DebugLevel") == 1 {
+		if event.Command != "CLIENT_STATE_UPDATED" &&
+			event.Command != "CLIENT_GENERAL_UPDATED" {
+			b.Log.Debugf("%#v", event.String())
+		}
+		return
+	}
+	switch event.Command {
+	case "372", "375", "376", "250", "251", "252", "253", "254", "255", "265", "266", "002", "003", "004", "005":
+		return
+	}
+	b.Log.Debugf("%#v", event.String())
+}
+
+func (b *Birc) handleOtherAuth(client *girc.Client, event girc.Event) {
+	b.handleNickServ()
+	b.handleRunCommands()
+	// we are now fully connected
+	// only send on first connection
+	if b.FirstConnection {
+		b.connected <- nil
+	}
+}
+
+func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
+	if b.skipPrivMsg(event) {
+		return
+	}
+	rmsg := config.Message{Username: event.Source.Name, Channel: strings.ToLower(event.Params[0]), Account: b.Account, UserID: event.Source.Ident + "@" + event.Source.Host}
+	b.Log.Debugf("== Receiving PRIVMSG: %s %s %#v", event.Source.Name, event.Last(), event)
+
+	// set action event
+	if event.IsAction() {
+		rmsg.Event = config.EventUserAction
+	}
+
+	// strip action, we made an event if it was an action
+	rmsg.Text += event.StripAction()
+
+	// start detecting the charset
+	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) handleRunCommands() {
+	for _, cmd := range b.GetStringSlice("RunCommands") {
+		if err := b.i.Cmd.SendRaw(cmd); err != nil {
+			b.Log.Errorf("RunCommands %s failed: %s", cmd, err)
+		}
+		time.Sleep(time.Second)
+	}
+}
+
+func (b *Birc) handleTopicWhoTime(client *girc.Client, event girc.Event) {
+	parts := strings.Split(event.Params[2], "!")
+	t, err := strconv.ParseInt(event.Params[3], 10, 64)
+	if err != nil {
+		b.Log.Errorf("Invalid time stamp: %s", event.Params[3])
+	}
+	user := parts[0]
+	if len(parts) > 1 {
+		user += " [" + parts[1] + "]"
+	}
+	b.Log.Debugf("%s: Topic set by %s [%s]", event.Command, user, time.Unix(t, 0))
+}

bridge/irc/irc.go

@@ -0,0 +1,307 @@
+package birc
+
+import (
+	"crypto/tls"
+	"fmt"
+	"hash/crc32"
+	"net"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/lrstanley/girc"
+	stripmd "github.com/writeas/go-strip-markdown"
+
+	// 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
+	Nick                                      string
+	names                                     map[string][]string
+	connected                                 chan error
+	Local                                     chan config.Message // local queue for flood control
+	FirstConnection, authDone                 bool
+	MessageDelay, MessageQueue, MessageLength int
+
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Birc{}
+	b.Config = cfg
+	b.Nick = b.GetString("Nick")
+	b.names = make(map[string][]string)
+	b.connected = make(chan error)
+	if b.GetInt("MessageDelay") == 0 {
+		b.MessageDelay = 1300
+	} else {
+		b.MessageDelay = b.GetInt("MessageDelay")
+	}
+	if b.GetInt("MessageQueue") == 0 {
+		b.MessageQueue = 30
+	} else {
+		b.MessageQueue = b.GetInt("MessageQueue")
+	}
+	if b.GetInt("MessageLength") == 0 {
+		b.MessageLength = 400
+	} else {
+		b.MessageLength = b.GetInt("MessageLength")
+	}
+	b.FirstConnection = true
+	return b
+}
+
+func (b *Birc) Command(msg *config.Message) string {
+	if msg.Text == "!users" {
+		b.i.Handlers.Add(girc.RPL_NAMREPLY, b.storeNames)
+		b.i.Handlers.Add(girc.RPL_ENDOFNAMES, b.endNames)
+		b.i.Cmd.SendRaw("NAMES " + msg.Channel) //nolint:errcheck
+	}
+	return ""
+}
+
+func (b *Birc) Connect() error {
+	b.Local = make(chan config.Message, b.MessageQueue+10)
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+
+	i, err := b.getClient()
+	if err != nil {
+		return err
+	}
+
+	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.ERR_NOMOTD, b.handleOtherAuth)
+	i.Handlers.Add(girc.ALL_EVENTS, b.handleOther)
+	b.i = i
+
+	go b.doConnect()
+
+	err = <-b.connected
+	if err != nil {
+		return fmt.Errorf("connection failed %s", err)
+	}
+	b.Log.Info("Connection succeeded")
+	b.FirstConnection = false
+	if b.GetInt("DebugLevel") == 0 {
+		i.Handlers.Clear(girc.ALL_EVENTS)
+	}
+	go b.doSend()
+	return nil
+}
+
+func (b *Birc) Disconnect() error {
+	b.i.Close()
+	close(b.Local)
+	return nil
+}
+
+func (b *Birc) JoinChannel(channel config.ChannelInfo) error {
+	// need to check if we have nickserv auth done before joining channels
+	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) {
+	// ignore delete messages
+	if msg.Event == config.EventMsgDelete {
+		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")
+		return "", nil
+	}
+
+	// Execute a command
+	if strings.HasPrefix(msg.Text, "!") {
+		b.Command(&msg)
+	}
+
+	// convert to specified charset
+	if err := b.handleCharset(&msg); err != nil {
+		return "", err
+	}
+
+	// handle files, return if we're done here
+	if ok := b.handleFiles(&msg); ok {
+		return "", nil
+	}
+
+	var msgLines []string
+	if b.GetBool("StripMarkdown") {
+		msg.Text = stripmd.Strip(msg.Text)
+	}
+
+	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
+		}
+
+		msg.Text = msgLines[i]
+		b.Local <- msg
+	}
+	return "", nil
+}
+
+func (b *Birc) doConnect() {
+	for {
+		if err := b.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)
+		b.i.Handlers.Clear(girc.RPL_WELCOME)
+		b.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
+		})
+	}
+}
+
+func (b *Birc) doSend() {
+	rate := time.Millisecond * time.Duration(b.MessageDelay)
+	throttle := time.NewTicker(rate)
+	for msg := range b.Local {
+		<-throttle.C
+		username := msg.Username
+		if b.GetBool("Colornicks") && len(username) > 1 {
+			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)
+		}
+	}
+}
+
+// validateInput validates the server/port/nick configuration. Returns a *girc.Client if successful
+func (b *Birc) getClient() (*girc.Client, error) {
+	server, portstr, err := net.SplitHostPort(b.GetString("Server"))
+	if err != nil {
+		return nil, err
+	}
+	port, err := strconv.Atoi(portstr)
+	if err != nil {
+		return nil, err
+	}
+	// fix strict user handling of girc
+	user := b.GetString("Nick")
+	for !girc.IsValidUser(user) {
+		if len(user) == 1 || len(user) == 0 {
+			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}, //nolint:gosec
+		PingDelay:  time.Minute,
+		// skip gIRC internal rate limiting, since we have our own throttling
+		AllowFlood: true,
+	})
+	return i, nil
+}
+
+func (b *Birc) endNames(client *girc.Client, event girc.Event) {
+	channel := event.Params[1]
+	sort.Strings(b.names[channel])
+	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
+	for len(b.names[channel]) > maxNamesPerPost {
+		b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel][0:maxNamesPerPost]),
+			Channel: channel, Account: b.Account}
+		b.names[channel] = b.names[channel][maxNamesPerPost:]
+	}
+	b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel]),
+		Channel: channel, Account: b.Account}
+	b.names[channel] = nil
+	b.i.Handlers.Clear(girc.RPL_NAMREPLY)
+	b.i.Handlers.Clear(girc.RPL_ENDOFNAMES)
+}
+
+func (b *Birc) skipPrivMsg(event girc.Event) bool {
+	// Our nick can be changed
+	b.Nick = b.i.GetNick()
+
+	// freenode doesn't send 001 as first reply
+	if event.Command == "NOTICE" {
+		return true
+	}
+	// don't forward queries to the bot
+	if event.Params[0] == b.Nick {
+		return true
+	}
+	// don't forward message from ourself
+	if event.Source.Name == b.Nick {
+		return true
+	}
+	return false
+}
+
+func (b *Birc) nicksPerRow() int {
+	return 4
+}
+
+func (b *Birc) storeNames(client *girc.Client, event girc.Event) {
+	channel := event.Params[2]
+	b.names[channel] = append(
+		b.names[channel],
+		strings.Split(strings.TrimSpace(event.Last()), " ")...)
+}
+
+func (b *Birc) formatnicks(nicks []string) string {
+	return strings.Join(nicks, ", ") + " currently on IRC"
+}

bridge/keybase/handlers.go

@@ -0,0 +1,59 @@
+package bkeybase
+
+import (
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1"
+)
+
+func (b *Bkeybase) handleKeybase() {
+	sub, err := b.kbc.ListenForNewTextMessages()
+	if err != nil {
+		b.Log.Errorf("Error listening: %s", err.Error())
+	}
+
+	go func() {
+		for {
+			msg, err := sub.Read()
+			if err != nil {
+				b.Log.Errorf("failed to read message: %s", err.Error())
+			}
+
+			if msg.Message.Content.TypeName != "text" {
+				continue
+			}
+
+			if msg.Message.Sender.Username == b.kbc.GetUsername() {
+				continue
+			}
+
+			b.handleMessage(msg.Message)
+
+		}
+	}()
+}
+
+func (b *Bkeybase) handleMessage(msg chat1.MsgSummary) {
+	b.Log.Debugf("== Receiving event: %#v", msg)
+	if msg.Channel.TopicName != b.channel || msg.Channel.Name != b.team {
+		return
+	}
+
+	if msg.Sender.Username != b.kbc.GetUsername() {
+
+		// TODO download avatar
+
+		// Create our message
+		rmsg := config.Message{Username: msg.Sender.Username, Text: msg.Content.Text.Body, UserID: string(msg.Sender.Uid), Channel: msg.Channel.TopicName, ID: strconv.Itoa(int(msg.Id)), Account: b.Account}
+
+		// Text must be a string
+		if msg.Content.TypeName != "text" {
+			b.Log.Errorf("message is not text")
+			return
+		}
+
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", msg.Sender.Username, msg.Channel.Name)
+		b.Remote <- rmsg
+	}
+}

bridge/keybase/keybase.go

@@ -0,0 +1,106 @@
+package bkeybase
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/keybase/go-keybase-chat-bot/kbchat"
+)
+
+// Bkeybase bridge structure
+type Bkeybase struct {
+	kbc     *kbchat.API
+	user    string
+	channel string
+	team    string
+	*bridge.Config
+}
+
+// New initializes Bkeybase object and sets team
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bkeybase{Config: cfg}
+	b.team = b.Config.GetString("Team")
+	return b
+}
+
+// Connect starts keybase API and listener loop
+func (b *Bkeybase) Connect() error {
+	var err error
+	b.Log.Infof("Connecting %s", b.GetString("Team"))
+
+	// use default keybase location (`keybase`)
+	b.kbc, err = kbchat.Start(kbchat.RunOptions{})
+	if err != nil {
+		return err
+	}
+	b.user = b.kbc.GetUsername()
+	b.Log.Info("Connection succeeded")
+	go b.handleKeybase()
+	return nil
+}
+
+// Disconnect doesn't do anything for now
+func (b *Bkeybase) Disconnect() error {
+	return nil
+}
+
+// JoinChannel sets channel name in struct
+func (b *Bkeybase) JoinChannel(channel config.ChannelInfo) error {
+	if _, err := b.kbc.JoinChannel(b.team, channel.Name); err != nil {
+		return err
+	}
+	b.channel = channel.Name
+	return nil
+}
+
+// Send receives bridge messages and sends them to Keybase chat room
+func (b *Bkeybase) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Handle /me events
+	if msg.Event == config.EventUserAction {
+		msg.Text = "_" + msg.Text + "_"
+	}
+
+	// Delete message if we have an ID
+	// Delete message not supported by keybase go library yet
+
+	// Edit message if we have an ID
+	// kbchat lib does not support message editing yet
+
+	if len(msg.Extra["file"]) > 0 {
+		// Upload a file
+		dir, err := ioutil.TempDir("", "matterbridge")
+		if err != nil {
+			return "", err
+		}
+		defer os.RemoveAll(dir)
+
+		for _, f := range msg.Extra["file"] {
+			fname := f.(config.FileInfo).Name
+			fdata := *f.(config.FileInfo).Data
+			fcaption := f.(config.FileInfo).Comment
+			fpath := filepath.Join(dir, fname)
+
+			if err = ioutil.WriteFile(fpath, fdata, 0600); err != nil {
+				return "", err
+			}
+
+			_, _ = b.kbc.SendAttachmentByTeam(b.team, &b.channel, fpath, fcaption)
+		}
+
+		return "", nil
+	}
+
+	// Send regular message
+	text := msg.Username + msg.Text
+	resp, err := b.kbc.SendMessageByTeamName(b.team, &b.channel, text)
+	if err != nil {
+		return "", err
+	}
+	return strconv.Itoa(int(*resp.Result.MessageID)), err
+}

bridge/matrix/matrix.go

@@ -0,0 +1,434 @@
+package bmatrix
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"html"
+	"mime"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"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
+	htmlTag            *regexp.Regexp
+	htmlReplacementTag *regexp.Regexp
+	*bridge.Config
+}
+
+type httpError struct {
+	Errcode      string `json:"errcode"`
+	Err          string `json:"error"`
+	RetryAfterMs int    `json:"retry_after_ms"`
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmatrix{Config: cfg}
+	b.htmlTag = regexp.MustCompile("</.*?>")
+	b.htmlReplacementTag = regexp.MustCompile("<[^>]*>")
+	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 {
+retry:
+	resp, err := b.mc.JoinRoom(channel.Name, "", nil)
+	if err != nil {
+		httpErr := handleError(err)
+		if httpErr.Errcode == "M_LIMIT_EXCEEDED" {
+			b.Log.Infof("getting ratelimited by matrix, sleeping approx %d seconds before joining %s", httpErr.RetryAfterMs/1000, channel.Name)
+			time.Sleep((time.Duration(httpErr.RetryAfterMs) * time.Millisecond))
+
+			goto retry
+		}
+
+		return err
+	}
+
+	b.Lock()
+	b.RoomMap[resp.RoomID] = channel.Name
+	b.Unlock()
+
+	return nil
+}
+
+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) {
+			if _, err := b.mc.SendText(channel, rmsg.Username+rmsg.Text); err != nil {
+				b.Log.Errorf("sendText failed: %s", err)
+			}
+		}
+		// check if we have files to upload (from slack, telegram or mattermost)
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFiles(&msg, channel)
+		}
+	}
+
+	// Edit message if we have an ID
+	// matrix has no editing support
+
+	// Use notices to send join/leave events
+	if msg.Event == config.EventJoinLeave {
+		resp, err := b.mc.SendNotice(channel, msg.Username+msg.Text)
+		if err != nil {
+			return "", err
+		}
+		return resp.EventID, err
+	}
+
+	if b.GetBool("HTMLDisable") {
+		resp, err := b.mc.SendText(channel, msg.Username+msg.Text)
+		if err != nil {
+			return "", err
+		}
+		return resp.EventID, err
+	}
+
+	var username string
+	var plainUsername string
+	// check if we have a </tag>. if we have, we don't escape HTML. #696
+	if b.htmlTag.MatchString(msg.Username) {
+		username = msg.Username
+		// remove the HTML formatting for beautiful push messages #1188
+		plainUsername = b.htmlReplacementTag.ReplaceAllString(msg.Username, "")
+	} else {
+		username = html.EscapeString(msg.Username)
+		plainUsername = msg.Username
+	}
+
+	// Post normal message with HTML support (eg riot.im)
+	resp, err := b.mc.SendHTML(channel, plainUsername+msg.Text, username+helper.ParseMarkdown(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
+		}
+
+		// Create our message
+		rmsg := config.Message{
+			Username: ev.Sender[1:],
+			Channel:  channel,
+			Account:  b.Account,
+			UserID:   ev.Sender,
+			ID:       ev.ID,
+			Avatar:   b.getAvatarURL(ev.Sender),
+		}
+
+		// 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
+}
+
+// handleUploadFiles handles native upload of files.
+func (b *Bmatrix) handleUploadFiles(msg *config.Message, channel string) (string, error) {
+	for _, f := range msg.Extra["file"] {
+		if fi, ok := f.(config.FileInfo); ok {
+			b.handleUploadFile(msg, channel, &fi)
+		}
+	}
+	return "", nil
+}
+
+// handleUploadFile handles native upload of a file.
+func (b *Bmatrix) handleUploadFile(msg *config.Message, channel string, fi *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") ||
+		strings.Contains(mtype, "application") || strings.Contains(mtype, "audio")) {
+		return
+	}
+	if fi.Comment != "" {
+		_, err := b.mc.SendText(channel, msg.Username+fi.Comment)
+		if err != nil {
+			b.Log.Errorf("file comment failed: %#v", err)
+		}
+	} else {
+		// image and video uploads send no username, we have to do this ourself here #715
+		_, err := b.mc.SendText(channel, msg.Username)
+		if err != nil {
+			b.Log.Errorf("file comment failed: %#v", err)
+		}
+	}
+	b.Log.Debugf("uploading file: %s %s", fi.Name, mtype)
+	res, err := b.mc.UploadToContentRepo(content, mtype, int64(len(*fi.Data)))
+	if err != nil {
+		b.Log.Errorf("file upload failed: %#v", err)
+		return
+	}
+
+	switch {
+	case 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)
+		}
+	case 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)
+		}
+	case strings.Contains(mtype, "application"):
+		b.Log.Debugf("sendFile %s", res.ContentURI)
+		_, err = b.mc.SendFile(channel, fi.Name, res.ContentURI, mtype, uint(len(*fi.Data)))
+		if err != nil {
+			b.Log.Errorf("sendFile failed: %#v", err)
+		}
+	case strings.Contains(mtype, "audio"):
+		b.Log.Debugf("sendAudio %s", res.ContentURI)
+		_, err = b.mc.SendAudio(channel, fi.Name, res.ContentURI, mtype, uint(len(*fi.Data)))
+		if err != nil {
+			b.Log.Errorf("sendAudio failed: %#v", err)
+		}
+	}
+	b.Log.Debugf("result: %#v", res)
+}
+
+// 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
+}
+
+// getAvatarURL returns the avatar URL of the specified sender
+func (b *Bmatrix) getAvatarURL(sender string) string {
+	mxcURL, err := b.mc.GetSenderAvatarURL(sender)
+	if err != nil {
+		b.Log.Errorf("getAvatarURL failed: %s", err)
+		return ""
+	}
+	url := strings.ReplaceAll(mxcURL, "mxc://", b.GetString("Server")+"/_matrix/media/r0/thumbnail/")
+	if url != "" {
+		url += "?width=37&height=37&method=crop"
+	}
+	return url
+}
+
+func handleError(err error) *httpError {
+	mErr, ok := err.(matrix.HTTPError)
+	if !ok {
+		return &httpError{
+			Err: "not a HTTPError",
+		}
+	}
+
+	var httpErr httpError
+
+	if err := json.Unmarshal(mErr.Contents, &httpErr); err != nil {
+		return &httpError{
+			Err: "unmarshal failed",
+		}
+	}
+
+	return &httpErr
+}

bridge/mattermost/handlers.go

@@ -0,0 +1,199 @@
+package bmattermost
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/matterclient"
+	"github.com/mattermost/mattermost-server/v5/model"
+)
+
+// 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
+}
+
+func (b *Bmattermost) handleMatter() {
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleMatterHook(messages)
+	} else {
+		if b.GetString("Token") != "" {
+			b.Log.Debugf("Choosing token based receiving")
+		} else {
+			b.Log.Debugf("Choosing login/password based receiving")
+		}
+		// if for some reason we only want to sent stuff to mattermost but not receive, return
+		if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") != "" && b.GetString("Token") == "" && b.GetString("Login") == "" {
+			b.Log.Debugf("No WebhookBindAddress specified, only WebhookURL. You will not receive messages from mattermost, only sending is possible.")
+		}
+		go b.handleMatterClient(messages)
+	}
+	var ok bool
+	for message := range messages {
+		message.Avatar = helper.GetAvatar(b.avatarMap, message.UserID, b.General)
+		message.Account = b.Account
+		message.Text, ok = b.replaceAction(message.Text)
+		if ok {
+			message.Event = config.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) {
+	for message := range b.mc.MessageChan {
+		b.Log.Debugf("%#v", message.Raw.Data)
+
+		if b.skipMessage(message) {
+			b.Log.Debugf("Skipped message: %#v", message)
+			continue
+		}
+
+		// only download avatars if we have a place to upload them (configured mediaserver)
+		if b.General.MediaServerUpload != "" || b.General.MediaDownloadPath != "" {
+			b.handleDownloadAvatar(message.UserID, message.Channel)
+		}
+
+		b.Log.Debugf("== Receiving event %#v", message)
+
+		rmsg := &config.Message{
+			Username: message.Username,
+			UserID:   message.UserID,
+			Channel:  message.Channel,
+			Text:     message.Text,
+			ID:       message.Post.Id,
+			ParentID: message.Post.ParentId,
+			Extra:    make(map[string][]interface{}),
+		}
+
+		// handle mattermost post properties (override username and attachments)
+		b.handleProps(rmsg, message)
+
+		// 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
+		}
+
+		for _, id := range message.Post.FileIds {
+			err := b.handleDownloadFile(rmsg, id)
+			if err != nil {
+				b.Log.Errorf("download failed: %s", err)
+			}
+		}
+
+		// Use nickname instead of username if defined
+		if nick := b.mc.GetNickName(rmsg.UserID); nick != "" {
+			rmsg.Username = nick
+		}
+
+		messages <- rmsg
+	}
+}
+
+func (b *Bmattermost) handleMatterHook(messages chan *config.Message) {
+	for {
+		message := b.mh.Receive()
+		b.Log.Debugf("Receiving from matterhook %#v", message)
+		messages <- &config.Message{
+			UserID:   message.UserID,
+			Username: message.UserName,
+			Text:     message.Text,
+			Channel:  message.ChannelName,
+		}
+	}
+}
+
+// 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, msg.ParentID, []string{id})
+	}
+	return res, err
+}
+
+func (b *Bmattermost) handleProps(rmsg *config.Message, message *matterclient.Message) {
+	props := message.Post.Props
+	if props == nil {
+		return
+	}
+	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)
+				}
+			}
+		}
+	}
+}

bridge/mattermost/helpers.go

@@ -0,0 +1,225 @@
+package bmattermost
+
+import (
+	"strings"
+
+	"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/mattermost-server/v5/model"
+)
+
+func (b *Bmattermost) doConnectWebhookBind() error {
+	switch {
+	case b.GetString("WebhookURL") != "":
+		b.Log.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
+		b.mh = matterhook.New(b.GetString("WebhookURL"),
+			matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+				BindAddress: b.GetString("WebhookBindAddress")})
+	case b.GetString("Token") != "":
+		b.Log.Info("Connecting using token (sending)")
+		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")})
+	}
+	return nil
+}
+
+func (b *Bmattermost) doConnectWebhookURL() error {
+	b.Log.Info("Connecting using webhookurl (sending)")
+	b.mh = matterhook.New(b.GetString("WebhookURL"),
+		matterhook.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+			DisableServer: true})
+	if b.GetString("Token") != "" {
+		b.Log.Info("Connecting using token (receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+	} else if b.GetString("Login") != "" {
+		b.Log.Info("Connecting using login/password (receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+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.SkipVersionCheck = b.GetBool("SkipVersionCheck")
+	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
+}
+
+// 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
+			if err := b.mh.Send(matterMessage); err != nil {
+				b.Log.Errorf("sendWebhook failed: %s ", err)
+			}
+		}
+
+		// webhook doesn't support file uploads, so we add the url manually
+		if len(msg.Extra["file"]) > 0 {
+			for _, f := range msg.Extra["file"] {
+				fi := f.(config.FileInfo)
+				if fi.URL != "" {
+					msg.Text += fi.URL
+				}
+			}
+		}
+	}
+
+	iconURL := config.GetIconURL(&msg, b.GetString("iconurl"))
+	matterMessage := matterhook.OMessage{
+		IconURL:  iconURL,
+		Channel:  msg.Channel,
+		UserName: msg.Username,
+		Text:     msg.Text,
+		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 non-post messages
+	if message.Post == nil {
+		b.Log.Debugf("ignoring nil message.Post: %#v", message)
+		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/mattermost/mattermost.go

@@ -0,0 +1,154 @@
+package bmattermost
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/matterclient"
+	"github.com/42wim/matterbridge/matterhook"
+	"github.com/rs/xid"
+)
+
+type Bmattermost struct {
+	mh     *matterhook.Client
+	mc     *matterclient.MMClient
+	uuid   string
+	TeamID string
+	*bridge.Config
+	avatarMap map[string]string
+}
+
+const mattermostPlugin = "mattermost.plugin"
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmattermost{Config: cfg, avatarMap: make(map[string]string)}
+	b.uuid = xid.New().String()
+	return b
+}
+
+func (b *Bmattermost) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bmattermost) Connect() error {
+	if b.Account == mattermostPlugin {
+		return nil
+	}
+	if b.GetString("WebhookBindAddress") != "" {
+		if err := b.doConnectWebhookBind(); err != nil {
+			return err
+		}
+		go b.handleMatter()
+		return nil
+	}
+	switch {
+	case b.GetString("WebhookURL") != "":
+		if err := b.doConnectWebhookURL(); 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()
+	case b.GetString("Login") != "":
+		b.Log.Info("Connecting using login/password (sending and receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+		go b.handleMatter()
+	}
+	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" &&
+		b.GetString("Login") == "" && b.GetString("Token") == "" {
+		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Token/Login/Password/Server/Team configured")
+	}
+	return nil
+}
+
+func (b *Bmattermost) Disconnect() error {
+	return nil
+}
+
+func (b *Bmattermost) JoinChannel(channel config.ChannelInfo) error {
+	if b.Account == mattermostPlugin {
+		return nil
+	}
+	// we can only join channels using the API
+	if b.GetString("WebhookURL") == "" && b.GetString("WebhookBindAddress") == "" {
+		id := b.mc.GetChannelId(channel.Name, b.TeamID)
+		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) {
+	if b.Account == mattermostPlugin {
+		return "", nil
+	}
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	// Make a action /me of the message
+	if msg.Event == config.EventUserAction {
+		msg.Text = "*" + msg.Text + "*"
+	}
+
+	// map the file SHA to our user (caches the avatar)
+	if msg.Event == config.EventAvatarDownload {
+		return b.cacheAvatar(&msg)
+	}
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return b.sendWebhook(msg)
+	}
+
+	// Delete message
+	if msg.Event == config.EventMsgDelete {
+		if msg.ID == "" {
+			return "", nil
+		}
+		return msg.ID, b.mc.DeleteMessage(msg.ID)
+	}
+
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentID == "msg-parent-not-found" {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			if _, err := b.mc.PostMessage(b.mc.GetChannelId(rmsg.Channel, b.TeamID), rmsg.Username+rmsg.Text, msg.ParentID); err != nil {
+				b.Log.Errorf("PostMessage failed: %s", err)
+			}
+		}
+		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, msg.ParentID)
+}

bridge/msteams/handler.go

@@ -0,0 +1,101 @@
+package bmsteams
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+
+	msgraph "github.com/yaegashi/msgraph.go/beta"
+)
+
+func (b *Bmsteams) findFile(weburl string) (string, error) {
+	itemRB, err := b.gc.GetDriveItemByURL(b.ctx, weburl)
+	if err != nil {
+		return "", err
+	}
+	itemRB.Workbook().Worksheets()
+	b.gc.Workbooks()
+	item, err := itemRB.Request().Get(b.ctx)
+	if err != nil {
+		return "", err
+	}
+	if url, ok := item.GetAdditionalData("@microsoft.graph.downloadUrl"); ok {
+		return url.(string), nil
+	}
+	return "", nil
+}
+
+// handleDownloadFile handles file download
+func (b *Bmsteams) handleDownloadFile(rmsg *config.Message, filename, weburl string) error {
+	realURL, err := b.findFile(weburl)
+	if err != nil {
+		return err
+	}
+	// Actually download the file.
+	data, err := helper.DownloadFile(realURL)
+	if err != nil {
+		return fmt.Errorf("download %s failed %#v", weburl, err)
+	}
+
+	// If a comment is attached to the file(s) it is in the 'Text' field of the teams 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, filename, comment, weburl, data, b.General)
+	return nil
+}
+
+func (b *Bmsteams) handleAttachments(rmsg *config.Message, msg msgraph.ChatMessage) {
+	for _, a := range msg.Attachments {
+		//remove the attachment tags from the text
+		rmsg.Text = attachRE.ReplaceAllString(rmsg.Text, "")
+
+		//handle a code snippet (code block)
+		if *a.ContentType == "application/vnd.microsoft.card.codesnippet" {
+			b.handleCodeSnippet(rmsg, a)
+			continue
+		}
+
+		//handle the download
+		err := b.handleDownloadFile(rmsg, *a.Name, *a.ContentURL)
+		if err != nil {
+			b.Log.Errorf("download of %s failed: %s", *a.Name, err)
+		}
+	}
+}
+
+type AttachContent struct {
+	Language       string `json:"language"`
+	CodeSnippetURL string `json:"codeSnippetUrl"`
+}
+
+func (b *Bmsteams) handleCodeSnippet(rmsg *config.Message, attach msgraph.ChatMessageAttachment) {
+	var content AttachContent
+	err := json.Unmarshal([]byte(*attach.Content), &content)
+	if err != nil {
+		b.Log.Errorf("unmarshal codesnippet failed: %s", err)
+		return
+	}
+	s := strings.Split(content.CodeSnippetURL, "/")
+	if len(s) != 13 {
+		b.Log.Errorf("codesnippetUrl has unexpected size: %s", content.CodeSnippetURL)
+		return
+	}
+	resp, err := b.gc.Teams().Request().Client().Get(content.CodeSnippetURL)
+	if err != nil {
+		b.Log.Errorf("retrieving snippet content failed:%s", err)
+		return
+	}
+	defer resp.Body.Close()
+	res, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		b.Log.Errorf("reading snippet data failed: %s", err)
+		return
+	}
+	rmsg.Text = rmsg.Text + "\n```" + content.Language + "\n" + string(res) + "\n```\n"
+}

bridge/msteams/msteams.go

@@ -0,0 +1,224 @@
+package bmsteams
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/davecgh/go-spew/spew"
+
+	"github.com/mattn/godown"
+	msgraph "github.com/yaegashi/msgraph.go/beta"
+	"github.com/yaegashi/msgraph.go/msauth"
+
+	"golang.org/x/oauth2"
+)
+
+var defaultScopes = []string{"openid", "profile", "offline_access", "Group.Read.All", "Group.ReadWrite.All"}
+var attachRE = regexp.MustCompile(`<attachment id=.*?attachment>`)
+
+type Bmsteams struct {
+	gc    *msgraph.GraphServiceRequestBuilder
+	ctx   context.Context
+	botID string
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bmsteams{Config: cfg}
+}
+
+func (b *Bmsteams) Connect() error {
+	tokenCachePath := b.GetString("sessionFile")
+	if tokenCachePath == "" {
+		tokenCachePath = "msteams_session.json"
+	}
+	ctx := context.Background()
+	m := msauth.NewManager()
+	m.LoadFile(tokenCachePath) //nolint:errcheck
+	ts, err := m.DeviceAuthorizationGrant(ctx, b.GetString("TenantID"), b.GetString("ClientID"), defaultScopes, nil)
+	if err != nil {
+		return err
+	}
+	err = m.SaveFile(tokenCachePath)
+	if err != nil {
+		b.Log.Errorf("Couldn't save sessionfile in %s: %s", tokenCachePath, err)
+	}
+	// make file readable only for matterbridge user
+	err = os.Chmod(tokenCachePath, 0600)
+	if err != nil {
+		b.Log.Errorf("Couldn't change permissions for %s: %s", tokenCachePath, err)
+	}
+	httpClient := oauth2.NewClient(ctx, ts)
+	graphClient := msgraph.NewClient(httpClient)
+	b.gc = graphClient
+	b.ctx = ctx
+
+	err = b.setBotID()
+	if err != nil {
+		return err
+	}
+	b.Log.Info("Connection succeeded")
+	return nil
+}
+
+func (b *Bmsteams) Disconnect() error {
+	return nil
+}
+
+func (b *Bmsteams) JoinChannel(channel config.ChannelInfo) error {
+	go func(name string) {
+		for {
+			err := b.poll(name)
+			if err != nil {
+				b.Log.Errorf("polling failed for %s: %s. retrying in 5 seconds", name, err)
+			}
+			time.Sleep(time.Second * 5)
+		}
+	}(channel.Name)
+	return nil
+}
+
+func (b *Bmsteams) Send(msg config.Message) (string, error) {
+	b.Log.Debugf("=> Receiving %#v", msg)
+	if msg.ParentID != "" && msg.ParentID != "msg-parent-not-found" {
+		return b.sendReply(msg)
+	}
+	if msg.ParentID == "msg-parent-not-found" {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
+	}
+	ct := b.gc.Teams().ID(b.GetString("TeamID")).Channels().ID(msg.Channel).Messages().Request()
+	text := msg.Username + msg.Text
+	content := &msgraph.ItemBody{Content: &text}
+	rmsg := &msgraph.ChatMessage{Body: content}
+	res, err := ct.Add(b.ctx, rmsg)
+	if err != nil {
+		return "", err
+	}
+	return *res.ID, nil
+}
+
+func (b *Bmsteams) sendReply(msg config.Message) (string, error) {
+	ct := b.gc.Teams().ID(b.GetString("TeamID")).Channels().ID(msg.Channel).Messages().ID(msg.ParentID).Replies().Request()
+	// Handle prefix hint for unthreaded messages.
+
+	text := msg.Username + msg.Text
+	content := &msgraph.ItemBody{Content: &text}
+	rmsg := &msgraph.ChatMessage{Body: content}
+	res, err := ct.Add(b.ctx, rmsg)
+	if err != nil {
+		return "", err
+	}
+	return *res.ID, nil
+}
+
+func (b *Bmsteams) getMessages(channel string) ([]msgraph.ChatMessage, error) {
+	ct := b.gc.Teams().ID(b.GetString("TeamID")).Channels().ID(channel).Messages().Request()
+	rct, err := ct.Get(b.ctx)
+	if err != nil {
+		return nil, err
+	}
+	b.Log.Debugf("got %#v messages", len(rct))
+	return rct, nil
+}
+
+//nolint:gocognit
+func (b *Bmsteams) poll(channelName string) error {
+	msgmap := make(map[string]time.Time)
+	b.Log.Debug("getting initial messages")
+	res, err := b.getMessages(channelName)
+	if err != nil {
+		return err
+	}
+	for _, msg := range res {
+		msgmap[*msg.ID] = *msg.CreatedDateTime
+		if msg.LastModifiedDateTime != nil {
+			msgmap[*msg.ID] = *msg.LastModifiedDateTime
+		}
+	}
+	time.Sleep(time.Second * 5)
+	b.Log.Debug("polling for messages")
+	for {
+		res, err := b.getMessages(channelName)
+		if err != nil {
+			return err
+		}
+		for i := len(res) - 1; i >= 0; i-- {
+			msg := res[i]
+			if mtime, ok := msgmap[*msg.ID]; ok {
+				if mtime == *msg.CreatedDateTime && msg.LastModifiedDateTime == nil {
+					continue
+				}
+				if msg.LastModifiedDateTime != nil && mtime == *msg.LastModifiedDateTime {
+					continue
+				}
+			}
+
+			if b.GetBool("debug") {
+				b.Log.Debug("Msg dump: ", spew.Sdump(msg))
+			}
+
+			// skip non-user message for now.
+			if msg.From.User == nil {
+				continue
+			}
+
+			if *msg.From.User.ID == b.botID {
+				b.Log.Debug("skipping own message")
+				msgmap[*msg.ID] = *msg.CreatedDateTime
+				continue
+			}
+
+			msgmap[*msg.ID] = *msg.CreatedDateTime
+			if msg.LastModifiedDateTime != nil {
+				msgmap[*msg.ID] = *msg.LastModifiedDateTime
+			}
+			b.Log.Debugf("<= Sending message from %s on %s to gateway", *msg.From.User.DisplayName, b.Account)
+			text := b.convertToMD(*msg.Body.Content)
+			rmsg := config.Message{
+				Username: *msg.From.User.DisplayName,
+				Text:     text,
+				Channel:  channelName,
+				Account:  b.Account,
+				Avatar:   "",
+				UserID:   *msg.From.User.ID,
+				ID:       *msg.ID,
+				Extra:    make(map[string][]interface{}),
+			}
+
+			b.handleAttachments(&rmsg, msg)
+			b.Log.Debugf("<= Message is %#v", rmsg)
+			b.Remote <- rmsg
+		}
+		time.Sleep(time.Second * 5)
+	}
+}
+
+func (b *Bmsteams) setBotID() error {
+	req := b.gc.Me().Request()
+	r, err := req.Get(b.ctx)
+	if err != nil {
+		return err
+	}
+	b.botID = *r.ID
+	return nil
+}
+
+func (b *Bmsteams) convertToMD(text string) string {
+	if !strings.Contains(text, "<div>") {
+		return text
+	}
+	var sb strings.Builder
+	err := godown.Convert(&sb, strings.NewReader(text), nil)
+	if err != nil {
+		b.Log.Errorf("Couldn't convert message to markdown %s", text)
+		return text
+	}
+	return sb.String()
+}

bridge/nctalk/nctalk.go

@@ -0,0 +1,114 @@
+package nctalk
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+
+	talk "gomod.garykim.dev/nc-talk"
+	"gomod.garykim.dev/nc-talk/ocs"
+	"gomod.garykim.dev/nc-talk/room"
+	"gomod.garykim.dev/nc-talk/user"
+)
+
+type Btalk struct {
+	user  *user.TalkUser
+	rooms []Broom
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Btalk{Config: cfg}
+}
+
+type Broom struct {
+	room      *room.TalkRoom
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+}
+
+func (b *Btalk) Connect() error {
+	b.Log.Info("Connecting")
+	b.user = talk.NewUser(b.GetString("Server"), b.GetString("Login"), b.GetString("Password"))
+	_, err := b.user.Capabilities()
+	if err != nil {
+		b.Log.Error("Cannot Connect")
+		return err
+	}
+	b.Log.Info("Connected")
+	return nil
+}
+
+func (b *Btalk) Disconnect() error {
+	for _, r := range b.rooms {
+		r.ctxCancel()
+	}
+	return nil
+}
+
+func (b *Btalk) JoinChannel(channel config.ChannelInfo) error {
+	newRoom := Broom{
+		room: talk.NewRoom(b.user, channel.Name),
+	}
+	newRoom.ctx, newRoom.ctxCancel = context.WithCancel(context.Background())
+	c, err := newRoom.room.ReceiveMessages(newRoom.ctx)
+	if err != nil {
+		return err
+	}
+	b.rooms = append(b.rooms, newRoom)
+	go func() {
+		for msg := range c {
+			// ignore messages that are one of the following
+			// * not a message from a user
+			// * from ourselves
+			if msg.MessageType != ocs.MessageComment || msg.ActorID == b.user.User {
+				continue
+			}
+			remoteMessage := config.Message{
+				Text:     msg.Message,
+				Channel:  newRoom.room.Token,
+				Username: msg.ActorDisplayName,
+				UserID:   msg.ActorID,
+				Account:  b.Account,
+			}
+			// It is possible for the ID to not be set on older versions of Talk so we only set it if
+			// the ID is not blank
+			if msg.ID != 0 {
+				remoteMessage.ID = strconv.Itoa(msg.ID)
+			}
+			b.Log.Debugf("<= Message is %#v", remoteMessage)
+			b.Remote <- remoteMessage
+		}
+	}()
+	return nil
+}
+
+func (b *Btalk) Send(msg config.Message) (string, error) {
+	r := b.getRoom(msg.Channel)
+	if r == nil {
+		b.Log.Errorf("Could not find room for %v", msg.Channel)
+		return "", nil
+	}
+
+	// Talk currently only supports sending normal messages
+	if msg.Event != "" {
+		return "", nil
+	}
+	sentMessage, err := r.room.SendMessage(msg.Username + msg.Text)
+	if err != nil {
+		b.Log.Errorf("Could not send message to room %v from %v: %v", msg.Channel, msg.Username, err)
+		return "", nil
+	}
+	return strconv.Itoa(sentMessage.ID), nil
+}
+
+func (b *Btalk) getRoom(token string) *Broom {
+	for _, r := range b.rooms {
+		if r.room.Token == token {
+			return &r
+		}
+	}
+	return nil
+}

bridge/rocketchat/handlers.go

@@ -0,0 +1,97 @@
+package brocketchat
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/models"
+)
+
+func (b *Brocketchat) handleRocket() {
+	messages := make(chan *config.Message)
+	if b.GetString("WebhookBindAddress") != "" {
+		b.Log.Debugf("Choosing webhooks based receiving")
+		go b.handleRocketHook(messages)
+	} else {
+		b.Log.Debugf("Choosing login/password based receiving")
+		go b.handleRocketClient(messages)
+	}
+	for message := range messages {
+		message.Account = b.Account
+		b.Log.Debugf("<= Sending message from %s on %s to gateway", message.Username, b.Account)
+		b.Log.Debugf("<= Message is %#v", message)
+		b.Remote <- *message
+	}
+}
+
+func (b *Brocketchat) handleRocketHook(messages chan *config.Message) {
+	for {
+		message := b.rh.Receive()
+		b.Log.Debugf("Receiving from rockethook %#v", message)
+		// do not loop
+		if message.UserName == b.GetString("Nick") {
+			continue
+		}
+		messages <- &config.Message{
+			UserID:   message.UserID,
+			Username: message.UserName,
+			Text:     message.Text,
+			Channel:  message.ChannelName,
+		}
+	}
+}
+
+func (b *Brocketchat) handleStatusEvent(ev models.Message, rmsg *config.Message) bool {
+	switch ev.Type {
+	case "":
+		// this is a normal message, no processing needed
+		// return true so the message is not dropped
+		return true
+	case sUserJoined, sUserLeft:
+		rmsg.Event = config.EventJoinLeave
+		return true
+	case sRoomChangedTopic:
+		rmsg.Event = config.EventTopicChange
+		return true
+	}
+	b.Log.Debugf("Dropping message with unknown type: %s", ev.Type)
+	return false
+}
+
+func (b *Brocketchat) handleRocketClient(messages chan *config.Message) {
+	for message := range b.messageChan {
+		// skip messages with same ID, apparently messages get duplicated for an unknown reason
+		if _, ok := b.cache.Get(message.ID); ok {
+			continue
+		}
+		b.cache.Add(message.ID, true)
+		b.Log.Debugf("message %#v", message)
+		m := message
+		if b.skipMessage(&m) {
+			b.Log.Debugf("Skipped message: %#v", message)
+			continue
+		}
+
+		rmsg := &config.Message{Text: message.Msg,
+			Username: message.User.UserName,
+			Channel:  b.getChannelName(message.RoomID),
+			Account:  b.Account,
+			UserID:   message.User.ID,
+			ID:       message.ID,
+		}
+
+		// handleStatusEvent returns false if the message should be dropped
+		// in that case it is probably some modification to the channel we do not want to relay
+		if b.handleStatusEvent(m, rmsg) {
+			messages <- rmsg
+		}
+	}
+}
+
+func (b *Brocketchat) handleUploadFile(msg *config.Message) error {
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		if err := b.uploadFile(&fi, b.getChannelID(msg.Channel)); err != nil {
+			return err
+		}
+	}
+	return nil
+}

bridge/rocketchat/helpers.go

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

bridge/rocketchat/rocketchat.go

@@ -0,0 +1,181 @@
+package brocketchat
+
+import (
+	"errors"
+	"strings"
+	"sync"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/42wim/matterbridge/hook/rockethook"
+	"github.com/42wim/matterbridge/matterhook"
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/models"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/realtime"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/rest"
+)
+
+type Brocketchat struct {
+	mh    *matterhook.Client
+	rh    *rockethook.Client
+	c     *realtime.Client
+	r     *rest.Client
+	cache *lru.Cache
+	*bridge.Config
+	messageChan chan models.Message
+	channelMap  map[string]string
+	user        *models.User
+	sync.RWMutex
+}
+
+const (
+	sUserJoined       = "uj"
+	sUserLeft         = "ul"
+	sRoomChangedTopic = "room_changed_topic"
+)
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	newCache, err := lru.New(100)
+	if err != nil {
+		cfg.Log.Fatalf("Could not create LRU cache for rocketchat bridge: %v", err)
+	}
+	b := &Brocketchat{
+		Config:      cfg,
+		messageChan: make(chan models.Message),
+		channelMap:  make(map[string]string),
+		cache:       newCache,
+	}
+	b.Log.Debugf("enabling rocketchat")
+	return b
+}
+
+func (b *Brocketchat) Command(cmd string) string {
+	return ""
+}
+
+func (b *Brocketchat) Connect() error {
+	if b.GetString("WebhookBindAddress") != "" {
+		if err := b.doConnectWebhookBind(); err != nil {
+			return err
+		}
+		go b.handleRocket()
+		return nil
+	}
+	switch {
+	case b.GetString("WebhookURL") != "":
+		if err := b.doConnectWebhookURL(); err != nil {
+			return err
+		}
+		go b.handleRocket()
+		return nil
+	case b.GetString("Login") != "":
+		b.Log.Info("Connecting using login/password (sending and receiving)")
+		err := b.apiLogin()
+		if err != nil {
+			return err
+		}
+		go b.handleRocket()
+	}
+	if b.GetString("WebhookBindAddress") == "" && b.GetString("WebhookURL") == "" &&
+		b.GetString("Login") == "" {
+		return errors.New("no connection method found. See that you have WebhookBindAddress, WebhookURL or Login/Password/Server configured")
+	}
+	return nil
+}
+
+func (b *Brocketchat) Disconnect() error {
+	return nil
+}
+
+func (b *Brocketchat) JoinChannel(channel config.ChannelInfo) error {
+	if b.c == nil {
+		return nil
+	}
+	id, err := b.c.GetChannelId(strings.TrimPrefix(channel.Name, "#"))
+	if err != nil {
+		return err
+	}
+	b.Lock()
+	b.channelMap[id] = channel.Name
+	b.Unlock()
+	mychannel := &models.Channel{ID: id, Name: strings.TrimPrefix(channel.Name, "#")}
+	if err := b.c.JoinChannel(id); err != nil {
+		return err
+	}
+	if err := b.c.SubscribeToMessageStream(mychannel, b.messageChan); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (b *Brocketchat) Send(msg config.Message) (string, error) {
+	// strip the # if people has set this
+	msg.Channel = strings.TrimPrefix(msg.Channel, "#")
+	channel := &models.Channel{ID: b.getChannelID(msg.Channel), Name: msg.Channel}
+
+	// Make a action /me of the message
+	if msg.Event == config.EventUserAction {
+		msg.Text = "_" + msg.Text + "_"
+	}
+
+	// Delete message
+	if msg.Event == config.EventMsgDelete {
+		if msg.ID == "" {
+			return "", nil
+		}
+		return msg.ID, b.c.DeleteMessage(&models.Message{ID: msg.ID})
+	}
+
+	// Use webhook to send the message
+	if b.GetString("WebhookURL") != "" {
+		return "", b.sendWebhook(&msg)
+	}
+
+	// Prepend nick if configured
+	if b.GetBool("PrefixMessagesWithNick") {
+		msg.Text = msg.Username + msg.Text
+	}
+
+	// Edit message if we have an ID
+	if msg.ID != "" {
+		return msg.ID, b.c.EditMessage(&models.Message{ID: msg.ID, Msg: msg.Text, RoomID: b.getChannelID(msg.Channel)})
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			// strip the # if people has set this
+			rmsg.Channel = strings.TrimPrefix(rmsg.Channel, "#")
+			smsg := &models.Message{
+				RoomID: b.getChannelID(rmsg.Channel),
+				Msg:    rmsg.Username + rmsg.Text,
+				PostMessage: models.PostMessage{
+					Avatar: rmsg.Avatar,
+					Alias:  rmsg.Username,
+				},
+			}
+			if _, err := b.c.SendMessage(smsg); err != nil {
+				b.Log.Errorf("SendMessage failed: %s", err)
+			}
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return "", b.handleUploadFile(&msg)
+		}
+	}
+
+	smsg := &models.Message{
+		RoomID: channel.ID,
+		Msg:    msg.Text,
+		PostMessage: models.PostMessage{
+			Avatar: msg.Avatar,
+			Alias:  msg.Username,
+		},
+	}
+
+	rmsg, err := b.c.SendMessage(smsg)
+	if rmsg == nil {
+		return "", err
+	}
+	return rmsg.ID, err
+}

bridge/slack/handlers.go

@@ -0,0 +1,373 @@
+package bslack
+
+import (
+	"errors"
+	"fmt"
+	"html"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/slack-go/slack"
+)
+
+// ErrEventIgnored is for events that should be ignored
+var ErrEventIgnored = errors.New("this event message should ignored")
+
+func (b *Bslack) handleSlack() {
+	messages := make(chan *config.Message)
+	if b.GetString(incomingWebhookConfig) != "" && b.GetString(tokenConfig) == "" {
+		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 {
+		// don't do any action on deleted/typing messages
+		if message.Event != config.EventUserTyping && message.Event != config.EventMsgDelete {
+			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 = b.replaceb0rkedMarkDown(message.Text)
+			message.Text = html.UnescapeString(message.Text)
+
+			// Add the avatar
+			message.Avatar = b.users.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 != sHello && 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 == ErrEventIgnored {
+				continue
+			} else 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.channels.registerChannel(ev.Channel)
+		case *slack.ConnectedEvent:
+			b.si = ev.Info
+			b.channels.populateChannels(true)
+			b.users.populateUsers(true)
+		case *slack.InvalidAuthEvent:
+			b.Log.Fatalf("Invalid Token %#v", ev)
+		case *slack.ConnectionErrorEvent:
+			b.Log.Errorf("Connection failed %#v %#v", ev.Error(), ev.ErrorObj)
+		case *slack.MemberJoinedChannelEvent:
+			b.users.populateUser(ev.User)
+		case *slack.HelloEvent, *slack.LatencyReport, *slack.ConnectingEvent:
+			continue
+		default:
+			b.Log.Debugf("Unhandled incoming event: %T", ev)
+		}
+	}
+}
+
+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
+	case sChannelTopic, sChannelPurpose:
+		// Skip the event if our bot/user account changed the topic/purpose
+		if ev.User == b.si.User.ID {
+			return true
+		}
+	}
+
+	// Check for our callback ID
+	hasOurCallbackID := false
+	if len(ev.Blocks.BlockSet) == 1 {
+		block, ok := ev.Blocks.BlockSet[0].(*slack.SectionBlock)
+		hasOurCallbackID = ok && block.BlockID == "matterbridge_"+b.uuid
+	}
+
+	if ev.SubMessage != nil {
+		// It seems ev.SubMessage.Edited == nil when slack unfurls.
+		// Do not forward these messages. See Github issue #266.
+		if ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp &&
+			ev.SubMessage.Edited == nil {
+			return true
+		}
+		// see hidden subtypes at https://api.slack.com/events/message
+		// these messages are sent when we add a message to a thread #709
+		if ev.SubType == "message_replied" && ev.Hidden {
+			return true
+		}
+		if len(ev.SubMessage.Blocks.BlockSet) == 1 {
+			block, ok := ev.SubMessage.Blocks.BlockSet[0].(*slack.SectionBlock)
+			hasOurCallbackID = ok && block.BlockID == "matterbridge_"+b.uuid
+		}
+	}
+
+	// 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) || hasOurCallbackID {
+		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)
+		}
+		if ev.SubMessage != nil {
+			return nil, fmt.Errorf("message handling resulted in an empty message: %#v with submessage %#v", ev, ev.SubMessage)
+		}
+		return nil, fmt.Errorf("message handling resulted in an empty message: %#v", ev)
+	}
+	return rmsg, nil
+}
+
+func (b *Bslack) handleStatusEvent(ev *slack.MessageEvent, rmsg *config.Message) bool {
+	switch ev.SubType {
+	case sChannelJoined, sMemberJoined:
+		// 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:
+		b.channels.populateChannels(false)
+		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], false); err != nil {
+			b.Log.Errorf("Could not download incoming file: %#v", err)
+		}
+	}
+}
+
+func (b *Bslack) handleTypingEvent(ev *slack.UserTypingEvent) (*config.Message, error) {
+	if ev.User == b.si.User.ID {
+		return nil, ErrEventIgnored
+	}
+	channelInfo, err := b.channels.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, retry bool) 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 len(*data) != file.Size && !retry {
+		b.Log.Debugf("Data size (%d) is not equal to size declared (%d)\n", len(*data), file.Size)
+		time.Sleep(1 * time.Second)
+		return b.handleDownloadFile(rmsg, file, true)
+	}
+
+	// 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
+}
+
+// handleGetChannelMembers handles messages containing the GetChannelMembers event
+// Sends a message to the router containing *config.ChannelMembers
+func (b *Bslack) handleGetChannelMembers(rmsg *config.Message) bool {
+	if rmsg.Event != config.EventGetChannelMembers {
+		return false
+	}
+
+	cMembers := b.channels.getChannelMembers(b.users)
+
+	extra := make(map[string][]interface{})
+	extra[config.EventGetChannelMembers] = append(extra[config.EventGetChannelMembers], cMembers)
+	msg := config.Message{
+		Extra:   extra,
+		Event:   config.EventGetChannelMembers,
+		Account: b.Account,
+	}
+
+	b.Log.Debugf("sending msg to remote %#v", msg)
+	b.Remote <- msg
+
+	return true
+}
+
+// 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

@@ -0,0 +1,259 @@
+package bslack
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/sirupsen/logrus"
+	"github.com/slack-go/slack"
+)
+
+// 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.channels.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)
+		}
+	}
+
+	// For edits, only submessage has thread ts.
+	// Ensures edits to threaded messages maintain their prefix hint on the
+	// unthreaded end.
+	if ev.SubMessage != nil {
+		rmsg.ParentID = ev.SubMessage.ThreadTimestamp
+	}
+
+	if err = b.populateMessageWithUserInfo(ev, rmsg); err != nil {
+		return nil, err
+	}
+	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.users.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 = handleRateLimit(b.Log, err); err != nil {
+			b.Log.Errorf("Could not retrieve bot information: %#v", err)
+			return err
+		}
+	}
+	b.Log.Debugf("Found bot %#v", bot)
+
+	if bot.Name != "" {
+		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(`<(.*?)(\|.*?)?>`)
+	codeFenceRE      = regexp.MustCompile(`(?m)^` + "```" + `\w+$`)
+	topicOrPurposeRE = regexp.MustCompile(`(?s)(@.+) (cleared|set)(?: the)? channel (topic|purpose)(?:: (.*))?`)
+)
+
+func (b *Bslack) extractTopicOrPurpose(text string) (string, string) {
+	r := topicOrPurposeRE.FindStringSubmatch(text)
+	if len(r) == 5 {
+		action, updateType, extracted := r[2], r[3], r[4]
+		switch action {
+		case "set":
+			return updateType, extracted
+		case "cleared":
+			return updateType, ""
+		}
+	}
+	b.Log.Warnf("Encountered channel topic or purpose change message with unexpected format: %s", text)
+	return "unknown", ""
+}
+
+// @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.users.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) replaceb0rkedMarkDown(text string) string {
+	// taken from https://github.com/mattermost/mattermost-server/blob/master/app/slackimport.go
+	//
+	regexReplaceAllString := []struct {
+		regex *regexp.Regexp
+		rpl   string
+	}{
+		// bold
+		{
+			regexp.MustCompile(`(^|[\s.;,])\*(\S[^*\n]+)\*`),
+			"$1**$2**",
+		},
+		// strikethrough
+		{
+			regexp.MustCompile(`(^|[\s.;,])\~(\S[^~\n]+)\~`),
+			"$1~~$2~~",
+		},
+		// single paragraph blockquote
+		// Slack converts > character to &gt;
+		{
+			regexp.MustCompile(`(?sm)^&gt;`),
+			">",
+		},
+	}
+	for _, rule := range regexReplaceAllString {
+		text = rule.regex.ReplaceAllString(text, rule.rpl)
+	}
+	return text
+}
+
+func (b *Bslack) replaceCodeFence(text string) string {
+	return codeFenceRE.ReplaceAllString(text, "```")
+}
+
+// getUsersInConversation returns an array of userIDs that are members of channelID
+func (b *Bslack) getUsersInConversation(channelID string) ([]string, error) {
+	channelMembers := []string{}
+	for {
+		queryParams := &slack.GetUsersInConversationParameters{
+			ChannelID: channelID,
+		}
+
+		members, nextCursor, err := b.sc.GetUsersInConversation(queryParams)
+		if err != nil {
+			if err = handleRateLimit(b.Log, err); err != nil {
+				return channelMembers, fmt.Errorf("Could not retrieve users in channels: %#v", err)
+			}
+			continue
+		}
+
+		channelMembers = append(channelMembers, members...)
+
+		if nextCursor == "" {
+			break
+		}
+		queryParams.Cursor = nextCursor
+	}
+	return channelMembers, nil
+}
+
+func handleRateLimit(log *logrus.Entry, err error) error {
+	rateLimit, ok := err.(*slack.RateLimitedError)
+	if !ok {
+		return err
+	}
+	log.Infof("Rate-limited by Slack. Sleeping for %v", rateLimit.RetryAfter)
+	time.Sleep(rateLimit.RetryAfter)
+	return nil
+}

bridge/slack/helpers_test.go

@@ -0,0 +1,36 @@
+package bslack
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExtractTopicOrPurpose(t *testing.T) {
+	testcases := map[string]struct {
+		input          string
+		wantChangeType string
+		wantOutput     string
+	}{
+		"success - topic type":   {"@someone set channel topic: foo bar", "topic", "foo bar"},
+		"success - purpose type": {"@someone set channel purpose: foo bar", "purpose", "foo bar"},
+		"success - one line":     {"@someone set channel topic: foo bar", "topic", "foo bar"},
+		"success - multi-line":   {"@someone set channel topic: foo\nbar", "topic", "foo\nbar"},
+		"success - cleared":      {"@someone cleared channel topic", "topic", ""},
+		"error - unhandled":      {"some unmatched message", "unknown", ""},
+	}
+
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	cfg := &bridge.Config{Bridge: &bridge.Bridge{Log: logrus.NewEntry(logger)}}
+	b := newBridge(cfg)
+	for name, tc := range testcases {
+		gotChangeType, gotOutput := b.extractTopicOrPurpose(tc.input)
+
+		assert.Equalf(t, tc.wantChangeType, gotChangeType, "This testcase failed: %s", name)
+		assert.Equalf(t, tc.wantOutput, gotOutput, "This testcase failed: %s", name)
+	}
+}

bridge/slack/legacy.go

@@ -0,0 +1,80 @@
+package bslack
+
+import (
+	"errors"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/matterhook"
+	"github.com/slack-go/slack"
+)
+
+type BLegacy struct {
+	*Bslack
+}
+
+func NewLegacy(cfg *bridge.Config) bridge.Bridger {
+	b := &BLegacy{Bslack: newBridge(cfg)}
+	b.legacy = true
+	return b
+}
+
+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), slack.OptionDebug(b.GetBool("debug")))
+			b.channels = newChannelManager(b.Log, b.sc)
+			b.users = newUserManager(b.Log, b.sc)
+			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), slack.OptionDebug(b.GetBool("debug")))
+		b.channels = newChannelManager(b.Log, b.sc)
+		b.users = newUserManager(b.Log, b.sc)
+		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

@@ -0,0 +1,555 @@
+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"
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/rs/xid"
+	"github.com/slack-go/slack"
+)
+
+type Bslack struct {
+	sync.RWMutex
+	*bridge.Config
+
+	mh  *matterhook.Client
+	sc  *slack.Client
+	rtm *slack.RTM
+	si  *slack.Info
+
+	cache        *lru.Cache
+	uuid         string
+	useChannelID bool
+
+	channels *channels
+	users    *users
+	legacy   bool
+}
+
+const (
+	sHello           = "hello"
+	sChannelJoin     = "channel_join"
+	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"
+	incomingWebhookConfig = "WebhookBindAddress"
+	outgoingWebhookConfig = "WebhookURL"
+	skipTLSConfig         = "SkipTLSVerify"
+	useNickPrefixConfig   = "PrefixMessagesWithNick"
+	editDisableConfig     = "EditDisable"
+	editSuffixConfig      = "EditSuffix"
+	iconURLConfig         = "iconurl"
+	noSendJoinConfig      = "nosendjoinpart"
+	messageLength         = 3000
+)
+
+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 {
+	newCache, err := lru.New(5000)
+	if err != nil {
+		cfg.Log.Fatalf("Could not create LRU cache for Slack bridge: %v", err)
+	}
+	b := &Bslack{
+		Config: cfg,
+		uuid:   xid.New().String(),
+		cache:  newCache,
+	}
+	return b
+}
+
+func (b *Bslack) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bslack) Connect() error {
+	b.RLock()
+	defer b.RUnlock()
+
+	if b.GetString(incomingWebhookConfig) == "" && b.GetString(outgoingWebhookConfig) == "" && b.GetString(tokenConfig) == "" {
+		return errors.New("no connection method found: WebhookBindAddress, WebhookURL or Token need to be configured")
+	}
+
+	// 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, slack.OptionDebug(b.GetBool("Debug")))
+
+		b.channels = newChannelManager(b.Log, b.sc)
+		b.users = newUserManager(b.Log, b.sc)
+
+		b.rtm = b.sc.NewRTM()
+		go b.rtm.ManageConnection()
+		go b.handleSlack()
+		return nil
+	}
+
+	// In absence of a token we fall back to incoming and outgoing Webhooks.
+	b.mh = matterhook.New(
+		"",
+		matterhook.Config{
+			InsecureSkipVerify: b.GetBool("SkipTLSVerify"),
+			DisableServer:      true,
+		},
+	)
+	if b.GetString(outgoingWebhookConfig) != "" {
+		b.Log.Info("Using specified webhook for outgoing messages.")
+		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 {
+	return b.rtm.Disconnect()
+}
+
+// JoinChannel only acts as a verification method that checks whether Matterbridge's
+// Slack integration is already member of the channel. This is because Slack does not
+// 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 {
+	// We can only join a channel through the Slack API.
+	if b.sc == nil {
+		return nil
+	}
+
+	// try to join a channel when in legacy
+	if b.legacy {
+		_, err := b.sc.JoinChannel(channel.Name)
+		if err != nil {
+			switch err.Error() {
+			case "name_taken", "restricted_action":
+			case "default":
+				return err
+			}
+		}
+	}
+
+	b.channels.populateChannels(false)
+
+	channelInfo, err := b.channels.getChannel(channel.Name)
+	if err != nil {
+		return fmt.Errorf("could not join channel: %#v", err)
+	}
+
+	if strings.HasPrefix(channel.Name, "ID:") {
+		b.useChannelID = true
+		channel.Name = channelInfo.Name
+	}
+
+	// we can't join a channel unless we are using legacy tokens #651
+	if !channelInfo.IsMember && !b.legacy {
+		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)
+	}
+
+	msg.Text = helper.ClipMessage(msg.Text, messageLength)
+	msg.Text = b.replaceCodeFence(msg.Text)
+
+	// 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) != "" && b.GetString(tokenConfig) == "" {
+		return "", b.sendWebhook(msg)
+	}
+	return b.sendRTM(msg)
+}
+
+// sendWebhook uses the configured WebhookURL to send the message
+func (b *Bslack) sendWebhook(msg config.Message) 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,
+	}
+	if msg.Avatar != "" {
+		matterMessage.IconURL = msg.Avatar
+	}
+	if err := b.mh.Send(matterMessage); err != nil {
+		b.Log.Errorf("Failed to send message via webhook: %#v", err)
+		return err
+	}
+	return nil
+}
+
+func (b *Bslack) sendRTM(msg config.Message) (string, error) {
+	// Handle channelmember messages.
+	if handled := b.handleGetChannelMembers(&msg); handled {
+		return "", nil
+	}
+
+	channelInfo, err := b.channels.getChannel(msg.Channel)
+	if err != nil {
+		return "", fmt.Errorf("could not send message: %v", err)
+	}
+	if msg.Event == config.EventUserTyping {
+		if b.GetBool("ShowUserTyping") {
+			b.rtm.SendMessage(b.rtm.NewTypingMessage(channelInfo.ID))
+		}
+		return "", nil
+	}
+
+	var handled bool
+
+	// Handle topic/purpose updates.
+	if handled, err = b.handleTopicOrPurpose(&msg, channelInfo); handled {
+		return "", err
+	}
+
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentID == "msg-parent-not-found" {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
+	}
+
+	// Handle message deletions.
+	if handled, err = b.deleteMessage(&msg, channelInfo); handled {
+		return msg.ID, err
+	}
+
+	// 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
+	}
+
+	// Upload a file if it exists.
+	if msg.Extra != nil {
+		extraMsgs := helper.HandleExtra(&msg, b.General)
+		for i := range extraMsgs {
+			rmsg := &extraMsgs[i]
+			rmsg.Text = rmsg.Username + rmsg.Text
+			_, err = b.postMessage(rmsg, channelInfo)
+			if err != nil {
+				b.Log.Error(err)
+			}
+		}
+		// Upload files if necessary (from Slack, Telegram or Mattermost).
+		b.uploadFile(&msg, channelInfo.ID)
+	}
+
+	// Post message.
+	return b.postMessage(&msg, channelInfo)
+}
+
+func (b *Bslack) updateTopicOrPurpose(msg *config.Message, channelInfo *slack.Channel) error {
+	var updateFunc func(channelID string, value string) (*slack.Channel, error)
+
+	incomingChangeType, text := b.extractTopicOrPurpose(msg.Text)
+	switch incomingChangeType {
+	case "topic":
+		updateFunc = b.rtm.SetTopicOfConversation
+	case "purpose":
+		updateFunc = b.rtm.SetPurposeOfConversation
+	default:
+		b.Log.Errorf("Unhandled type received from extractTopicOrPurpose: %s", incomingChangeType)
+		return nil
+	}
+	for {
+		_, err := updateFunc(channelInfo.ID, text)
+		if err == nil {
+			return nil
+		}
+		if err = handleRateLimit(b.Log, err); err != nil {
+			return err
+		}
+	}
+}
+
+// handles updating topic/purpose and determining whether to further propagate update messages.
+func (b *Bslack) handleTopicOrPurpose(msg *config.Message, channelInfo *slack.Channel) (bool, error) {
+	if msg.Event != config.EventTopicChange {
+		return false, nil
+	}
+
+	if b.GetBool("SyncTopic") {
+		return true, b.updateTopicOrPurpose(msg, channelInfo)
+	}
+
+	// Pass along to normal message handlers.
+	if b.GetBool("ShowTopicChange") {
+		return false, nil
+	}
+
+	// Swallow message as handled no-op.
+	return true, nil
+}
+
+func (b *Bslack) deleteMessage(msg *config.Message, channelInfo *slack.Channel) (bool, error) {
+	if msg.Event != config.EventMsgDelete {
+		return false, nil
+	}
+
+	// Some protocols echo deletes, but with an empty ID.
+	if msg.ID == "" {
+		return true, nil
+	}
+
+	for {
+		_, _, err := b.rtm.DeleteMessage(channelInfo.ID, msg.ID)
+		if err == nil {
+			return true, nil
+		}
+
+		if err = handleRateLimit(b.Log, err); err != nil {
+			b.Log.Errorf("Failed to delete user message from Slack: %#v", err)
+			return true, err
+		}
+	}
+}
+
+func (b *Bslack) editMessage(msg *config.Message, channelInfo *slack.Channel) (bool, error) {
+	if msg.ID == "" {
+		return false, nil
+	}
+	messageOptions := b.prepareMessageOptions(msg)
+	for {
+		_, _, _, err := b.rtm.UpdateMessage(channelInfo.ID, msg.ID, messageOptions...)
+		if err == nil {
+			return true, nil
+		}
+
+		if err = handleRateLimit(b.Log, 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, channelInfo *slack.Channel) (string, error) {
+	// don't post empty messages
+	if msg.Text == "" {
+		return "", nil
+	}
+	messageOptions := b.prepareMessageOptions(msg)
+	for {
+		_, id, err := b.rtm.PostMessage(channelInfo.ID, messageOptions...)
+		if err == nil {
+			return id, nil
+		}
+
+		if err = handleRateLimit(b.Log, 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 {
+			msg.Text = ""
+		}
+		// Because the result of the UploadFile is slower than the MessageEvent from slack
+		// we can't match on the file ID yet, so we have to match on the filename too.
+		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) prepareMessageOptions(msg *config.Message) []slack.MsgOption {
+	params := slack.NewPostMessageParameters()
+	if b.GetBool(useNickPrefixConfig) {
+		params.AsUser = true
+	}
+	params.Username = msg.Username
+	params.LinkNames = 1 // replace mentions
+	params.IconURL = config.GetIconURL(msg, b.GetString(iconURLConfig))
+	params.ThreadTimestamp = msg.ParentID
+	if msg.Avatar != "" {
+		params.IconURL = msg.Avatar
+	}
+
+	var attachments []slack.Attachment
+	// add file attachments
+	attachments = append(attachments, b.createAttach(msg.Extra)...)
+	// add slack attachments (from another slack bridge)
+	if msg.Extra != nil {
+		for _, attach := range msg.Extra[sSlackAttachment] {
+			attachments = append(attachments, attach.([]slack.Attachment)...)
+		}
+	}
+
+	var opts []slack.MsgOption
+	opts = append(opts,
+		// provide regular text field (fallback used in Slack notifications, etc.)
+		slack.MsgOptionText(msg.Text, false),
+
+		// add a callback ID so we can see we created it
+		slack.MsgOptionBlocks(slack.NewSectionBlock(
+			slack.NewTextBlockObject(slack.MarkdownType, msg.Text, false, false),
+			nil, nil,
+			slack.SectionBlockOptionBlockID("matterbridge_"+b.uuid),
+		)),
+
+		slack.MsgOptionEnableLinkUnfurl(),
+	)
+	opts = append(opts, slack.MsgOptionAttachments(attachments...))
+	opts = append(opts, slack.MsgOptionPostMessageParameters(params))
+	return opts
+}
+
+func (b *Bslack) createAttach(extra map[string][]interface{}) []slack.Attachment {
+	var attachements []slack.Attachment
+	for _, v := range extra["attachments"] {
+		entry := v.(map[string]interface{})
+		s := slack.Attachment{
+			Fallback:   extractStringField(entry, "fallback"),
+			Color:      extractStringField(entry, "color"),
+			Pretext:    extractStringField(entry, "pretext"),
+			AuthorName: extractStringField(entry, "author_name"),
+			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/slack/users_channels.go

@@ -0,0 +1,336 @@
+package bslack
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/sirupsen/logrus"
+	"github.com/slack-go/slack"
+)
+
+const minimumRefreshInterval = 10 * time.Second
+
+type users struct {
+	log *logrus.Entry
+	sc  *slack.Client
+
+	users           map[string]*slack.User
+	usersMutex      sync.RWMutex
+	usersSyncPoints map[string]chan struct{}
+
+	refreshInProgress bool
+	earliestRefresh   time.Time
+	refreshMutex      sync.Mutex
+}
+
+func newUserManager(log *logrus.Entry, sc *slack.Client) *users {
+	return &users{
+		log:             log,
+		sc:              sc,
+		users:           make(map[string]*slack.User),
+		usersSyncPoints: make(map[string]chan struct{}),
+		earliestRefresh: time.Now(),
+	}
+}
+
+func (b *users) getUser(id string) *slack.User {
+	b.usersMutex.RLock()
+	user, ok := b.users[id]
+	b.usersMutex.RUnlock()
+	if ok {
+		return user
+	}
+	b.populateUser(id)
+	b.usersMutex.RLock()
+	defer b.usersMutex.RUnlock()
+
+	return b.users[id]
+}
+
+func (b *users) 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 *users) getAvatar(id string) string {
+	if user := b.getUser(id); user != nil {
+		return user.Profile.Image48
+	}
+	return ""
+}
+
+func (b *users) populateUser(userID string) {
+	for {
+		b.usersMutex.Lock()
+		_, exists := b.users[userID]
+		if exists {
+			// already in cache
+			b.usersMutex.Unlock()
+			return
+		}
+
+		if syncPoint, ok := b.usersSyncPoints[userID]; ok {
+			// Another goroutine is already populating this user for us so wait on it to finish.
+			b.usersMutex.Unlock()
+			<-syncPoint
+			// We do not return and iterate again to check that the entry does indeed exist
+			// in case the previous query failed for some reason.
+		} else {
+			b.usersSyncPoints[userID] = make(chan struct{})
+			defer func() {
+				// Wake up any waiting goroutines and remove the synchronization point.
+				close(b.usersSyncPoints[userID])
+				delete(b.usersSyncPoints, userID)
+			}()
+			break
+		}
+	}
+
+	// Do not hold the lock while fetching information from Slack
+	// as this might take an unbounded amount of time.
+	b.usersMutex.Unlock()
+
+	user, err := b.sc.GetUserInfo(userID)
+	if err != nil {
+		b.log.Debugf("GetUserInfo failed for %v: %v", userID, err)
+		return
+	}
+
+	b.usersMutex.Lock()
+	defer b.usersMutex.Unlock()
+
+	// Register user information.
+	b.users[userID] = user
+}
+
+func (b *users) populateUsers(wait bool) {
+	b.refreshMutex.Lock()
+	if !wait && (time.Now().Before(b.earliestRefresh) || b.refreshInProgress) {
+		b.log.Debugf("Not refreshing user list as it was done less than %v ago.", minimumRefreshInterval)
+		b.refreshMutex.Unlock()
+
+		return
+	}
+	for b.refreshInProgress {
+		b.refreshMutex.Unlock()
+		time.Sleep(time.Second)
+		b.refreshMutex.Lock()
+	}
+	b.refreshInProgress = true
+	b.refreshMutex.Unlock()
+
+	newUsers := map[string]*slack.User{}
+	pagination := b.sc.GetUsersPaginated(slack.GetUsersOptionLimit(200))
+	count := 0
+	for {
+		var err error
+		pagination, err = pagination.Next(context.Background())
+		time.Sleep(time.Second)
+		if err != nil {
+			if pagination.Done(err) {
+				break
+			}
+
+			if err = handleRateLimit(b.log, 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.log.Debugf("getting %d users", len(pagination.Users))
+		count++
+		// more > 2000 users, slack will complain and ratelimit. break
+		if count > 10 {
+			b.log.Info("Large slack detected > 2000 users, skipping loading complete userlist.")
+			break
+		}
+	}
+
+	b.usersMutex.Lock()
+	defer b.usersMutex.Unlock()
+	b.users = newUsers
+
+	b.refreshMutex.Lock()
+	defer b.refreshMutex.Unlock()
+	b.earliestRefresh = time.Now().Add(minimumRefreshInterval)
+	b.refreshInProgress = false
+}
+
+type channels struct {
+	log *logrus.Entry
+	sc  *slack.Client
+
+	channelsByID   map[string]*slack.Channel
+	channelsByName map[string]*slack.Channel
+	channelsMutex  sync.RWMutex
+
+	channelMembers      map[string][]string
+	channelMembersMutex sync.RWMutex
+
+	refreshInProgress bool
+	earliestRefresh   time.Time
+	refreshMutex      sync.Mutex
+}
+
+func newChannelManager(log *logrus.Entry, sc *slack.Client) *channels {
+	return &channels{
+		log:             log,
+		sc:              sc,
+		channelsByID:    make(map[string]*slack.Channel),
+		channelsByName:  make(map[string]*slack.Channel),
+		earliestRefresh: time.Now(),
+	}
+}
+
+func (b *channels) getChannel(channel string) (*slack.Channel, error) {
+	if strings.HasPrefix(channel, "ID:") {
+		return b.getChannelByID(strings.TrimPrefix(channel, "ID:"))
+	}
+	return b.getChannelByName(channel)
+}
+
+func (b *channels) getChannelByName(name string) (*slack.Channel, error) {
+	return b.getChannelBy(name, b.channelsByName)
+}
+
+func (b *channels) getChannelByID(id string) (*slack.Channel, error) {
+	return b.getChannelBy(id, b.channelsByID)
+}
+
+func (b *channels) getChannelBy(lookupKey string, lookupMap map[string]*slack.Channel) (*slack.Channel, error) {
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+
+	if channel, ok := lookupMap[lookupKey]; ok {
+		return channel, nil
+	}
+	return nil, fmt.Errorf("channel %s not found", lookupKey)
+}
+
+func (b *channels) getChannelMembers(users *users) config.ChannelMembers {
+	b.channelMembersMutex.RLock()
+	defer b.channelMembersMutex.RUnlock()
+
+	membersInfo := config.ChannelMembers{}
+	for channelID, members := range b.channelMembers {
+		for _, member := range members {
+			channelName := ""
+			userName := ""
+			userNick := ""
+			user := users.getUser(member)
+			if user != nil {
+				userName = user.Name
+				userNick = user.Profile.DisplayName
+			}
+			channel, _ := b.getChannelByID(channelID)
+			if channel != nil {
+				channelName = channel.Name
+			}
+			memberInfo := config.ChannelMember{
+				Username:    userName,
+				Nick:        userNick,
+				UserID:      member,
+				ChannelID:   channelID,
+				ChannelName: channelName,
+			}
+			membersInfo = append(membersInfo, memberInfo)
+		}
+	}
+	return membersInfo
+}
+
+func (b *channels) registerChannel(channel slack.Channel) {
+	b.channelsMutex.Lock()
+	defer b.channelsMutex.Unlock()
+
+	b.channelsByID[channel.ID] = &channel
+	b.channelsByName[channel.Name] = &channel
+}
+
+func (b *channels) populateChannels(wait bool) {
+	b.refreshMutex.Lock()
+	if !wait && (time.Now().Before(b.earliestRefresh) || b.refreshInProgress) {
+		b.log.Debugf("Not refreshing channel list as it was done less than %v seconds ago.", minimumRefreshInterval)
+		b.refreshMutex.Unlock()
+		return
+	}
+	for b.refreshInProgress {
+		b.refreshMutex.Unlock()
+		time.Sleep(time.Second)
+		b.refreshMutex.Lock()
+	}
+	b.refreshInProgress = true
+	b.refreshMutex.Unlock()
+
+	newChannelsByID := map[string]*slack.Channel{}
+	newChannelsByName := map[string]*slack.Channel{}
+	newChannelMembers := make(map[string][]string)
+
+	// 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 = handleRateLimit(b.log, 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]
+			// also find all the members in every channel
+			// comment for now, issues on big slacks
+			/*
+				members, err := b.getUsersInConversation(channels[i].ID)
+				if err != nil {
+					if err = b.handleRateLimit(err); err != nil {
+						b.Log.Errorf("Could not retrieve channel members: %#v", err)
+						return
+					}
+					continue
+				}
+				newChannelMembers[channels[i].ID] = members
+			*/
+		}
+
+		if nextCursor == "" {
+			break
+		}
+		queryParams.Cursor = nextCursor
+	}
+
+	b.channelsMutex.Lock()
+	defer b.channelsMutex.Unlock()
+	b.channelsByID = newChannelsByID
+	b.channelsByName = newChannelsByName
+
+	b.channelMembersMutex.Lock()
+	defer b.channelMembersMutex.Unlock()
+	b.channelMembers = newChannelMembers
+
+	b.refreshMutex.Lock()
+	defer b.refreshMutex.Unlock()
+	b.earliestRefresh = time.Now().Add(minimumRefreshInterval)
+	b.refreshInProgress = false
+}

bridge/sshchat/sshchat.go

@@ -0,0 +1,169 @@
+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"
+)
+
+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 {
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+
+	// connHandler will be called by 'sshd.ConnectShell()' below
+	// once the connection is established in order to handle it.
+	connErr := make(chan error, 1) // Needs to be buffered.
+	connSignal := make(chan struct{})
+	connHandler := func(r io.Reader, w io.WriteCloser) error {
+		b.r = bufio.NewScanner(r)
+		b.r.Scan()
+		b.w = w
+		if _, err := b.w.Write([]byte("/theme mono\r\n/quiet\r\n")); err != nil {
+			return err
+		}
+		close(connSignal) // Connection is established so we can signal the success.
+		return b.handleSSHChat()
+	}
+
+	go func() {
+		// As a successful connection will result in this returning after the Connection
+		// method has already returned point we NEED to have a buffered channel to still
+		// be able to write.
+		connErr <- sshd.ConnectShell(b.GetString("Server"), b.GetString("Nick"), connHandler)
+	}()
+
+	select {
+	case err := <-connErr:
+		b.Log.Error("Connection failed")
+		return err
+	case <-connSignal:
+	}
+	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) {
+			if _, err := b.w.Write([]byte(rmsg.Username + rmsg.Text + "\r\n")); err != nil {
+				b.Log.Errorf("Could not send extra message: %#v", err)
+			}
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return b.handleUploadFile(&msg)
+		}
+	}
+	_, err := b.w.Write([]byte(msg.Username + msg.Text + "\r\n"))
+	return "", err
+}
+
+/*
+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
+			}
+			if strings.Contains(b.r.Text(), "Rate limiting is in effect") {
+				continue
+			}
+			// skip our own messages
+			if !strings.HasPrefix(b.r.Text(), "["+b.GetString("Nick")+"] \x1b") {
+				continue
+			}
+			res := strings.Split(stripPrompt(b.r.Text()), ":")
+			if res[0] == "-> Set theme" {
+				wait = false
+				b.Log.Debugf("mono found, allowing")
+				continue
+			}
+			if !wait {
+				b.Log.Debugf("<= Message %#v", res)
+				rmsg := config.Message{Username: res[0], Text: strings.TrimSpace(strings.Join(res[1:], ":")), Channel: "sshchat", Account: b.Account, UserID: "nick"}
+				b.Remote <- rmsg
+			}
+		}
+	}
+}
+
+func (b *Bsshchat) 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
+			}
+		}
+		if _, err := b.w.Write([]byte(msg.Username + msg.Text + "\r\n")); err != nil {
+			b.Log.Errorf("Could not send file message: %#v", err)
+		}
+	}
+	return "", nil
+}

bridge/steam/handlers.go

@@ -0,0 +1,126 @@
+package bsteam
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/Philipp15b/go-steam"
+	"github.com/Philipp15b/go-steam/protocol/steamlang"
+)
+
+func (b *Bsteam) handleChatMsg(e *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
+		// TODO
+		// https://github.com/42wim/matterbridge/pull/630#discussion_r238102751
+		// channel = int64(e.ChatRoomId) & 0xfffffffffffff
+		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
+}
+
+func (b *Bsteam) handleEvents() {
+	myLoginInfo := &steam.LogOnDetails{
+		Username: b.GetString("Login"),
+		Password: b.GetString("Password"),
+		AuthCode: b.GetString("AuthCode"),
+	}
+	// TODO Attempt to read existing auth hash to avoid steam guard.
+	// Maybe works
+	//myLoginInfo.SentryFileHash, _ = ioutil.ReadFile("sentry")
+	for event := range b.c.Events() {
+		switch e := event.(type) {
+		case *steam.ChatMsgEvent:
+			b.handleChatMsg(e)
+		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:
+		// TODO sentry files for 2 auth
+		/*
+			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)
+			err := b.handleLogOnFailed(e, myLoginInfo)
+			if err != nil {
+				b.Log.Error(err)
+				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.Errorf("steam FatalErrorEvent: %#v", e)
+		default:
+			b.Log.Debugf("unknown event %#v", e)
+		}
+	}
+}
+
+func (b *Bsteam) handleLogOnFailed(e *steam.LogOnFailedEvent, myLoginInfo *steam.LogOnDetails) error {
+	switch e.Result {
+	case steamlang.EResult_AccountLoginDeniedNeedTwoFactor:
+		b.Log.Info("Steam guard isn't letting me in! Enter 2FA code:")
+		var code string
+		fmt.Scanf("%s", &code)
+		// TODO https://github.com/42wim/matterbridge/pull/630#discussion_r238103978
+		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)
+		// TODO https://github.com/42wim/matterbridge/pull/630#discussion_r238103978
+		myLoginInfo.AuthCode = code
+	case steamlang.EResult_InvalidLoginAuthCode:
+		return fmt.Errorf("Steam guard: invalid login auth code: %#v ", e.Result)
+	default:
+		return fmt.Errorf("LogOnFailedEvent: %#v ", e.Result)
+		// TODO: Handle EResult_InvalidLoginAuthCode
+	}
+	return nil
+}
+
+// handleFileInfo handles config.FileInfo and adds correct file comment or URL to msg.Text.
+// Returns error if cast fails.
+func (b *Bsteam) handleFileInfo(msg *config.Message, f interface{}) error {
+	if _, ok := f.(config.FileInfo); !ok {
+		return fmt.Errorf("handleFileInfo cast failed %#v", f)
+	}
+	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
+		}
+	}
+	return nil
+}

bridge/steam/steam.go

@@ -0,0 +1,95 @@
+package bsteam
+
+import (
+	"fmt"
+	"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)
+		}
+		for i := range msg.Extra["file"] {
+			if err := b.handleFileInfo(&msg, msg.Extra["file"][i]); err != nil {
+				b.Log.Error(err)
+			}
+			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"
+}

bridge/telegram/handlers.go

@@ -0,0 +1,447 @@
+package btelegram
+
+import (
+	"html"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf16"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
+)
+
+func (b *Btelegram) handleUpdate(rmsg *config.Message, message, posted, edited *tgbotapi.Message) *tgbotapi.Message {
+	// handle channels
+	if posted != nil {
+		message = posted
+		rmsg.Text = message.Text
+	}
+
+	// edited channel message
+	if edited != nil && !b.GetBool("EditDisable") {
+		message = edited
+		rmsg.Text = rmsg.Text + message.Text + b.GetString("EditSuffix")
+	}
+	return message
+}
+
+// handleChannels checks if it's a channel message and if the message is a new or edited messages
+func (b *Btelegram) handleChannels(rmsg *config.Message, message *tgbotapi.Message, update tgbotapi.Update) *tgbotapi.Message {
+	return b.handleUpdate(rmsg, message, update.ChannelPost, update.EditedChannelPost)
+}
+
+// handleGroups checks if it's a group message and if the message is a new or edited messages
+func (b *Btelegram) handleGroups(rmsg *config.Message, message *tgbotapi.Message, update tgbotapi.Update) *tgbotapi.Message {
+	return b.handleUpdate(rmsg, message, update.Message, update.EditedMessage)
+}
+
+// handleForwarded handles forwarded messages
+func (b *Btelegram) handleForwarded(rmsg *config.Message, message *tgbotapi.Message) {
+	if message.ForwardDate == 0 {
+		return
+	}
+
+	if message.ForwardFrom == nil {
+		rmsg.Text = "Forwarded from " + unknownUser + ": " + rmsg.Text
+		return
+	}
+
+	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
+}
+
+// handleQuoting handles quoting of previous messages
+func (b *Btelegram) handleQuoting(rmsg *config.Message, message *tgbotapi.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)
+		}
+	}
+}
+
+// handleUsername handles the correct setting of the username
+func (b *Btelegram) handleUsername(rmsg *config.Message, message *tgbotapi.Message) {
+	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.General.MediaServerDownload != "" && b.General.MediaDownloadPath != "") {
+			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
+	}
+}
+
+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
+		message = b.handleChannels(&rmsg, message, update)
+
+		// handle groups
+		message = b.handleGroups(&rmsg, message, update)
+
+		if message == nil {
+			b.Log.Error("message is nil, this shouldn't happen.")
+			continue
+		}
+
+		// 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
+		b.handleUsername(&rmsg, message)
+
+		// handle any downloads
+		err := b.handleDownload(&rmsg, message)
+		if err != nil {
+			b.Log.Errorf("download failed: %s", err)
+		}
+
+		// handle forwarded messages
+		b.handleForwarded(&rmsg, message)
+
+		// quote the previous message
+		b.handleQuoting(&rmsg, message)
+
+		// handle entities (adding URLs)
+		b.handleEntities(&rmsg, message)
+
+		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
+		}
+	}
+}
+
+// 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
+		}
+	}
+}
+
+func (b *Btelegram) maybeConvertTgs(name *string, data *[]byte) {
+	var format string
+	switch b.GetString("MediaConvertTgs") {
+	case FormatWebp:
+		b.Log.Debugf("Tgs to WebP conversion enabled, converting %v", name)
+		format = FormatWebp
+	case FormatPng:
+		// The WebP to PNG converter can't handle animated webp files yet,
+		// and I'm not going to write a path for x/image/webp.
+		// The error message would be:
+		//     conversion failed: webp: non-Alpha VP8X is not implemented
+		// So instead, we tell lottie to directly go to PNG.
+		b.Log.Debugf("Tgs to PNG conversion enabled, converting %v", name)
+		format = FormatPng
+	default:
+		// Otherwise, no conversion was requested. Trying to run the usual webp
+		// converter would fail, because '.tgs.webp' is actually a gzipped JSON
+		// file, and has nothing to do with WebP.
+		return
+	}
+	err := helper.ConvertTgsToX(data, format, b.Log)
+	if err != nil {
+		b.Log.Errorf("conversion failed: %v", err)
+	} else {
+		*name = strings.Replace(*name, "tgs.webp", format, 1)
+	}
+}
+
+func (b *Btelegram) maybeConvertWebp(name *string, data *[]byte) {
+	if b.GetBool("MediaConvertWebPToPNG") {
+		b.Log.Debugf("WebP to PNG conversion enabled, converting %v", name)
+		err := helper.ConvertWebPToPNG(data)
+		if err != nil {
+			b.Log.Errorf("conversion failed: %v", err)
+		} else {
+			*name = strings.Replace(*name, ".webp", ".png", 1)
+		}
+	}
+}
+
+// handleDownloadFile handles file download
+func (b *Btelegram) handleDownload(rmsg *config.Message, message *tgbotapi.Message) error {
+	size := 0
+	var url, name, text string
+	switch {
+	case message.Sticker != nil:
+		text, name, url = b.getDownloadInfo(message.Sticker.FileID, ".webp", true)
+		size = message.Sticker.FileSize
+	case message.Voice != nil:
+		text, name, url = b.getDownloadInfo(message.Voice.FileID, ".ogg", true)
+		size = message.Voice.FileSize
+	case message.Video != nil:
+		text, name, url = b.getDownloadInfo(message.Video.FileID, "", true)
+		size = message.Video.FileSize
+	case message.Audio != nil:
+		text, name, url = b.getDownloadInfo(message.Audio.FileID, "", true)
+		size = message.Audio.FileSize
+	case message.Document != nil:
+		_, _, url = b.getDownloadInfo(message.Document.FileID, "", false)
+		size = message.Document.FileSize
+		name = message.Document.FileName
+		text = " " + message.Document.FileName + " : " + url
+	case message.Photo != nil:
+		photos := *message.Photo
+		size = photos[len(photos)-1].FileSize
+		text, name, url = b.getDownloadInfo(photos[len(photos)-1].FileID, "", true)
+	}
+
+	// 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
+	}
+
+	if strings.HasSuffix(name, ".tgs.webp") {
+		b.maybeConvertTgs(&name, data)
+	} else if strings.HasSuffix(name, ".webp") {
+		b.maybeConvertWebp(&name, data)
+	}
+
+	helper.HandleDownloadData(b.Log, rmsg, name, message.Caption, "", data, b.General)
+	return nil
+}
+
+func (b *Btelegram) getDownloadInfo(id string, suffix string, urlpart bool) (string, string, string) {
+	url := b.getFileDirectURL(id)
+	name := ""
+	if urlpart {
+		urlPart := strings.Split(url, "/")
+		name = urlPart[len(urlPart)-1]
+	}
+	if suffix != "" && !strings.HasSuffix(name, suffix) {
+		name += suffix
+	}
+	text := " " + url
+	return text, name, url
+}
+
+// handleDelete handles message deleting
+func (b *Btelegram) handleDelete(msg *config.Message, chatid int64) (string, error) {
+	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
+}
+
+// handleEdit handles message editing.
+func (b *Btelegram) handleEdit(msg *config.Message, chatid int64) (string, error) {
+	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)
+	switch b.GetString("MessageFormat") {
+	case HTMLFormat:
+		b.Log.Debug("Using mode HTML")
+		m.ParseMode = tgbotapi.ModeHTML
+	case "Markdown":
+		b.Log.Debug("Using mode markdown")
+		m.ParseMode = tgbotapi.ModeMarkdown
+	case MarkdownV2:
+		b.Log.Debug("Using mode MarkdownV2")
+		m.ParseMode = MarkdownV2
+	}
+	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
+}
+
+// handleUploadFile handles native upload of files
+func (b *Btelegram) handleUploadFile(msg *config.Message, chatid int64) string {
+	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 != "" {
+			if _, err := b.sendMessage(chatid, msg.Username, fi.Comment); err != nil {
+				b.Log.Errorf("posting file comment %s failed: %s", fi.Comment, err)
+			}
+		}
+	}
+	return ""
+}
+
+func (b *Btelegram) handleQuote(message, quoteNick, quoteMessage string) string {
+	format := b.GetString("quoteformat")
+	if format == "" {
+		format = "{MESSAGE} (re @{QUOTENICK}: {QUOTEMESSAGE})"
+	}
+	quoteMessagelength := len(quoteMessage)
+	if b.GetInt("QuoteLengthLimit") != 0 && quoteMessagelength >= b.GetInt("QuoteLengthLimit") {
+		runes := []rune(quoteMessage)
+		quoteMessage = string(runes[0:b.GetInt("QuoteLengthLimit")])
+		if quoteMessagelength > b.GetInt("QuoteLengthLimit") {
+			quoteMessage += "..."
+		}
+	}
+	format = strings.Replace(format, "{MESSAGE}", message, -1)
+	format = strings.Replace(format, "{QUOTENICK}", quoteNick, -1)
+	format = strings.Replace(format, "{QUOTEMESSAGE}", quoteMessage, -1)
+	return format
+}
+
+// handleEntities handles messageEntities
+func (b *Btelegram) handleEntities(rmsg *config.Message, message *tgbotapi.Message) {
+	if message.Entities == nil {
+		return
+	}
+	// for now only do URL replacements
+	for _, e := range *message.Entities {
+		if e.Type == "text_link" {
+			url, err := e.ParseURL()
+			if err != nil {
+				b.Log.Errorf("entity text_link url parse failed: %s", err)
+				continue
+			}
+			utfEncodedString := utf16.Encode([]rune(rmsg.Text))
+			if e.Offset+e.Length > len(utfEncodedString) {
+				b.Log.Errorf("entity length is too long %d > %d", e.Offset+e.Length, len(utfEncodedString))
+				continue
+			}
+			link := utf16.Decode(utfEncodedString[e.Offset : e.Offset+e.Length])
+			rmsg.Text = strings.Replace(rmsg.Text, string(link), url.String(), 1)
+		}
+	}
+}

bridge/telegram/html.go

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

bridge/telegram/telegram.go

@@ -0,0 +1,171 @@
+package btelegram
+
+import (
+	"html"
+	"log"
+	"strconv"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
+)
+
+const (
+	unknownUser = "unknown"
+	HTMLFormat  = "HTML"
+	HTMLNick    = "htmlnick"
+	MarkdownV2  = "MarkdownV2"
+	FormatPng   = "png"
+	FormatWebp  = "webp"
+)
+
+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 {
+	tgsConvertFormat := cfg.GetString("MediaConvertTgs")
+	if tgsConvertFormat != "" {
+		err := helper.CanConvertTgsToX()
+		if err != nil {
+			log.Fatalf("Telegram bridge configured to convert .tgs files to '%s', but lottie does not appear to work:\n%#v", tgsConvertFormat, err)
+		}
+		if tgsConvertFormat != FormatPng && tgsConvertFormat != FormatWebp {
+			log.Fatalf("Telegram bridge configured to convert .tgs files to '%s', but only '%s' and '%s' are supported.", FormatPng, FormatWebp, tgsConvertFormat)
+		}
+	}
+	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 {
+		return b.handleDelete(&msg, chatid)
+	}
+
+	// Upload a file if it exists
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			if _, msgErr := b.sendMessage(chatid, rmsg.Username, rmsg.Text); msgErr != nil {
+				b.Log.Errorf("sendMessage failed: %s", msgErr)
+			}
+		}
+		// 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 != "" {
+		return b.handleEdit(&msg, chatid)
+	}
+
+	// Post normal message
+	// TODO: recheck it.
+	// Ignore empty text field needs for prevent double messages from whatsapp to telegram
+	// when sending media with text caption
+	if msg.Text != "" {
+		return b.sendMessage(chatid, msg.Username, msg.Text)
+	}
+
+	return "", nil
+}
+
+func (b *Btelegram) getFileDirectURL(id string) string {
+	res, err := b.c.GetFileDirectURL(id)
+	if err != nil {
+		return ""
+	}
+	return res
+}
+
+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 b.GetString("MessageFormat") == MarkdownV2 {
+		b.Log.Debug("Using mode MarkdownV2")
+		m.ParseMode = MarkdownV2
+	}
+	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
+	}
+
+	m.DisableWebPagePreview = b.GetBool("DisableWebPagePreview")
+
+	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
+}

bridge/whatsapp/handlers.go

@@ -0,0 +1,208 @@
+package bwhatsapp
+
+import (
+	"fmt"
+	"mime"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/Rhymen/go-whatsapp"
+	"github.com/jpillora/backoff"
+)
+
+/*
+Implement handling messages coming from WhatsApp
+Check:
+- https://github.com/Rhymen/go-whatsapp#add-message-handlers
+- https://github.com/Rhymen/go-whatsapp/blob/master/handler.go
+- https://github.com/tulir/mautrix-whatsapp/tree/master/whatsapp-ext for more advanced command handling
+*/
+
+// HandleError received from WhatsApp
+func (b *Bwhatsapp) HandleError(err error) {
+	// ignore received invalid data errors. https://github.com/42wim/matterbridge/issues/843
+	// ignore tag 174 errors. https://github.com/42wim/matterbridge/issues/1094
+	if strings.Contains(err.Error(), "error processing data: received invalid data") || strings.Contains(err.Error(), "invalid string with tag 174") {
+		return
+	}
+
+	switch err.(type) {
+	case *whatsapp.ErrConnectionClosed, *whatsapp.ErrConnectionFailed:
+		b.reconnect(err)
+	default:
+		switch err {
+		case whatsapp.ErrConnectionTimeout:
+			b.reconnect(err)
+		default:
+			b.Log.Errorf("%v", err)
+		}
+	}
+}
+
+func (b *Bwhatsapp) reconnect(err error) {
+	bf := &backoff.Backoff{
+		Min:    time.Second,
+		Max:    5 * time.Minute,
+		Jitter: true,
+	}
+	for {
+		d := bf.Duration()
+		b.Log.Errorf("Connection failed, underlying error: %v", err)
+		b.Log.Infof("Waiting %s...", d)
+		time.Sleep(d)
+		b.Log.Info("Reconnecting...")
+		err := b.conn.Restore()
+		if err == nil {
+			bf.Reset()
+			b.startedAt = uint64(time.Now().Unix())
+			return
+		}
+	}
+}
+
+// HandleTextMessage sent from WhatsApp, relay it to the brige
+func (b *Bwhatsapp) HandleTextMessage(message whatsapp.TextMessage) {
+	if message.Info.FromMe { // || !strings.Contains(strings.ToLower(message.Text), "@echo") {
+		return
+	}
+	// whatsapp sends last messages to show context , cut them
+	if message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	messageTime := time.Unix(int64(message.Info.Timestamp), 0) // TODO check how behaves between timezones
+	groupJID := message.Info.RemoteJid
+
+	senderJID := message.Info.SenderJid
+	if len(senderJID) == 0 {
+		// TODO workaround till https://github.com/Rhymen/go-whatsapp/issues/86 resolved
+		if message.Info.Source != nil {
+			senderJID = *message.Info.Source.Participant
+		}
+	}
+
+	// translate sender's JID to the nicest username we can get
+	senderName := b.getSenderName(senderJID)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	extText := message.Info.Source.Message.ExtendedTextMessage
+	if extText != nil && extText.ContextInfo != nil && extText.ContextInfo.MentionedJid != nil {
+		// handle user mentions
+		for _, mentionedJID := range extText.ContextInfo.MentionedJid {
+			numberAndSuffix := strings.SplitN(mentionedJID, "@", 2)
+
+			// mentions comes as telephone numbers and we don't want to expose it to other bridges
+			// replace it with something more meaninful to others
+			mention := b.getSenderNotify(numberAndSuffix[0] + "@s.whatsapp.net")
+			if mention == "" {
+				mention = "someone"
+			}
+			message.Text = strings.Replace(message.Text, "@"+numberAndSuffix[0], "@"+mention, 1)
+		}
+	}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
+	rmsg := config.Message{
+		UserID:    senderJID,
+		Username:  senderName,
+		Text:      message.Text,
+		Timestamp: messageTime,
+		Channel:   groupJID,
+		Account:   b.Account,
+		Protocol:  b.Protocol,
+		Extra:     make(map[string][]interface{}),
+		//	ParentID: TODO, // TODO handle thread replies  // map from Info.QuotedMessageID string
+		//	Event     string    `json:"event"`
+		//	Gateway   string  // will be added during message processing
+		ID: message.Info.Id}
+
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	b.Log.Debugf("<= Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+// HandleImageMessage sent from WhatsApp, relay it to the brige
+func (b *Bwhatsapp) HandleImageMessage(message whatsapp.ImageMessage) {
+	if message.Info.FromMe { // || !strings.Contains(strings.ToLower(message.Text), "@echo") {
+		return
+	}
+
+	// whatsapp sends last messages to show context , cut them
+	if message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	messageTime := time.Unix(int64(message.Info.Timestamp), 0) // TODO check how behaves between timezones
+	groupJID := message.Info.RemoteJid
+
+	senderJID := message.Info.SenderJid
+	// if len(senderJid) == 0 {
+	//   // TODO workaround till https://github.com/Rhymen/go-whatsapp/issues/86 resolved
+	//   senderJid = *message.Info.Source.Participant
+	// }
+
+	// translate sender's Jid to the nicest username we can get
+	senderName := b.getSenderName(senderJID)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
+	rmsg := config.Message{
+		UserID:    senderJID,
+		Username:  senderName,
+		Timestamp: messageTime,
+		Channel:   groupJID,
+		Account:   b.Account,
+		Protocol:  b.Protocol,
+		Extra:     make(map[string][]interface{}),
+		//  ParentID: TODO,      // TODO handle thread replies  // map from Info.QuotedMessageID string
+		//  Event     string    `json:"event"`
+		//  Gateway   string     // will be added during message processing
+		ID: message.Info.Id}
+
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	// Download and unencrypt content
+	data, err := message.Download()
+	if err != nil {
+		b.Log.Errorf("%v", err)
+		return
+	}
+
+	// Get file extension by mimetype
+	fileExt, err := mime.ExtensionsByType(message.Type)
+	if err != nil {
+		b.Log.Errorf("%v", err)
+		return
+	}
+
+	filename := fmt.Sprintf("%v%v", message.Info.Id, fileExt[0])
+
+	b.Log.Debugf("<= Image downloaded and unencrypted")
+
+	// Move file to bridge storage
+	helper.HandleDownloadData(b.Log, &rmsg, filename, message.Caption, "", &data, b.General)
+
+	b.Log.Debugf("<= Image Message is %#v", rmsg)
+	b.Remote <- rmsg
+}
+
+//func (b *Bwhatsapp) HandleVideoMessage(message whatsapp.VideoMessage) {
+//	fmt.Println(message) // TODO implement
+//}
+//
+//func (b *Bwhatsapp) HandleJsonMessage(message string) {
+//	fmt.Println(message) // TODO implement
+//}
+// TODO HandleRawMessage
+// TODO HandleAudioMessage

bridge/whatsapp/helpers.go

@@ -0,0 +1,132 @@
+package bwhatsapp
+
+import (
+	"encoding/gob"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+
+	qrcodeTerminal "github.com/Baozisoftware/qrcode-terminal-go"
+	"github.com/Rhymen/go-whatsapp"
+)
+
+type ProfilePicInfo struct {
+	URL string `json:"eurl"`
+	Tag string `json:"tag"`
+
+	Status int16 `json:"status"`
+}
+
+func qrFromTerminal(invert bool) chan string {
+	qr := make(chan string)
+	go func() {
+		terminal := qrcodeTerminal.New()
+		if invert {
+			terminal = qrcodeTerminal.New2(qrcodeTerminal.ConsoleColors.BrightWhite, qrcodeTerminal.ConsoleColors.BrightBlack, qrcodeTerminal.QRCodeRecoveryLevels.Medium)
+		}
+
+		terminal.Get(<-qr).Print()
+	}()
+
+	return qr
+}
+
+func (b *Bwhatsapp) readSession() (whatsapp.Session, error) {
+	session := whatsapp.Session{}
+	sessionFile := b.Config.GetString(sessionFile)
+
+	if sessionFile == "" {
+		return session, errors.New("if you won't set SessionFile then you will need to scan QR code on every restart")
+	}
+
+	file, err := os.Open(sessionFile)
+	if err != nil {
+		return session, err
+	}
+	defer file.Close()
+	decoder := gob.NewDecoder(file)
+	err = decoder.Decode(&session)
+	if err != nil {
+		return session, err
+	}
+	return session, nil
+}
+
+func (b *Bwhatsapp) writeSession(session whatsapp.Session) error {
+	sessionFile := b.Config.GetString(sessionFile)
+
+	if sessionFile == "" {
+		// we already sent a warning while starting the bridge, so let's be quiet here
+		return nil
+	}
+
+	file, err := os.Create(sessionFile)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	encoder := gob.NewEncoder(file)
+	err = encoder.Encode(session)
+
+	return err
+}
+
+func (b *Bwhatsapp) getSenderName(senderJid string) string {
+	if sender, exists := b.users[senderJid]; exists {
+		if sender.Name != "" {
+			return sender.Name
+		}
+		// if user is not in phone contacts
+		// it is the most obvious scenario unless you sync your phone contacts with some remote updated source
+		// users can change it in their WhatsApp settings -> profile -> click on Avatar
+		if sender.Notify != "" {
+			return sender.Notify
+		}
+
+		if sender.Short != "" {
+			return sender.Short
+		}
+	}
+
+	// try to reload this contact
+	_, err := b.conn.Contacts()
+	if err != nil {
+		b.Log.Errorf("error on update of contacts: %v", err)
+	}
+
+	if contact, exists := b.conn.Store.Contacts[senderJid]; exists {
+		// Add it to the user map
+		b.users[senderJid] = contact
+
+		if contact.Name != "" {
+			return contact.Name
+		}
+		// if user is not in phone contacts
+		// same as above
+		return contact.Notify
+	}
+
+	return ""
+}
+
+func (b *Bwhatsapp) getSenderNotify(senderJid string) string {
+	if sender, exists := b.users[senderJid]; exists {
+		return sender.Notify
+	}
+	return ""
+}
+
+func (b *Bwhatsapp) GetProfilePicThumb(jid string) (*ProfilePicInfo, error) {
+	data, err := b.conn.GetProfilePicThumb(jid)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get avatar: %v", err)
+	}
+	content := <-data
+	info := &ProfilePicInfo{}
+	err = json.Unmarshal([]byte(content), info)
+	if err != nil {
+		return info, fmt.Errorf("failed to unmarshal avatar info: %v", err)
+	}
+	return info, nil
+}

bridge/whatsapp/whatsapp.go

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

bridge/xmpp/handler.go

@@ -0,0 +1,34 @@
+package bxmpp
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/matterbridge/go-xmpp"
+)
+
+// 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 *Bxmpp) handleDownloadAvatar(avatar xmpp.AvatarData) {
+	rmsg := config.Message{
+		Username: "system",
+		Text:     "avatar",
+		Channel:  b.parseChannel(avatar.From),
+		Account:  b.Account,
+		UserID:   avatar.From,
+		Event:    config.EventAvatarDownload,
+		Extra:    make(map[string][]interface{}),
+	}
+	if _, ok := b.avatarMap[avatar.From]; !ok {
+		b.Log.Debugf("Avatar.From: %s", avatar.From)
+
+		err := helper.HandleDownloadSize(b.Log, &rmsg, avatar.From+".png", int64(len(avatar.Data)), b.General)
+		if err != nil {
+			b.Log.Error(err)
+			return
+		}
+		helper.HandleDownloadData(b.Log, &rmsg, avatar.From+".png", rmsg.Text, "", &avatar.Data, b.General)
+		b.Log.Debugf("Avatar download complete")
+		b.Remote <- rmsg
+	}
+}

bridge/xmpp/helpers.go

@@ -0,0 +1,30 @@
+package bxmpp
+
+import (
+	"regexp"
+
+	"github.com/42wim/matterbridge/bridge/config"
+)
+
+var pathRegex = regexp.MustCompile("[^a-zA-Z0-9]+")
+
+// GetAvatar constructs a URL for a given user-avatar if it is available in the cache.
+func getAvatar(av map[string]string, userid string, general *config.Protocol) string {
+	if hash, ok := av[userid]; ok {
+		// NOTE: This does not happen in bridge/helper/helper.go but messes up XMPP
+		id := pathRegex.ReplaceAllString(userid, "_")
+		return general.MediaServerDownload + "/" + hash + "/" + id + ".png"
+	}
+	return ""
+}
+
+func (b *Bxmpp) cacheAvatar(msg *config.Message) string {
+	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 ""
+}

bridge/xmpp/xmpp.go

@@ -0,0 +1,395 @@
+package bxmpp
+
+import (
+	"crypto/tls"
+	"fmt"
+	"strings"
+	"sync"
+	"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 {
+	*bridge.Config
+
+	startTime time.Time
+	xc        *xmpp.Client
+	xmppMap   map[string]string
+	connected bool
+	sync.RWMutex
+
+	avatarAvailability map[string]bool
+	avatarMap          map[string]string
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	return &Bxmpp{
+		Config:             cfg,
+		xmppMap:            make(map[string]string),
+		avatarAvailability: make(map[string]bool),
+		avatarMap:          make(map[string]string),
+	}
+}
+
+func (b *Bxmpp) Connect() error {
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	if err := b.createXMPP(); err != nil {
+		b.Log.Debugf("%#v", err)
+		return err
+	}
+
+	b.Log.Info("Connection succeeded")
+	go b.manageConnection()
+	return nil
+}
+
+func (b *Bxmpp) Disconnect() error {
+	return nil
+}
+
+func (b *Bxmpp) JoinChannel(channel config.ChannelInfo) error {
+	if channel.Options.Key != "" {
+		b.Log.Debugf("using key %s for channel %s", channel.Options.Key, channel.Name)
+		b.xc.JoinProtectedMUC(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"), channel.Options.Key, xmpp.NoHistory, 0, nil)
+	} else {
+		b.xc.JoinMUCNoHistory(channel.Name+"@"+b.GetString("Muc"), b.GetString("Nick"))
+	}
+	return nil
+}
+
+func (b *Bxmpp) Send(msg config.Message) (string, error) {
+	// should be fixed by using a cache instead of dropping
+	if !b.Connected() {
+		return "", fmt.Errorf("bridge %s not connected, dropping message %#v to bridge", b.Account, msg)
+	}
+	// ignore delete messages
+	if msg.Event == config.EventMsgDelete {
+		return "", nil
+	}
+
+	b.Log.Debugf("=> Receiving %#v", msg)
+
+	if msg.Event == config.EventAvatarDownload {
+		return b.cacheAvatar(&msg), nil
+	}
+
+	// Make a action /me of the message, prepend the username with it.
+	// https://xmpp.org/extensions/xep-0245.html
+	if msg.Event == config.EventUserAction {
+		msg.Username = "/me " + msg.Username
+	}
+
+	// Upload a file (in XMPP case send the upload URL because XMPP has no native upload support).
+	if msg.Extra != nil {
+		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+			b.Log.Debugf("=> Sending attachement message %#v", rmsg)
+			if _, err := b.xc.Send(xmpp.Chat{
+				Type:   "groupchat",
+				Remote: rmsg.Channel + "@" + b.GetString("Muc"),
+				Text:   rmsg.Username + rmsg.Text,
+			}); err != nil {
+				b.Log.WithError(err).Error("Unable to send message with share URL.")
+			}
+		}
+		if len(msg.Extra["file"]) > 0 {
+			return "", b.handleUploadFile(&msg)
+		}
+	}
+
+	var msgReplaceID string
+	msgID := xid.New().String()
+	if msg.ID != "" {
+		msgID = msg.ID
+		msgReplaceID = msg.ID
+	}
+	// Post normal message.
+	b.Log.Debugf("=> Sending message %#v", msg)
+	if _, err := b.xc.Send(xmpp.Chat{
+		Type:      "groupchat",
+		Remote:    msg.Channel + "@" + b.GetString("Muc"),
+		Text:      msg.Username + msg.Text,
+		ID:        msgID,
+		ReplaceID: msgReplaceID,
+	}); err != nil {
+		return "", err
+	}
+	return msgID, nil
+}
+
+func (b *Bxmpp) createXMPP() error {
+	if !strings.Contains(b.GetString("Jid"), "@") {
+		return fmt.Errorf("the Jid %s doesn't contain an @", b.GetString("Jid"))
+	}
+	tc := &tls.Config{
+		ServerName:         strings.Split(b.GetString("Jid"), "@")[1],
+		InsecureSkipVerify: b.GetBool("SkipTLSVerify"), // nolint: gosec
+	}
+
+	xmpp.DebugWriter = b.Log.Writer()
+
+	options := xmpp.Options{
+		Host:                         b.GetString("Server"),
+		User:                         b.GetString("Jid"),
+		Password:                     b.GetString("Password"),
+		NoTLS:                        true,
+		StartTLS:                     true,
+		TLSConfig:                    tc,
+		Debug:                        b.GetBool("debug"),
+		Session:                      true,
+		Status:                       "",
+		StatusMessage:                "",
+		Resource:                     "",
+		InsecureAllowUnencryptedAuth: false,
+	}
+	var err error
+	b.xc, err = options.NewClient()
+	return err
+}
+
+func (b *Bxmpp) manageConnection() {
+	b.setConnected(true)
+	initial := true
+	bf := &backoff.Backoff{
+		Min:    time.Second,
+		Max:    5 * time.Minute,
+		Jitter: true,
+	}
+
+	// Main connection loop. Each iteration corresponds to a successful
+	// connection attempt and the subsequent handling of the connection.
+	for {
+		if initial {
+			initial = false
+		} else {
+			b.Remote <- config.Message{
+				Username: "system",
+				Text:     "rejoin",
+				Channel:  "",
+				Account:  b.Account,
+				Event:    config.EventRejoinChannels,
+			}
+		}
+
+		if err := b.handleXMPP(); err != nil {
+			b.Log.WithError(err).Error("Disconnected.")
+			b.setConnected(false)
+		}
+
+		// Reconnection loop using an exponential back-off strategy. We
+		// only break out of the loop if we have successfully reconnected.
+		for {
+			d := bf.Duration()
+			b.Log.Infof("Reconnecting in %s.", d)
+			time.Sleep(d)
+
+			b.Log.Infof("Reconnecting now.")
+			if err := b.createXMPP(); err == nil {
+				b.setConnected(true)
+				bf.Reset()
+				break
+			}
+			b.Log.Warn("Failed to reconnect.")
+		}
+	}
+}
+
+func (b *Bxmpp) xmppKeepAlive() chan bool {
+	done := make(chan bool)
+	go func() {
+		ticker := time.NewTicker(90 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				b.Log.Debugf("PING")
+				if err := b.xc.PingC2S("", ""); err != nil {
+					b.Log.Debugf("PING failed %#v", err)
+				}
+			case <-done:
+				return
+			}
+		}
+	}()
+	return done
+}
+
+func (b *Bxmpp) handleXMPP() error {
+	b.startTime = time.Now()
+
+	done := b.xmppKeepAlive()
+	defer close(done)
+
+	for {
+		m, err := b.xc.Recv()
+		if err != nil {
+			return err
+		}
+
+		switch v := m.(type) {
+		case xmpp.Chat:
+			if v.Type == "groupchat" {
+				b.Log.Debugf("== Receiving %#v", v)
+
+				// Skip invalid messages.
+				if b.skipMessage(v) {
+					continue
+				}
+
+				var event string
+				if strings.Contains(v.Text, "has set the subject to:") {
+					event = config.EventTopicChange
+				}
+
+				available, sok := b.avatarAvailability[v.Remote]
+				avatar := ""
+				if !sok {
+					b.Log.Debugf("Requesting avatar data")
+					b.avatarAvailability[v.Remote] = false
+					b.xc.AvatarRequestData(v.Remote)
+				} else if available {
+					avatar = getAvatar(b.avatarMap, v.Remote, b.General)
+				}
+
+				msgID := v.ID
+				if v.ReplaceID != "" {
+					msgID = v.ReplaceID
+				}
+				rmsg := config.Message{
+					Username: b.parseNick(v.Remote),
+					Text:     v.Text,
+					Channel:  b.parseChannel(v.Remote),
+					Account:  b.Account,
+					Avatar:   avatar,
+					UserID:   v.Remote,
+					ID:       msgID,
+					Event:    event,
+				}
+
+				// Check if we have an action event.
+				var ok bool
+				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.AvatarData:
+			b.handleDownloadAvatar(v)
+			b.avatarAvailability[v.From] = true
+			b.Log.Debugf("Avatar for %s is now available", v.From)
+		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) error {
+	var urlDesc string
+
+	for _, file := range msg.Extra["file"] {
+		fileInfo := file.(config.FileInfo)
+		if fileInfo.Comment != "" {
+			msg.Text += fileInfo.Comment + ": "
+		}
+		if fileInfo.URL != "" {
+			msg.Text = fileInfo.URL
+			if fileInfo.Comment != "" {
+				msg.Text = fileInfo.Comment + ": " + fileInfo.URL
+				urlDesc = fileInfo.Comment
+			}
+		}
+		if _, err := b.xc.Send(xmpp.Chat{
+			Type:   "groupchat",
+			Remote: msg.Channel + "@" + b.GetString("Muc"),
+			Text:   msg.Username + msg.Text,
+		}); err != nil {
+			return err
+		}
+
+		if fileInfo.URL != "" {
+			if _, err := b.xc.SendOOB(xmpp.Chat{
+				Type:    "groupchat",
+				Remote:  msg.Channel + "@" + b.GetString("Muc"),
+				Ooburl:  fileInfo.URL,
+				Oobdesc: urlDesc,
+			}); err != nil {
+				b.Log.WithError(err).Warn("Failed to send share URL.")
+			}
+		}
+	}
+	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
+	}
+
+	// do not show subjects on connect #732
+	if strings.Contains(message.Text, "has set the subject to:") && time.Since(b.startTime) < time.Second*5 {
+		return true
+	}
+
+	// skip delayed messages
+	return !message.Stamp.IsZero() && time.Since(message.Stamp).Minutes() > 5
+}
+
+func (b *Bxmpp) setConnected(state bool) {
+	b.Lock()
+	b.connected = state
+	defer b.Unlock()
+}
+
+func (b *Bxmpp) Connected() bool {
+	b.RLock()
+	defer b.RUnlock()
+	return b.connected
+}

bridge/zulip/zulip.go

@@ -0,0 +1,207 @@
+package bzulip
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"sync"
+	"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
+	sync.RWMutex
+}
+
+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, err := b.q.GetEvents()
+		switch err {
+		case gzb.BackoffError:
+			time.Sleep(time.Second * 5)
+		case gzb.NoJSONError:
+			b.Log.Error("Response wasn't JSON, server down or restarting? sleeping 10 seconds")
+			time.Sleep(time.Second * 10)
+		case gzb.BadEventQueueError:
+			b.Log.Info("got a bad event queue id error, reconnecting")
+			b.bot.Queues = nil
+			for {
+				b.q, err = b.bot.RegisterAll()
+				if err != nil {
+					b.Log.Errorf("reconnecting failed: %s. Sleeping 10 seconds", err)
+					time.Sleep(time.Second * 10)
+				}
+				break
+			}
+		case gzb.HeartbeatError:
+			b.Log.Debug("heartbeat received.")
+		default:
+			b.Log.Debugf("receiving error: %#v", err)
+		}
+		if err != nil {
+			continue
+		}
+		for _, m := range messages {
+			b.Log.Debugf("== Receiving %#v", m)
+			// ignore our own messages
+			if m.SenderEmail == b.GetString("login") {
+				continue
+			}
+			rmsg := config.Message{
+				Username: m.SenderFullName,
+				Text:     m.Content,
+				Channel:  b.getChannel(m.StreamID) + "/topic:" + m.Subject,
+				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 := ""
+	if strings.Contains(msg.Channel, "/topic:") {
+		res := strings.Split(msg.Channel, "/topic:")
+		topic = res[1]
+		msg.Channel = res[0]
+	}
+	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
+}

config.go

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

contrib/api.yaml

@@ -0,0 +1,210 @@
+openapi: 3.0.0
+info:
+  contact: {}
+  description: A read/write API for the Matterbridge chat bridge.
+  license:
+    name: Apache 2.0
+    url: 'https://github.com/42wim/matterbridge/blob/master/LICENSE'
+  title: Matterbridge API
+  version: "0.1.0-oas3"
+paths:
+  /health:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            '*/*':
+              schema:
+                type: string
+      summary: Checks if the server is alive.
+  /message:
+    post:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/config.OutgoingMessageResponse'
+      summary: Create a message
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/config.OutgoingMessage'
+        description: Message object to create
+        required: true
+  /messages:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                items:
+                  $ref: '#/components/schemas/config.IncomingMessage'
+                type: array
+      security:
+        - ApiKeyAuth: []
+      summary: List new messages
+  /stream:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/x-json-stream:
+              schema:
+                $ref: '#/components/schemas/config.IncomingMessage'
+      summary: Stream realtime messages
+servers:
+  - url: /api
+components:
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+  schemas:
+    config.IncomingMessage:
+      properties:
+        avatar:
+          description: URL to an avatar image
+          example: >-
+            https://secure.gravatar.com/avatar/1234567890abcdef1234567890abcdef.jpg
+          type: string
+        event:
+          description: >-
+            A specific matterbridge event. (see
+            https://github.com/42wim/matterbridge/blob/master/bridge/config/config.go#L16)
+          type: string
+        gateway:
+          description: Name of the gateway as configured in matterbridge.toml
+          example: mygateway
+          type: string
+        text:
+          description: Content of the message
+          example: 'Testing, testing, 1-2-3.'
+          type: string
+        username:
+          description: Human-readable username
+          example: alice
+          type: string
+        account:
+          description: Unique account name of format "[protocol].[slug]" as defined in matterbridge.toml 
+          example: slack.myteam
+          type: string
+        channel:
+          description: Human-readable channel name of sending bridge
+          example: test-channel
+          type: string
+        id:
+          description: Unique ID of message on the gateway
+          example: slack 1541361213.030700
+          type: string
+        parent_id:
+          description: Unique ID of a parent message, if threaded
+          example: slack 1541361213.030700
+          type: string
+        protocol:
+          description: Chat protocol of the sending bridge
+          example: slack
+          type: string
+        timestamp:
+          description: Timestamp of the message
+          example: "1541361213.030700"
+          type: string
+        userid:
+          description: Userid on the sending bridge
+          example: U4MCXJKNC
+          type: string
+        extra:
+          description: Extra data that doesn't fit in other fields (eg base64 encoded files)
+          type: object
+    config.OutgoingMessage:
+      properties:
+        avatar:
+          description: URL to an avatar image
+          example: >-
+            https://secure.gravatar.com/avatar/1234567890abcdef1234567890abcdef.jpg
+          type: string
+        event:
+          description: >-
+            A specific matterbridge event. (see
+            https://github.com/42wim/matterbridge/blob/master/bridge/config/config.go#L16)
+          example: ""
+          type: string
+        gateway:
+          description: Name of the gateway as configured in matterbridge.toml
+          example: mygateway
+          type: string
+        text:
+          description: Content of the message
+          example: 'Testing, testing, 1-2-3.'
+          type: string
+        username:
+          description: Human-readable username
+          example: alice
+          type: string
+      type: object
+      required:
+        - gateway
+        - text
+        - username
+    config.OutgoingMessageResponse:
+      properties:
+        avatar:
+          description: URL to an avatar image
+          example: >-
+            https://secure.gravatar.com/avatar/1234567890abcdef1234567890abcdef.jpg
+          type: string
+        event:
+          description: >-
+            A specific matterbridge event. (see
+            https://github.com/42wim/matterbridge/blob/master/bridge/config/config.go#L16)
+          example: ""
+          type: string
+        gateway:
+          description: Name of the gateway as configured in matterbridge.toml
+          example: mygateway
+          type: string
+        text:
+          description: Content of the message
+          example: 'Testing, testing, 1-2-3.'
+          type: string
+        username:
+          description: Human-readable username
+          example: alice
+          type: string
+        account:
+          description: fixed api account 
+          example: api.local
+          type: string
+        channel:
+          description: fixed api channel 
+          example: api
+          type: string
+        id:
+          example: ""
+          type: string
+        parent_id:
+          example: ""
+          type: string
+        protocol:
+          description: fixed api protocol
+          example: api
+          type: string
+        timestamp:
+          description: Timestamp of the message
+          example: "1541361213.030700"
+          type: string
+        userid:
+          example: ""
+          type: string
+        extra:
+          example: null
+          type: object
+      type: object
+security:
+  - bearerAuth: []

contrib/example.tengo

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

contrib/matterbridge.service

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

contrib/outmessage-discordemoji.tengo

@@ -0,0 +1,10 @@
+text := import("text")
+
+// if we're not sending to a discord bridge,
+// then convert custom emoji tags into url's
+if (inProtocol == "discord" && outProtocol != "discord") {
+    rePNG := text.re_compile(`<:.*?:([0-9]+)>`)
+    msgText=rePNG.replace(msgText,"https://cdn.discordapp.com/emojis/$1.png")
+    reGIF := text.re_compile(`<a:.*?:([0-9]+)>`)
+    msgText=reGIF.replace(msgText,"https://cdn.discordapp.com/emojis/$1.gif")
+}

contrib/outmessage-irccolornick.tengo

@@ -0,0 +1,14 @@
+// See https://github.com/42wim/matterbridge/issues/881
+// Generates a colored nick for each msgUsername, with example to filter specific codes 
+
+text := import("text")
+fmt := import("fmt")
+if outProtocol == "irc" {
+    // generate a color for a nick, make sure it isn't 0 or 15
+    colorCode := len(msgUsername)+bytes(msgUsername)[0]%14 + 2
+    // example if we want to use colorCode 3 when we have calculated colorcode 14
+    if colorCode == 14 {
+        colorCode = 3
+    }
+    msgUsername=fmt.sprintf("\x03%02d%s\x0F", colorCode, msgUsername)
+}

contrib/outmessage-irccolors.tengo

@@ -0,0 +1,7 @@
+// See https://github.com/42wim/matterbridge/issues/798
+
+// if we're not sending to an irc bridge we strip the IRC colors
+if outProtocol != "irc" {
+    re := text.re_compile(`\x03(?:\d{1,2}(?:,\d{1,2})?)?|[[:cntrl:]]`)
+    msgText=re.replace(msgText,"")
+}

contrib/remotenickformat-zerowidth.tengo

@@ -0,0 +1,16 @@
+/*
+This script will return the nick except with multi-character usernames
+containing a zero-width space between the first and second character letter.
+
+Single character usernames will be left untouched.
+
+This is useful to prevent remote users from nickalerting
+IRC users of the same name when the remote user speaks.
+
+This result can be used in {TENGO} in RemoteNickFormat.
+*/
+
+result = nick
+if len(nick) > 1 {
+    result = string(nick[0]) + "​" + nick[1:]
+}

contrib/remotenickformat.tengo

@@ -0,0 +1,9 @@
+/*
+This script will return the current time in kitchen format if the protocol (of the remote bridge) isn't irc
+See https://github.com/d5/tengo/blob/master/docs/stdlib-times.md
+This result can be used in {TENGO} in RemoteNickFormat
+*/
+times := import("times")
+if protocol != "irc" {
+   result=times.time_format(times.now(),times.format_kitchen)
+}

docker/arm/Dockerfile

@@ -0,0 +1,9 @@
+FROM alpine:edge as certs
+RUN apk --update add ca-certificates
+
+FROM scratch
+ARG VERSION=1.12.3
+COPY --from=certs /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
+ADD https://github.com/42wim/matterbridge/releases/download/v${VERSION}/matterbridge-linux-arm /bin/matterbridge
+RUN chmod +x /bin/matterbridge
+ENTRYPOINT ["/bin/matterbridge"]

gateway/bench.tengo

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

gateway/bridgemap/api.go

@@ -0,0 +1,11 @@
+// +build !noapi
+
+package bridgemap
+
+import (
+	"github.com/42wim/matterbridge/bridge/api"
+)
+
+func init() {
+	FullMap["api"] = api.New
+}

gateway/bridgemap/bdiscord.go

@@ -0,0 +1,12 @@
+// +build !nodiscord
+
+package bridgemap
+
+import (
+	bdiscord "github.com/42wim/matterbridge/bridge/discord"
+)
+
+func init() {
+	FullMap["discord"] = bdiscord.New
+	UserTypingSupport["discord"] = struct{}{}
+}

gateway/bridgemap/bgitter.go

@@ -0,0 +1,11 @@
+// +build !nogitter
+
+package bridgemap
+
+import (
+	bgitter "github.com/42wim/matterbridge/bridge/gitter"
+)
+
+func init() {
+	FullMap["gitter"] = bgitter.New
+}

gateway/bridgemap/birc.go

@@ -0,0 +1,11 @@
+// +build !noirc
+
+package bridgemap
+
+import (
+	birc "github.com/42wim/matterbridge/bridge/irc"
+)
+
+func init() {
+	FullMap["irc"] = birc.New
+}

gateway/bridgemap/bkeybase.go

@@ -0,0 +1,11 @@
+// +build !nokeybase
+
+package bridgemap
+
+import (
+	bkeybase "github.com/42wim/matterbridge/bridge/keybase"
+)
+
+func init() {
+	FullMap["keybase"] = bkeybase.New
+}

gateway/bridgemap/bmatrix.go

@@ -0,0 +1,11 @@
+// +build !nomatrix
+
+package bridgemap
+
+import (
+	bmatrix "github.com/42wim/matterbridge/bridge/matrix"
+)
+
+func init() {
+	FullMap["matrix"] = bmatrix.New
+}

gateway/bridgemap/bmattermost.go

@@ -0,0 +1,11 @@
+// +build !nomattermost
+
+package bridgemap
+
+import (
+	bmattermost "github.com/42wim/matterbridge/bridge/mattermost"
+)
+
+func init() {
+	FullMap["mattermost"] = bmattermost.New
+}

gateway/bridgemap/bmsteams.go

@@ -0,0 +1,11 @@
+// +build !nomsteams
+
+package bridgemap
+
+import (
+	bmsteams "github.com/42wim/matterbridge/bridge/msteams"
+)
+
+func init() {
+	FullMap["msteams"] = bmsteams.New
+}

gateway/bridgemap/bnctalk.go

@@ -0,0 +1,11 @@
+// +build !nonctalk
+
+package bridgemap
+
+import (
+	btalk "github.com/42wim/matterbridge/bridge/nctalk"
+)
+
+func init() {
+	FullMap["nctalk"] = btalk.New
+}

gateway/bridgemap/bridgemap.go

@@ -0,0 +1,10 @@
+package bridgemap
+
+import (
+	"github.com/42wim/matterbridge/bridge"
+)
+
+var (
+	FullMap           = map[string]bridge.Factory{}
+	UserTypingSupport = map[string]struct{}{}
+)

gateway/bridgemap/brocketchat.go

@@ -0,0 +1,11 @@
+// +build !norocketchat
+
+package bridgemap
+
+import (
+	brocketchat "github.com/42wim/matterbridge/bridge/rocketchat"
+)
+
+func init() {
+	FullMap["rocketchat"] = brocketchat.New
+}

gateway/bridgemap/bslack.go

@@ -0,0 +1,13 @@
+// +build !noslack
+
+package bridgemap
+
+import (
+	bslack "github.com/42wim/matterbridge/bridge/slack"
+)
+
+func init() {
+	FullMap["slack-legacy"] = bslack.NewLegacy
+	FullMap["slack"] = bslack.New
+	UserTypingSupport["slack"] = struct{}{}
+}

gateway/bridgemap/bsshchat.go

@@ -0,0 +1,11 @@
+// +build !nosshchat
+
+package bridgemap
+
+import (
+	bsshchat "github.com/42wim/matterbridge/bridge/sshchat"
+)
+
+func init() {
+	FullMap["sshchat"] = bsshchat.New
+}

gateway/bridgemap/bsteam.go

@@ -0,0 +1,11 @@
+// +build !nosteam
+
+package bridgemap
+
+import (
+	bsteam "github.com/42wim/matterbridge/bridge/steam"
+)
+
+func init() {
+	FullMap["steam"] = bsteam.New
+}

gateway/bridgemap/btelegram.go

@@ -0,0 +1,11 @@
+// +build !notelegram
+
+package bridgemap
+
+import (
+	btelegram "github.com/42wim/matterbridge/bridge/telegram"
+)
+
+func init() {
+	FullMap["telegram"] = btelegram.New
+}

gateway/bridgemap/bwhatsapp.go

@@ -0,0 +1,11 @@
+// +build !nowhatsapp
+
+package bridgemap
+
+import (
+	bwhatsapp "github.com/42wim/matterbridge/bridge/whatsapp"
+)
+
+func init() {
+	FullMap["whatsapp"] = bwhatsapp.New
+}

gateway/bridgemap/bxmpp.go

@@ -0,0 +1,11 @@
+// +build !noxmpp
+
+package bridgemap
+
+import (
+	bxmpp "github.com/42wim/matterbridge/bridge/xmpp"
+)
+
+func init() {
+	FullMap["xmpp"] = bxmpp.New
+}

gateway/bridgemap/bzulip.go

@@ -0,0 +1,11 @@
+// +build !nozulip
+
+package bridgemap
+
+import (
+	bzulip "github.com/42wim/matterbridge/bridge/zulip"
+)
+
+func init() {
+	FullMap["zulip"] = bzulip.New
+}

gateway/gateway.go

@@ -0,0 +1,606 @@
+package gateway
+
+import (
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/internal"
+	"github.com/d5/tengo/v2"
+	"github.com/d5/tengo/v2/stdlib"
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/matterbridge/emoji"
+	"github.com/sirupsen/logrus"
+)
+
+type Gateway struct {
+	config.Config
+
+	Router         *Router
+	MyConfig       *config.Gateway
+	Bridges        map[string]*bridge.Bridge
+	Channels       map[string]*config.ChannelInfo
+	ChannelOptions map[string]config.ChannelOptions
+	Message        chan config.Message
+	Name           string
+	Messages       *lru.Cache
+
+	logger *logrus.Entry
+}
+
+type BrMsgID struct {
+	br        *bridge.Bridge
+	ID        string
+	ChannelID string
+}
+
+const apiProtocol = "api"
+
+// New creates a new Gateway object associated with the specified router and
+// following the given configuration.
+func New(rootLogger *logrus.Logger, cfg *config.Gateway, r *Router) *Gateway {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "gateway"})
+
+	cache, _ := lru.New(5000)
+	gw := &Gateway{
+		Channels: make(map[string]*config.ChannelInfo),
+		Message:  r.Message,
+		Router:   r,
+		Bridges:  make(map[string]*bridge.Bridge),
+		Config:   r.Config,
+		Messages: cache,
+		logger:   logger,
+	}
+	if err := gw.AddConfig(cfg); err != nil {
+		logger.Errorf("Failed to add configuration to gateway: %#v", err)
+	}
+	return gw
+}
+
+// FindCanonicalMsgID returns the ID under which a message was stored in the cache.
+func (gw *Gateway) FindCanonicalMsgID(protocol string, mID string) string {
+	ID := protocol + " " + mID
+	if gw.Messages.Contains(ID) {
+		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)
+			}
+		}
+	}
+	return ""
+}
+
+// AddBridge sets up a new bridge in the gateway object with the specified configuration.
+func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
+	br := gw.Router.getBridge(cfg.Account)
+	if br == nil {
+		gw.checkConfig(cfg)
+		br = bridge.New(cfg)
+		br.Config = gw.Router.Config
+		br.General = &gw.BridgeValues().General
+		br.Log = gw.logger.WithFields(logrus.Fields{"prefix": br.Protocol})
+		brconfig := &bridge.Config{
+			Remote: gw.Message,
+			Bridge: br,
+		}
+		// add the actual bridger for this protocol to this bridge using the bridgeMap
+		if _, ok := gw.Router.BridgeMap[br.Protocol]; !ok {
+			gw.logger.Fatalf("Incorrect protocol %s specified in gateway configuration %s, exiting.", br.Protocol, cfg.Account)
+		}
+		br.Bridger = gw.Router.BridgeMap[br.Protocol](brconfig)
+	}
+	gw.mapChannelsToBridge(br)
+	gw.Bridges[cfg.Account] = br
+	return nil
+}
+
+func (gw *Gateway) checkConfig(cfg *config.Bridge) {
+	match := false
+	for _, key := range gw.Router.Config.Viper().AllKeys() {
+		if strings.HasPrefix(key, strings.ToLower(cfg.Account)) {
+			match = true
+			break
+		}
+	}
+	if !match {
+		gw.logger.Fatalf("Account %s defined in gateway %s but no configuration found, exiting.", cfg.Account, gw.Name)
+	}
+}
+
+// AddConfig associates a new configuration with the gateway object.
+func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
+	gw.Name = cfg.Name
+	gw.MyConfig = cfg
+	if err := gw.mapChannels(); err != nil {
+		gw.logger.Errorf("mapChannels() failed: %s", err)
+	}
+	for _, br := range append(gw.MyConfig.In, append(gw.MyConfig.InOut, gw.MyConfig.Out...)...) {
+		br := br //scopelint
+		err := gw.AddBridge(&br)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
+	for ID, channel := range gw.Channels {
+		if br.Account == channel.Account {
+			br.Channels[ID] = *channel
+		}
+	}
+}
+
+func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
+	if err := br.Disconnect(); err != nil {
+		gw.logger.Errorf("Disconnect() %s failed: %s", br.Account, err)
+	}
+	time.Sleep(time.Second * 5)
+RECONNECT:
+	gw.logger.Infof("Reconnecting %s", br.Account)
+	err := br.Connect()
+	if err != nil {
+		gw.logger.Errorf("Reconnection failed: %s. Trying again in 60 seconds", err)
+		time.Sleep(time.Second * 60)
+		goto RECONNECT
+	}
+	br.Joined = make(map[string]bool)
+	if err := br.JoinChannels(); err != nil {
+		gw.logger.Errorf("JoinChannels() %s failed: %s", br.Account, err)
+	}
+}
+
+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)
+		}
+		if strings.HasPrefix(br.Account, "mattermost.") && strings.HasPrefix(br.Channel, "#") {
+			gw.logger.Errorf("Mattermost channels do not start with a #: remove the # in %s", br.Channel)
+			os.Exit(1)
+		}
+		if strings.HasPrefix(br.Account, "zulip.") && !strings.Contains(br.Channel, "/topic:") {
+			gw.logger.Errorf("Breaking change, since matterbridge 1.14.0 zulip channels need to specify the topic with channel/topic:mytopic in %s of %s", br.Channel, br.Account)
+			os.Exit(1)
+		}
+		ID := br.Channel + br.Account
+		if _, ok := gw.Channels[ID]; !ok {
+			channel := &config.ChannelInfo{
+				Name:        br.Channel,
+				Direction:   direction,
+				ID:          ID,
+				Options:     br.Options,
+				Account:     br.Account,
+				SameChannel: make(map[string]bool),
+			}
+			channel.SameChannel[gw.Name] = br.SameChannel
+			gw.Channels[channel.ID] = channel
+		} else {
+			// if we already have a key and it's not our current direction it means we have a bidirectional inout
+			if gw.Channels[ID].Direction != direction {
+				gw.Channels[ID].Direction = "inout"
+			}
+		}
+		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
+	}
+}
+
+func (gw *Gateway) mapChannels() error {
+	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
+	return nil
+}
+
+func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
+	var channels []config.ChannelInfo
+
+	// for messages received from the api check that the gateway is the specified one
+	if msg.Protocol == apiProtocol && gw.Name != msg.Gateway {
+		return channels
+	}
+
+	// discord join/leave is for the whole bridge, isn't a per channel join/leave
+	if msg.Event == config.EventJoinLeave && getProtocol(msg) == "discord" && msg.Channel == "" {
+		for _, channel := range gw.Channels {
+			if channel.Account == dest.Account && strings.Contains(channel.Direction, "out") &&
+				gw.validGatewayDest(msg) {
+				channels = append(channels, *channel)
+			}
+		}
+		return channels
+	}
+
+	// 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 logic
+		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 {
+	if res, ok := gw.Messages.Get(msgID); ok {
+		IDs := res.([]*BrMsgID)
+		for _, id := range IDs {
+			// check protocol, bridge name and channelname
+			// for people that reuse the same bridge multiple times. see #342
+			if dest.Protocol == id.br.Protocol && dest.Name == id.br.Name && channel.ID == id.ChannelID {
+				return strings.Replace(id.ID, dest.Protocol+" ", "", 1)
+			}
+		}
+	}
+	return ""
+}
+
+// ignoreTextEmpty returns true if we need to ignore a message with an empty text.
+func (gw *Gateway) ignoreTextEmpty(msg *config.Message) bool {
+	if msg.Text != "" {
+		return false
+	}
+	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
+	}
+	gw.logger.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
+	return true
+}
+
+func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
+	// if we don't have the bridge, ignore it
+	if _, ok := gw.Bridges[msg.Account]; !ok {
+		return true
+	}
+
+	igNicks := strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreNicks"))
+	igMessages := strings.Fields(gw.Bridges[msg.Account].GetString("IgnoreMessages"))
+	if gw.ignoreTextEmpty(msg) || gw.ignoreText(msg.Username, igNicks) || gw.ignoreText(msg.Text, igMessages) {
+		return true
+	}
+
+	return false
+}
+
+func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) string {
+	if dest.GetBool("StripNick") {
+		re := regexp.MustCompile("[^a-zA-Z0-9]+")
+		msg.Username = re.ReplaceAllString(msg.Username, "")
+	}
+	nick := dest.GetString("RemoteNickFormat")
+
+	// loop to replace nicks
+	br := gw.Bridges[msg.Account]
+	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 {
+			gw.logger.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)
+	tengoNick, err := gw.modifyUsernameTengo(msg, br)
+	if err != nil {
+		gw.logger.Errorf("modifyUsernameTengo error: %s", err)
+	}
+	nick = strings.Replace(nick, "{TENGO}", tengoNick, -1) //nolint:gocritic
+	return nick
+}
+
+func (gw *Gateway) modifyAvatar(msg *config.Message, dest *bridge.Bridge) string {
+	iconurl := dest.GetString("IconURL")
+	iconurl = strings.Replace(iconurl, "{NICK}", msg.Username, -1)
+	if msg.Avatar == "" {
+		msg.Avatar = iconurl
+	}
+	return msg.Avatar
+}
+
+func (gw *Gateway) modifyMessage(msg *config.Message) {
+	if err := modifyMessageTengo(gw.BridgeValues().General.TengoModifyMessage, msg); err != nil {
+		gw.logger.Errorf("TengoModifyMessage failed: %s", err)
+	}
+	if err := modifyMessageTengo(gw.BridgeValues().Tengo.Message, msg); err != nil {
+		gw.logger.Errorf("Tengo.Message failed: %s", err)
+	}
+
+	// replace :emoji: to unicode
+	msg.Text = emoji.Sprint(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 {
+			gw.logger.Errorf("regexp in %s failed: %s", msg.Account, err)
+			break
+		}
+		msg.Text = re.ReplaceAllString(msg.Text, replace)
+	}
+
+	gw.handleExtractNicks(msg)
+
+	// messages from api have Gateway specified, don't overwrite
+	if msg.Protocol != apiProtocol {
+		msg.Gateway = gw.Name
+	}
+}
+
+// SendMessage sends a message (with specified parentID) to the channel on the selected
+// destination bridge and returns a message ID or an error.
+func (gw *Gateway) SendMessage(
+	rmsg *config.Message,
+	dest *bridge.Bridge,
+	channel *config.ChannelInfo,
+	canonicalParentMsgID string,
+) (string, error) {
+	msg := *rmsg
+	// Only send the avatar download event to ourselves.
+	if msg.Event == config.EventAvatarDownload {
+		if channel.ID != getChannelID(rmsg) {
+			return "", nil
+		}
+	} else {
+		// do not send to ourself for any other event
+		if channel.ID == getChannelID(rmsg) {
+			return "", nil
+		}
+	}
+
+	// Too noisy to log like other events
+	if msg.Event != config.EventUserTyping {
+		gw.logger.Debugf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, rmsg.Channel, dest.Account, channel.Name)
+	}
+
+	msg.Channel = channel.Name
+	msg.Avatar = gw.modifyAvatar(rmsg, dest)
+	msg.Username = gw.modifyUsername(rmsg, dest)
+
+	msg.ID = gw.getDestMsgID(rmsg.Protocol+" "+rmsg.ID, dest, channel)
+
+	// for api we need originchannel as channel
+	if dest.Protocol == apiProtocol {
+		msg.Channel = rmsg.Channel
+	}
+
+	msg.ParentID = gw.getDestMsgID(rmsg.Protocol+" "+canonicalParentMsgID, dest, channel)
+	if msg.ParentID == "" {
+		msg.ParentID = canonicalParentMsgID
+	}
+
+	// if the parentID is still empty and we have a parentID set in the original message
+	// this means that we didn't find it in the cache so set it "msg-parent-not-found"
+	if msg.ParentID == "" && rmsg.ParentID != "" {
+		msg.ParentID = "msg-parent-not-found"
+	}
+
+	err := gw.modifySendMessageTengo(rmsg, &msg, dest)
+	if err != nil {
+		gw.logger.Errorf("modifySendMessageTengo: %s", err)
+	}
+
+	// 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 {
+		return mID, err
+	}
+
+	// append the message ID (mID) from this bridge (dest) to our brMsgIDs slice
+	if mID != "" {
+		gw.logger.Debugf("mID %s: %s", dest.Account, mID)
+		return mID, nil
+		//brMsgIDs = append(brMsgIDs, &BrMsgID{dest, dest.Protocol + " " + mID, channel.ID})
+	}
+	return "", nil
+}
+
+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.")
+}
+
+// ignoreText returns true if text matches any of the input regexes.
+func (gw *Gateway) ignoreText(text string, input []string) bool {
+	for _, entry := range input {
+		if entry == "" {
+			continue
+		}
+		// TODO do not compile regexps everytime
+		re, err := regexp.Compile(entry)
+		if err != nil {
+			gw.logger.Errorf("incorrect regexp %s", entry)
+			continue
+		}
+		if re.MatchString(text) {
+			gw.logger.Debugf("matching %s. ignoring %s", entry, text)
+			return true
+		}
+	}
+	return false
+}
+
+func getProtocol(msg *config.Message) string {
+	p := strings.Split(msg.Account, ".")
+	return p[0]
+}
+
+func modifyMessageTengo(filename string, msg *config.Message) error {
+	if filename == "" {
+		return nil
+	}
+	res, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	s := tengo.NewScript(res)
+	s.SetImports(stdlib.GetModuleMap(stdlib.AllModuleNames()...))
+	_ = s.Add("msgText", msg.Text)
+	_ = s.Add("msgUsername", msg.Username)
+	_ = s.Add("msgAccount", msg.Account)
+	_ = s.Add("msgChannel", msg.Channel)
+	c, err := s.Compile()
+	if err != nil {
+		return err
+	}
+	if err := c.Run(); err != nil {
+		return err
+	}
+	msg.Text = c.Get("msgText").String()
+	msg.Username = c.Get("msgUsername").String()
+	return nil
+}
+
+func (gw *Gateway) modifyUsernameTengo(msg *config.Message, br *bridge.Bridge) (string, error) {
+	filename := gw.BridgeValues().Tengo.RemoteNickFormat
+	if filename == "" {
+		return "", nil
+	}
+	res, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+	s := tengo.NewScript(res)
+	s.SetImports(stdlib.GetModuleMap(stdlib.AllModuleNames()...))
+	_ = s.Add("result", "")
+	_ = s.Add("msgText", msg.Text)
+	_ = s.Add("msgUsername", msg.Username)
+	_ = s.Add("nick", msg.Username)
+	_ = s.Add("msgAccount", msg.Account)
+	_ = s.Add("msgChannel", msg.Channel)
+	_ = s.Add("channel", msg.Channel)
+	_ = s.Add("msgProtocol", msg.Protocol)
+	_ = s.Add("remoteAccount", br.Account)
+	_ = s.Add("protocol", br.Protocol)
+	_ = s.Add("bridge", br.Name)
+	_ = s.Add("gateway", gw.Name)
+	c, err := s.Compile()
+	if err != nil {
+		return "", err
+	}
+	if err := c.Run(); err != nil {
+		return "", err
+	}
+	return c.Get("result").String(), nil
+}
+
+func (gw *Gateway) modifySendMessageTengo(origmsg *config.Message, msg *config.Message, br *bridge.Bridge) error {
+	filename := gw.BridgeValues().Tengo.OutMessage
+	var res []byte
+	var err error
+	if filename == "" {
+		res, err = internal.Asset("tengo/outmessage.tengo")
+		if err != nil {
+			return err
+		}
+	} else {
+		res, err = ioutil.ReadFile(filename)
+		if err != nil {
+			return err
+		}
+	}
+	s := tengo.NewScript(res)
+	s.SetImports(stdlib.GetModuleMap(stdlib.AllModuleNames()...))
+	_ = s.Add("inAccount", origmsg.Account)
+	_ = s.Add("inProtocol", origmsg.Protocol)
+	_ = s.Add("inChannel", origmsg.Channel)
+	_ = s.Add("inGateway", origmsg.Gateway)
+	_ = s.Add("inEvent", origmsg.Event)
+	_ = s.Add("outAccount", br.Account)
+	_ = s.Add("outProtocol", br.Protocol)
+	_ = s.Add("outChannel", msg.Channel)
+	_ = s.Add("outGateway", gw.Name)
+	_ = s.Add("outEvent", msg.Event)
+	_ = s.Add("msgText", msg.Text)
+	_ = s.Add("msgUsername", msg.Username)
+	c, err := s.Compile()
+	if err != nil {
+		return err
+	}
+	if err := c.Run(); err != nil {
+		return err
+	}
+	msg.Text = c.Get("msgText").String()
+	msg.Username = c.Get("msgUsername").String()
+	return nil
+}

gateway/gateway_test.go

@@ -0,0 +1,541 @@
+package gateway
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strconv"
+	"testing"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway/bridgemap"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+var testconfig = []byte(`
+[irc.freenode]
+server=""
+[mattermost.test]
+server=""
+[gitter.42wim]
+server=""
+[discord.test]
+server=""
+[slack.test]
+server=""
+
+[[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]
+server=""
+[mattermost.test]
+server=""
+[gitter.42wim]
+server=""
+[discord.test]
+server=""
+[slack.test]
+server=""
+
+[[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]
+server=""
+[telegram.zzz]
+server=""
+[slack.zzz]
+server=""
+[[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 {
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	cfg := config.NewConfigFromString(logger, input)
+	r, err := NewRouter(logger, cfg, bridgemap.FullMap)
+	if err != nil {
+		fmt.Println(err)
+	}
+	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)
+}
+
+type ignoreTestSuite struct {
+	suite.Suite
+
+	gw *Gateway
+}
+
+func TestIgnoreSuite(t *testing.T) {
+	s := &ignoreTestSuite{}
+	suite.Run(t, s)
+}
+
+func (s *ignoreTestSuite) SetupSuite() {
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	s.gw = &Gateway{logger: logrus.NewEntry(logger)}
+}
+func (s *ignoreTestSuite) TestIgnoreTextEmpty() {
+	extraFile := make(map[string][]interface{})
+	extraAttach := make(map[string][]interface{})
+	extraFailure := make(map[string][]interface{})
+	extraFile["file"] = append(extraFile["file"], config.FileInfo{})
+	extraAttach["attachments"] = append(extraAttach["attachments"], []string{})
+	extraFailure[config.EventFileFailureSize] = append(extraFailure[config.EventFileFailureSize], config.FileInfo{})
+
+	msgTests := map[string]struct {
+		input  *config.Message
+		output bool
+	}{
+		"usertyping": {
+			input:  &config.Message{Event: config.EventUserTyping},
+			output: false,
+		},
+		"file attach": {
+			input:  &config.Message{Extra: extraFile},
+			output: false,
+		},
+		"attachments": {
+			input:  &config.Message{Extra: extraAttach},
+			output: false,
+		},
+		config.EventFileFailureSize: {
+			input:  &config.Message{Extra: extraFailure},
+			output: false,
+		},
+		"nil extra": {
+			input:  &config.Message{Extra: nil},
+			output: true,
+		},
+		"empty": {
+			input:  &config.Message{},
+			output: true,
+		},
+	}
+	for testname, testcase := range msgTests {
+		output := s.gw.ignoreTextEmpty(testcase.input)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
+	}
+
+}
+
+func (s *ignoreTestSuite) TestIgnoreTexts() {
+	msgTests := map[string]struct {
+		input  string
+		re     []string
+		output bool
+	}{
+		"no regex": {
+			input:  "a text message",
+			re:     []string{},
+			output: false,
+		},
+		"simple regex": {
+			input:  "a text message",
+			re:     []string{"text"},
+			output: true,
+		},
+		"multiple regex fail": {
+			input:  "a text message",
+			re:     []string{"abc", "123$"},
+			output: false,
+		},
+		"multiple regex pass": {
+			input:  "a text message",
+			re:     []string{"lala", "sage$"},
+			output: true,
+		},
+	}
+	for testname, testcase := range msgTests {
+		output := s.gw.ignoreText(testcase.input, testcase.re)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
+	}
+}
+
+func (s *ignoreTestSuite) TestIgnoreNicks() {
+	msgTests := map[string]struct {
+		input  string
+		re     []string
+		output bool
+	}{
+		"no entry": {
+			input:  "user",
+			re:     []string{},
+			output: false,
+		},
+		"one entry": {
+			input:  "user",
+			re:     []string{"user"},
+			output: true,
+		},
+		"multiple entries": {
+			input:  "user",
+			re:     []string{"abc", "user"},
+			output: true,
+		},
+		"multiple entries fail": {
+			input:  "user",
+			re:     []string{"abc", "def"},
+			output: false,
+		},
+	}
+	for testname, testcase := range msgTests {
+		output := s.gw.ignoreText(testcase.input, testcase.re)
+		s.Assert().Equalf(testcase.output, output, "case '%s' failed", testname)
+	}
+}
+
+func BenchmarkTengo(b *testing.B) {
+	msg := &config.Message{Username: "user", Text: "blah testing", Account: "protocol.account", Channel: "mychannel"}
+	for n := 0; n < b.N; n++ {
+		err := modifyMessageTengo("bench.tengo", msg)
+		if err != nil {
+			return
+		}
+	}
+}

gateway/handlers.go

@@ -0,0 +1,275 @@
+package gateway
+
+import (
+	"bytes"
+	"crypto/sha1" //nolint:gosec
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway/bridgemap"
+)
+
+// handleEventFailure handles failures and reconnects bridges.
+func (r *Router) handleEventFailure(msg *config.Message) {
+	if msg.Event != config.EventFailure {
+		return
+	}
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			if msg.Account == br.Account {
+				go gw.reconnectBridge(br)
+				return
+			}
+		}
+	}
+}
+
+// handleEventGetChannelMembers handles channel members
+func (r *Router) handleEventGetChannelMembers(msg *config.Message) {
+	if msg.Event != config.EventGetChannelMembers {
+		return
+	}
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			if msg.Account == br.Account {
+				cMembers := msg.Extra[config.EventGetChannelMembers][0].(config.ChannelMembers)
+				r.logger.Debugf("Syncing channelmembers from %s", msg.Account)
+				br.SetChannelMembers(&cMembers)
+				return
+			}
+		}
+	}
+}
+
+// handleEventRejoinChannels handles rejoining of channels.
+func (r *Router) handleEventRejoinChannels(msg *config.Message) {
+	if msg.Event != config.EventRejoinChannels {
+		return
+	}
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			if msg.Account == br.Account {
+				br.Joined = make(map[string]bool)
+				if err := br.JoinChannels(); err != nil {
+					r.logger.Errorf("channel join failed for %s: %s", msg.Account, err)
+				}
+			}
+		}
+	}
+}
+
+// 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
+	}
+
+	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] //nolint:gosec
+
+		if gw.BridgeValues().General.MediaServerUpload != "" {
+			// Use MediaServerUpload. Upload using a PUT HTTP request and basicauth.
+			if err := gw.handleFilesUpload(&fi); err != nil {
+				gw.logger.Error(err)
+				continue
+			}
+		} else {
+			// Use MediaServerPath. Place the file on the current filesystem.
+			if err := gw.handleFilesLocal(&fi); err != nil {
+				gw.logger.Error(err)
+				continue
+			}
+		}
+
+		// Download URL.
+		durl := gw.BridgeValues().General.MediaServerDownload + "/" + sha1sum + "/" + fi.Name
+
+		gw.logger.Debugf("mediaserver download URL = %s", durl)
+
+		// We uploaded/placed the file successfully. Add the SHA and URL.
+		extra := msg.Extra["file"][i].(config.FileInfo)
+		extra.URL = durl
+		extra.SHA = sha1sum
+		msg.Extra["file"][i] = extra
+	}
+}
+
+// handleFilesUpload uses MediaServerUpload configuration to upload the file.
+// Returns error on failure.
+func (gw *Gateway) handleFilesUpload(fi *config.FileInfo) error {
+	client := &http.Client{
+		Timeout: time.Second * 5,
+	}
+	// Use MediaServerUpload. Upload using a PUT HTTP request and basicauth.
+	sha1sum := fmt.Sprintf("%x", sha1.Sum(*fi.Data))[:8] //nolint:gosec
+	url := gw.BridgeValues().General.MediaServerUpload + "/" + sha1sum + "/" + fi.Name
+
+	req, err := http.NewRequest("PUT", url, bytes.NewReader(*fi.Data))
+	if err != nil {
+		return fmt.Errorf("mediaserver upload failed, could not create request: %#v", err)
+	}
+
+	gw.logger.Debugf("mediaserver upload url: %s", url)
+
+	req.Header.Set("Content-Type", "binary/octet-stream")
+	_, err = client.Do(req)
+	if err != nil {
+		return fmt.Errorf("mediaserver upload failed, could not Do request: %#v", err)
+	}
+	return nil
+}
+
+// handleFilesLocal use MediaServerPath configuration, places the file on the current filesystem.
+// Returns error on failure.
+func (gw *Gateway) handleFilesLocal(fi *config.FileInfo) error {
+	sha1sum := fmt.Sprintf("%x", sha1.Sum(*fi.Data))[:8] //nolint:gosec
+	dir := gw.BridgeValues().General.MediaDownloadPath + "/" + sha1sum
+	err := os.Mkdir(dir, os.ModePerm)
+	if err != nil && !os.IsExist(err) {
+		return fmt.Errorf("mediaserver path failed, could not mkdir: %s %#v", err, err)
+	}
+
+	path := dir + "/" + fi.Name
+	gw.logger.Debugf("mediaserver path placing file: %s", path)
+
+	err = ioutil.WriteFile(path, *fi.Data, os.ModePerm)
+	if err != nil {
+		return fmt.Errorf("mediaserver path failed, could not writefile: %s %#v", err, err)
+	}
+	return nil
+}
+
+// ignoreEvent returns true if we need to ignore this event for the specified destination bridge.
+func (gw *Gateway) ignoreEvent(event string, dest *bridge.Bridge) bool {
+	switch event {
+	case config.EventAvatarDownload:
+		// Avatar downloads are only relevant for telegram and mattermost for now
+		if dest.Protocol != "mattermost" && dest.Protocol != "telegram" && dest.Protocol != "xmpp" {
+			return true
+		}
+	case config.EventJoinLeave:
+		// only relay join/part when configured
+		if !dest.GetBool("ShowJoinPart") {
+			return true
+		}
+	case config.EventTopicChange:
+		// only relay topic change when used in some way on other side
+		if !dest.GetBool("ShowTopicChange") && !dest.GetBool("SyncTopic") {
+			return true
+		}
+	}
+	return false
+}
+
+// handleMessage makes sure the message get sent to the correct bridge/channels.
+// Returns an array of msg ID's
+func (gw *Gateway) handleMessage(rmsg *config.Message, dest *bridge.Bridge) []*BrMsgID {
+	var brMsgIDs []*BrMsgID
+
+	// Not all bridges support "user is typing" indications so skip the message
+	// if the targeted bridge does not support it.
+	if rmsg.Event == config.EventUserTyping {
+		if _, ok := bridgemap.UserTypingSupport[dest.Protocol]; !ok {
+			return nil
+		}
+	}
+
+	// if we have an attached file, or other info
+	if rmsg.Extra != nil && len(rmsg.Extra[config.EventFileFailureSize]) != 0 && rmsg.Text == "" {
+		return brMsgIDs
+	}
+
+	if gw.ignoreEvent(rmsg.Event, dest) {
+		return brMsgIDs
+	}
+
+	// broadcast to every out channel (irc QUIT)
+	if rmsg.Channel == "" && rmsg.Event != config.EventJoinLeave {
+		gw.logger.Debug("empty channel")
+		return brMsgIDs
+	}
+
+	// Get the ID of the parent message in thread
+	var canonicalParentMsgID string
+	if rmsg.ParentID != "" && dest.GetBool("PreserveThreading") {
+		canonicalParentMsgID = gw.FindCanonicalMsgID(rmsg.Protocol, rmsg.ParentID)
+	}
+
+	channels := gw.getDestChannel(rmsg, *dest)
+	for idx := range channels {
+		channel := &channels[idx]
+		msgID, err := gw.SendMessage(rmsg, dest, channel, canonicalParentMsgID)
+		if err != nil {
+			gw.logger.Errorf("SendMessage failed: %s", err)
+			continue
+		}
+		if msgID == "" {
+			continue
+		}
+		brMsgIDs = append(brMsgIDs, &BrMsgID{dest, dest.Protocol + " " + msgID, channel.ID})
+	}
+	return brMsgIDs
+}
+
+func (gw *Gateway) handleExtractNicks(msg *config.Message) {
+	var err error
+	br := gw.Bridges[msg.Account]
+	for _, outer := range br.GetStringSlice2D("ExtractNicks") {
+		search := outer[0]
+		replace := outer[1]
+		msg.Username, msg.Text, err = extractNick(search, replace, msg.Username, msg.Text)
+		if err != nil {
+			gw.logger.Errorf("regexp in %s failed: %s", msg.Account, err)
+			break
+		}
+	}
+}
+
+// extractNick searches for a username (based on "search" a regular expression).
+// if this matches it extracts a nick (based on "extract" another regular expression) from text
+// and replaces username with this result.
+// returns error if the regexp doesn't compile.
+func extractNick(search, extract, username, text string) (string, string, error) {
+	re, err := regexp.Compile(search)
+	if err != nil {
+		return username, text, err
+	}
+	if re.MatchString(username) {
+		re, err = regexp.Compile(extract)
+		if err != nil {
+			return username, text, err
+		}
+		res := re.FindAllStringSubmatch(text, 1)
+		// only replace if we have exactly 1 match
+		if len(res) > 0 && len(res[0]) == 2 {
+			username = res[0][1]
+			text = strings.Replace(text, res[0][0], "", 1)
+		}
+	}
+	return username, text, nil
+}

gateway/handlers_test.go

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

gateway/router.go

@@ -0,0 +1,191 @@
+package gateway
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway/samechannel"
+	"github.com/sirupsen/logrus"
+)
+
+type Router struct {
+	config.Config
+	sync.RWMutex
+
+	BridgeMap        map[string]bridge.Factory
+	Gateways         map[string]*Gateway
+	Message          chan config.Message
+	MattermostPlugin chan config.Message
+
+	logger *logrus.Entry
+}
+
+// NewRouter initializes a new Matterbridge router for the specified configuration and
+// sets up all required gateways.
+func NewRouter(rootLogger *logrus.Logger, cfg config.Config, bridgeMap map[string]bridge.Factory) (*Router, error) {
+	logger := rootLogger.WithFields(logrus.Fields{"prefix": "router"})
+
+	r := &Router{
+		Config:           cfg,
+		BridgeMap:        bridgeMap,
+		Message:          make(chan config.Message),
+		MattermostPlugin: make(chan config.Message),
+		Gateways:         make(map[string]*Gateway),
+		logger:           logger,
+	}
+	sgw := samechannel.New(cfg)
+	gwconfigs := append(sgw.GetConfig(), cfg.BridgeValues().Gateway...)
+
+	for idx := range gwconfigs {
+		entry := &gwconfigs[idx]
+		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(rootLogger, entry, r)
+	}
+	return r, nil
+}
+
+// Start will connect all gateways belonging to this router and subsequently route messages
+// between them.
+func (r *Router) Start() error {
+	m := make(map[string]*bridge.Bridge)
+	if len(r.Gateways) == 0 {
+		return fmt.Errorf("no [[gateway]] configured. See https://github.com/42wim/matterbridge/wiki/How-to-create-your-config for more info")
+	}
+	for _, gw := range r.Gateways {
+		r.logger.Infof("Parsing gateway %s", gw.Name)
+		if len(gw.Bridges) == 0 {
+			return fmt.Errorf("no bridges configured for gateway %s. See https://github.com/42wim/matterbridge/wiki/How-to-create-your-config for more info", gw.Name)
+		}
+		for _, br := range gw.Bridges {
+			m[br.Account] = br
+		}
+	}
+	for _, br := range m {
+		r.logger.Infof("Starting bridge: %s ", br.Account)
+		err := br.Connect()
+		if err != nil {
+			e := fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
+			if r.disableBridge(br, e) {
+				continue
+			}
+			return e
+		}
+		err = br.JoinChannels()
+		if err != nil {
+			e := fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
+			if r.disableBridge(br, e) {
+				continue
+			}
+			return e
+		}
+	}
+	// remove unused bridges
+	for _, gw := range r.Gateways {
+		for i, br := range gw.Bridges {
+			if br.Bridger == nil {
+				r.logger.Errorf("removing failed bridge %s", i)
+				delete(gw.Bridges, i)
+			}
+		}
+	}
+	go r.handleReceive()
+	//go r.updateChannelMembers()
+	return nil
+}
+
+// disableBridge returns true and empties a bridge if we have IgnoreFailureOnStart configured
+// otherwise returns false
+func (r *Router) disableBridge(br *bridge.Bridge, err error) bool {
+	if r.BridgeValues().General.IgnoreFailureOnStart {
+		r.logger.Error(err)
+		// setting this bridge empty
+		*br = bridge.Bridge{}
+		return true
+	}
+	return false
+}
+
+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
+		r.handleEventGetChannelMembers(&msg)
+		r.handleEventFailure(&msg)
+		r.handleEventRejoinChannels(&msg)
+
+		// Set message protocol based on the account it came from
+		msg.Protocol = r.getBridge(msg.Account).Protocol
+
+		filesHandled := false
+		for _, gw := range r.Gateways {
+			// record all the message ID's of the different bridges
+			var msgIDs []*BrMsgID
+			if gw.ignoreMessage(&msg) {
+				continue
+			}
+			msg.Timestamp = time.Now()
+			gw.modifyMessage(&msg)
+			if !filesHandled {
+				gw.handleFiles(&msg)
+				filesHandled = true
+			}
+			for _, br := range gw.Bridges {
+				msgIDs = append(msgIDs, gw.handleMessage(&msg, br)...)
+			}
+
+			if msg.ID != "" {
+				_, exists := gw.Messages.Get(msg.Protocol + " " + msg.ID)
+
+				// Only add the message ID if it doesn't already exist
+				//
+				// For some bridges we always add/update the message ID.
+				// This is necessary as msgIDs will change if a bridge returns
+				// a different ID in response to edits.
+				if !exists || msg.Protocol == "discord" {
+					gw.Messages.Add(msg.Protocol+" "+msg.ID, msgIDs)
+				}
+			}
+		}
+	}
+}
+
+// updateChannelMembers sends every minute an GetChannelMembers event to all bridges.
+func (r *Router) updateChannelMembers() {
+	// TODO sleep a minute because slack can take a while
+	// fix this by having actually connectionDone events send to the router
+	time.Sleep(time.Minute)
+	for {
+		for _, gw := range r.Gateways {
+			for _, br := range gw.Bridges {
+				// only for slack now
+				if br.Protocol != "slack" {
+					continue
+				}
+				r.logger.Debugf("sending %s to %s", config.EventGetChannelMembers, br.Account)
+				if _, err := br.Send(config.Message{Event: config.EventGetChannelMembers}); err != nil {
+					r.logger.Errorf("updateChannelMembers: %s", err)
+				}
+			}
+		}
+		time.Sleep(time.Minute)
+	}
+}

gateway/samechannel/samechannel.go

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

gateway/samechannel/samechannel_test.go

@@ -0,0 +1,77 @@
+package samechannel
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+)
+
+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) {
+	logger := logrus.New()
+	logger.SetOutput(ioutil.Discard)
+	cfg := config.NewConfigFromString(logger, []byte(testConfig))
+	sgw := New(cfg)
+	configs := sgw.GetConfig()
+	assert.Equal(t, []config.Gateway{expectedConfig}, configs)
+}

go.mod

@@ -0,0 +1,55 @@
+module github.com/42wim/matterbridge
+
+require (
+	github.com/42wim/go-gitter v0.0.0-20170828205020-017310c2d557
+	github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f
+	github.com/Jeffail/gabs v1.1.1 // indirect
+	github.com/Philipp15b/go-steam v1.0.1-0.20190816133340-b04c5a83c1c0
+	github.com/Rhymen/go-whatsapp v0.1.1-0.20200421062035-31e8111ac334
+	github.com/d5/tengo/v2 v2.6.0
+	github.com/davecgh/go-spew v1.1.1
+	github.com/fsnotify/fsnotify v1.4.9
+	github.com/go-telegram-bot-api/telegram-bot-api v1.0.1-0.20200524105306-7434b0456e81
+	github.com/gomarkdown/markdown v0.0.0-20200609195525-3f9352745725
+	github.com/google/gops v0.3.10
+	github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4 // indirect
+	github.com/gorilla/schema v1.1.0
+	github.com/gorilla/websocket v1.4.2
+	github.com/hashicorp/golang-lru v0.5.4
+	github.com/jpillora/backoff v1.0.0
+	github.com/keybase/go-keybase-chat-bot v0.0.0-20200505163032-5cacf52379da
+	github.com/labstack/echo/v4 v4.1.16
+	github.com/lrstanley/girc v0.0.0-20190801035559-4fc93959e1a7
+	github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20200411204219-d5c18ce75048
+	github.com/matterbridge/discordgo v0.21.2-0.20200718144317-01fe5db6c78d
+	github.com/matterbridge/emoji v2.1.1-0.20191117213217-af507f6b02db+incompatible
+	github.com/matterbridge/go-xmpp v0.0.0-20200418225040-c8a3a57b4050
+	github.com/matterbridge/gomatrix v0.0.0-20200209224845-c2104d7936a6
+	github.com/matterbridge/gozulipbot v0.0.0-20200820220548-be5824faa913
+	github.com/matterbridge/logrus-prefixed-formatter v0.5.3-0.20200523233437-d971309a77ba
+	github.com/mattermost/mattermost-server/v5 v5.25.2
+	github.com/mattn/godown v0.0.0-20200217152941-afc959f6a561
+	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/missdeer/golib v1.0.3
+	github.com/mreiferson/go-httpclient v0.0.0-20160630210159-31f0106b4474 // indirect
+	github.com/mrexodia/wray v0.0.0-20160318003008-78a2c1f284ff // indirect
+	github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9
+	github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c
+	github.com/rs/xid v1.2.1
+	github.com/russross/blackfriday v1.5.2
+	github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca
+	github.com/shazow/ssh-chat v1.8.3-0.20200308224626-80ddf1f43a98
+	github.com/sirupsen/logrus v1.6.0
+	github.com/slack-go/slack v0.6.5
+	github.com/spf13/viper v1.7.0
+	github.com/stretchr/testify v1.5.1
+	github.com/writeas/go-strip-markdown v2.0.1+incompatible
+	github.com/x-cray/logrus-prefixed-formatter v0.5.2 // indirect
+	github.com/yaegashi/msgraph.go v0.1.3
+	github.com/zfjagann/golang-ring v0.0.0-20190304061218-d34796e0a6c2
+	golang.org/x/image v0.0.0-20200618115811-c13761719519
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
+	gomod.garykim.dev/nc-talk v0.0.2
+)
+
+go 1.13

go.sum

@@ -0,0 +1,957 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.37.0/go.mod h1:TS1dMSSfndXH133OKGwekG838Om/cQT0BUHV3HcBgoo=
+cloud.google.com/go v0.37.1/go.mod h1:SAbnLi6YTSPKSI0dTUEOVLCkyPfKXK8n4ibqiMoj4ok=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+contrib.go.opencensus.io/exporter/ocagent v0.4.9/go.mod h1:ueLzZcP7LPhPulEBukGn4aLh7Mx9YJwpVJ9nL2FYltw=
+dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU=
+dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4=
+dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU=
+git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
+git.apache.org/thrift.git v0.12.0/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
+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/Azure/azure-sdk-for-go v26.5.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
+github.com/Azure/go-autorest v11.5.2+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
+github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f h1:2dk3eOnYllh+wUOuDhOoC2vUVoJF/5z478ryJ+wzEII=
+github.com/Baozisoftware/qrcode-terminal-go v0.0.0-20170407111555-c0650d8dff0f/go.mod h1:4a58ifQTEe2uwwsaqbh3i2un5/CBPg+At/qHpt18Tmk=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/Jeffail/gabs v1.1.1 h1:V0uzR08Hj22EX8+8QMhyI9sX2hwRu+/RJhJUmnwda/E=
+github.com/Jeffail/gabs v1.1.1/go.mod h1:6xMvQMK4k33lb7GUUpaAPh6nKMmemQeg5d4gn7/bOXc=
+github.com/Masterminds/glide v0.13.2/go.mod h1:STyF5vcenH/rUqTEv+/hBXlSTo7KYwg2oc2f4tzPWic=
+github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
+github.com/Masterminds/squirrel v1.2.0/go.mod h1:yaPeOnPG5ZRwL9oKdTsO/prlkPbXWZlRVMQ/gGlzIuA=
+github.com/Masterminds/vcs v1.13.0/go.mod h1:N09YCmOQr6RLxC6UNHzuVwAdodYbbnycGHSmwVJjcKA=
+github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/PaulARoy/azurestoragecache v0.0.0-20170906084534-3c249a3ba788/go.mod h1:lY1dZd8HBzJ10eqKERHn3CU59tfhzcAVb2c0ZhIWSOk=
+github.com/Philipp15b/go-steam v1.0.1-0.20190816133340-b04c5a83c1c0 h1:TO7d4rocnNFng6ZQrPe7U6WqHtK5eHEMrgrnnM/72IQ=
+github.com/Philipp15b/go-steam v1.0.1-0.20190816133340-b04c5a83c1c0/go.mod h1:HuVM+sZFzumUdKPWiz+IlCMb4RdsKdT3T+nQBKL+sYg=
+github.com/Rhymen/go-whatsapp v0.0.0/go.mod h1:rdQr95g2C1xcOfM7QGOhza58HeI3I+tZ/bbluv7VazA=
+github.com/Rhymen/go-whatsapp v0.1.1-0.20200421062035-31e8111ac334 h1:kb1zvD+xd+XbPUdQ0lMxnRaQ76N5C9vMAClLi8Dyw1Y=
+github.com/Rhymen/go-whatsapp v0.1.1-0.20200421062035-31e8111ac334/go.mod h1:o7jjkvKnigfu432dMbQ/w4PH0Yp5u4Y6ysCNjUlcYCk=
+github.com/Rhymen/go-whatsapp/examples/echo v0.0.0-20190325075644-cc2581bbf24d/go.mod h1:zgCiQtBtZ4P4gFWvwl9aashsdwOcbb/EHOGRmSzM8ME=
+github.com/Rhymen/go-whatsapp/examples/restoreSession v0.0.0-20190325075644-cc2581bbf24d/go.mod h1:5sCUSpG616ZoSJhlt9iBNI/KXBqrVLcNUJqg7J9+8pU=
+github.com/Rhymen/go-whatsapp/examples/sendImage v0.0.0-20190325075644-cc2581bbf24d/go.mod h1:RdiyhanVEGXTam+mZ3k6Y3VDCCvXYCwReOoxGozqhHw=
+github.com/Rhymen/go-whatsapp/examples/sendTextMessages v0.0.0-20190325075644-cc2581bbf24d/go.mod h1:suwzklatySS3Q0+NCxCDh5hYfgXdQUWU1DNcxwAxStM=
+github.com/RoaringBitmap/roaring v0.4.21/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo=
+github.com/RoaringBitmap/roaring v0.4.23/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo=
+github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
+github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
+github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alexcesaro/log v0.0.0-20150915221235-61e686294e58/go.mod h1:YNfsMyWSs+h+PaYkxGeMVmVCX75Zj/pqdjbu12ciCYE=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
+github.com/armon/go-metrics v0.3.0/go.mod h1:zXjbSimjXTd7vOpY8B0/2LpvNvDoXBuplAD+gJD3GYs=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/avct/uasurfer v0.0.0-20191028135549-26b5daa857f1/go.mod h1:noBAuukeYOXa0aXGqxr24tADqkwDO2KRD15FsuaZ5a8=
+github.com/aws/aws-sdk-go v1.19.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/beevik/etree v1.1.0/go.mod h1:r8Aw8JqVegEf0w2fDnATrX9VpkMcyFeM0FhwO62wh+A=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
+github.com/blevesearch/bleve v1.0.7/go.mod h1:3xvmBtaw12Y4C9iA1RTzwWCof5j5HjydjCTiDE2TeE0=
+github.com/blevesearch/blevex v0.0.0-20190916190636-152f0fe5c040/go.mod h1:WH+MU2F4T0VmSdaPX+Wu5GYoZBrYWdOZWSjzvYcDmqQ=
+github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M=
+github.com/blevesearch/mmap-go v1.0.2/go.mod h1:ol2qBqYaOUsGdm7aRMRrYGgPvnwLe6Y+7LMvAB5IbSA=
+github.com/blevesearch/segment v0.9.0/go.mod h1:9PfHYUdQCgHktBgvtUOF4x+pc4/l8rdH0u5spnW85UQ=
+github.com/blevesearch/snowballstem v0.9.0/go.mod h1:PivSj3JMc8WuaFkTSRDW2SlrulNWPl4ABg1tC/hlgLs=
+github.com/blevesearch/zap/v11 v11.0.7/go.mod h1:bJoY56fdU2m/IP4LLz/1h4jY2thBoREvoqbuJ8zhm9k=
+github.com/blevesearch/zap/v12 v12.0.7/go.mod h1:70DNK4ZN4tb42LubeDbfpp6xnm8g3ROYVvvZ6pEoXD8=
+github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
+github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
+github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
+github.com/census-instrumentation/opencensus-proto v0.2.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
+github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
+github.com/codegangsta/cli v1.20.0/go.mod h1:/qJNoX69yVSKu5o4jLyXAENLRyk1uhi7zkbQ3slBdOA=
+github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/corpix/uarand v0.1.1/go.mod h1:SFKZvkcRoLqVRFZ4u25xPmp6m9ktANfbpXZ7SJ0/FNU=
+github.com/couchbase/ghistogram v0.1.0/go.mod h1:s1Jhy76zqfEecpNWJfWUiKZookAFaiGOEoyzgHt9i7k=
+github.com/couchbase/moss v0.1.0/go.mod h1:9MaHIaRuy9pvLPUJxB8sh8OrLfyDczECVL37grCIubs=
+github.com/couchbase/vellum v1.0.1/go.mod h1:FcwrEivFpNi24R3jLOs3n+fs5RnuQnQqCLBJ1uAg1W4=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cznic/b v0.0.0-20181122101859-a26611c4d92d/go.mod h1:URriBxXwVq5ijiJ12C7iIZqlA69nTlI+LgI6/pwftG8=
+github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM=
+github.com/cznic/strutil v0.0.0-20181122101858-275e90344537/go.mod h1:AHHPPPXTw0h6pVabbcbyGRK1DckRn7r/STdZEeIDzZc=
+github.com/d5/tengo/v2 v2.6.0 h1:D0cJtpiBzaLJ/Smv6nnUc/LIfO46oKwDx85NZtIRNRI=
+github.com/d5/tengo/v2 v2.6.0/go.mod h1:XRGjEs5I9jYIKTxly6HCF8oiiilk5E/RYXOZ5b0DZC8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/dgoogauth v0.0.0-20190221195224-5a805980a5f3/go.mod h1:hEfFauPHz7+NnjR/yHJGhrKo1Za+zStgwUETx3yzqgY=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/die-net/lrucache v0.0.0-20181227122439-19a39ef22a11/go.mod h1:ew0MSjCVDdtGMjF3kzLK9hwdgF5mOE8SbYVF3Rc7mkU=
+github.com/disintegration/imaging v1.6.0/go.mod h1:xuIt+sRxDFrHS0drzXUlCJthkJ8k7lkkUojDSR247MQ=
+github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
+github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dyatlov/go-opengraph v0.0.0-20180429202543-816b6608b3c8 h1:6muCmMJat6z7qptVrIf/+OWPxsjAfvhw5/6t+FwEkgg=
+github.com/dyatlov/go-opengraph v0.0.0-20180429202543-816b6608b3c8/go.mod h1:nYia/MIs9OyvXXYboPmNOj0gVWo97Wx0sde+ZuKkoM4=
+github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
+github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64=
+github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg=
+github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/francoispqt/gojay v1.2.13 h1:d2m3sFjloqoIUQU3TsHBgj6qg/BVGlTBeHDUmyJnXKk=
+github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/garyburd/redigo v1.6.0/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
+github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/go-asn1-ber/asn1-ber v1.3.2-0.20191121212151-29be175fc3a3/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
+github.com/go-asn1-ber/asn1-ber v1.4.1 h1:qP/QDxOtmMoJVgXHCXNzDpA0+wkgYB2x5QoLMVOciyw=
+github.com/go-asn1-ber/asn1-ber v1.4.1/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gorp/gorp v2.0.0+incompatible/go.mod h1:7IfkAQnO7jfT/9IQ3R9wL1dFhukN6aQxzKTHnkxzA/E=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-telegram-bot-api/telegram-bot-api v1.0.1-0.20200524105306-7434b0456e81 h1:FdZThbRF0R+2qgyBl3KCVNWWBmKm68E+stT3rnQ02Ww=
+github.com/go-telegram-bot-api/telegram-bot-api v1.0.1-0.20200524105306-7434b0456e81/go.mod h1:lDm2E64X4OjFdBUA4hlN4mEvbSitvhJdKw7rsA8KHgI=
+github.com/go-test/deep v1.0.4 h1:u2CU3YKy9I2pmu9pX0eq50wCgjfGIt539SqR7FbHiho=
+github.com/go-test/deep v1.0.4/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/gomarkdown/markdown v0.0.0-20200609195525-3f9352745725 h1:X6sZdr+t2E2jwajTy/FfXbmAKPFTYxEq9hiFgzMiuPQ=
+github.com/gomarkdown/markdown v0.0.0-20200609195525-3f9352745725/go.mod h1:aii0r/K0ZnHv7G0KF7xy1v0A7s2Ljrb5byB7MO5p6TU=
+github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gops v0.3.10 h1:M2XZYgfUW+P7AOCLiu4CRb0rQfwnslLyB4B9Mp0vXmE=
+github.com/google/gops v0.3.10/go.mod h1:38bMPVKFh+1X106CPpbLAWtZIR1+xwgzT9gew0kn6w4=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
+github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4 h1:4EZlYQIiyecYJlUbVkFXCXHz1QPhVXcHnQKAzBTPfQo=
+github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4/go.mod h1:lEO7XoHJ/xNRBCxrn4h/CEB67h0kW1B0t4ooP2yrjUA=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99 h1:twflg0XRTjwKpxb/jFExr4HGq6on2dEOmnL6FV+fgPw=
+github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/handlers v1.4.2/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/OAirnOIQ=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.4/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/schema v1.1.0 h1:CamqUDOFUBqzrvxuz2vEwo8+SUdwsluFh7IlzJh30LY=
+github.com/gorilla/schema v1.1.0/go.mod h1:kgLaKoK1FELgZqMAVxx/5cbj0kT+57qxUrAlIO2eleU=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/gregjones/httpcache v0.0.0-20190212212710-3befbb6ad0cc/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
+github.com/grpc-ecosystem/grpc-gateway v1.6.2/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
+github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/h2non/go-is-svg v0.0.0-20160927212452-35e8c4b0612c/go.mod h1:ObS/W+h8RYb1Y7fYivughjxojTmIu5iAIjSrSLCLeqE=
+github.com/hako/durafmt v0.0.0-20191009132224-3f39dc1ed9f4/go.mod h1:5Scbynm8dF1XAPwIwkGPqzkM/shndPm79Jd1003hTjE=
+github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
+github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI=
+github.com/hashicorp/go-hclog v0.12.2/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-immutable-radix v1.2.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-msgpack v1.1.5/go.mod h1:gWVc3sv/wbDmR3rQsj1CAktEZzoz1YNK9NfGLXJ69/4=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
+github.com/hashicorp/go-plugin v1.2.2/go.mod h1:F9eH4LrE/ZsRdbwhfjs9k9HoDUwAHnYtXdgmf1AVNs0=
+github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
+github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
+github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A=
+github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
+github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
+github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
+github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
+github.com/hashicorp/yamux v0.0.0-20190923154419-df201c70410d/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
+github.com/howeyc/gopass v0.0.0-20170109162249-bf9dde6d0d2c/go.mod h1:lADxMC39cJJqL93Duh1xhAs4I2Zs8mKS89XWXFGp9cs=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/icrowley/fake v0.0.0-20180203215853-4178557ae428/go.mod h1:uhpZMVGznybq1itEKXj6RYw9I71qK4kH+OGMjRC4KEo=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jamiealquiza/envy v1.1.0/go.mod h1:MP36BriGCLwEHhi1OU8E9569JNZrjWfCvzG7RsPnHus=
+github.com/jaytaylor/html2text v0.0.0-20200412013138-3577fbdbcff7/go.mod h1:CVKlgaMiht+LXvHG173ujK6JUhZXKb2u/BQtjPDIvyk=
+github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jhump/protoreflect v1.6.0/go.mod h1:eaTn3RZAmMBcV0fifFvlm6VHNz3wSkYyXYWUh7ymB74=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/keybase/go-keybase-chat-bot v0.0.0-20200505163032-5cacf52379da h1:LK+8uBG3kNikj664cjFt88RBmuGmonxkXv2rUVfbqz4=
+github.com/keybase/go-keybase-chat-bot v0.0.0-20200505163032-5cacf52379da/go.mod h1:xJA+X9ZVyT/irGldcb7q1XnJBq5F9s5H9h2L44Y+poY=
+github.com/keybase/go-ps v0.0.0-20190827175125-91aafc93ba19/go.mod h1:hY+WOq6m2FpbvyrI93sMaypsttvaIL5nhVR92dTMUcQ=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kljensen/snowball v0.6.0/go.mod h1:27N7E8fVU5H68RlUmnWwZCfxgt4POBJfENGMvNRhldw=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+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/pty v1.1.3/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/v4 v4.1.16 h1:8swiwjE5Jkai3RPfZoahp8kjVCRNq+y7Q0hPji2Kz0o=
+github.com/labstack/echo/v4 v4.1.16/go.mod h1:awO+5TzAjvL8XpibdsfXxPgHr+orhtXZJZIQCVjogKI=
+github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o=
+github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.4.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lrstanley/girc v0.0.0-20190801035559-4fc93959e1a7 h1:BS9tqL0OCiOGuy/CYYk2gc33fxqaqh5/rhqMKu4tcYA=
+github.com/lrstanley/girc v0.0.0-20190801035559-4fc93959e1a7/go.mod h1:liX5MxHPrwgHaKowoLkYGwbXfYABh1jbZ6FpElbGF1I=
+github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
+github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
+github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho=
+github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20200411204219-d5c18ce75048 h1:B9HaistmV+MD8/33BXmZe1zPIn+RImAFVXNNSOrwU2E=
+github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20200411204219-d5c18ce75048/go.mod h1:c6MxwqHD+0HvtAJjsHMIdPCiAwGiQwPRPTp69ACMg8A=
+github.com/matterbridge/discordgo v0.21.2-0.20200718144317-01fe5db6c78d h1:NBckP4nw7qVspbt7cOZYsrOrEbq7tATdMjSjc1hW63A=
+github.com/matterbridge/discordgo v0.21.2-0.20200718144317-01fe5db6c78d/go.mod h1:411nZYv0UMMrtppR5glXop1foboJiFAowy+42U+Ahvw=
+github.com/matterbridge/emoji v2.1.1-0.20191117213217-af507f6b02db+incompatible h1:oaOqwbg5HxHRxvAbd84ks0Okwoc1ISyUZ87EiVJFhGI=
+github.com/matterbridge/emoji v2.1.1-0.20191117213217-af507f6b02db+incompatible/go.mod h1:igE6rUAn3jai2wCdsjFHfhUoekjrFthoEjFObKKwSb4=
+github.com/matterbridge/go-xmpp v0.0.0-20200418225040-c8a3a57b4050 h1:kWkP1lXpkvtoNL08jkP3XQH/zvDOEXJpdCJd/DlIvMw=
+github.com/matterbridge/go-xmpp v0.0.0-20200418225040-c8a3a57b4050/go.mod h1:ECDRehsR9TYTKCAsRS8/wLeOk6UUqDydw47ln7wG41Q=
+github.com/matterbridge/gomatrix v0.0.0-20200209224845-c2104d7936a6 h1:Kl65VJv38HjYFnnwH+MP6Z8hcJT5UHuSpHVU5vW1HH0=
+github.com/matterbridge/gomatrix v0.0.0-20200209224845-c2104d7936a6/go.mod h1:+jWeaaUtXQbBRdKYWfjW6JDDYiI2XXE+3NnTjW5kg8g=
+github.com/matterbridge/gozulipbot v0.0.0-20200820220548-be5824faa913 h1:5UGr9fLsvAvhjP6i5XJmd0ZIwYVR2gZCzU1lJZ7wfLY=
+github.com/matterbridge/gozulipbot v0.0.0-20200820220548-be5824faa913/go.mod h1:yAjnZ34DuDyPHMPHHjOsTk/FefW4JJjoMMCGt/8uuQA=
+github.com/matterbridge/logrus-prefixed-formatter v0.5.3-0.20200523233437-d971309a77ba h1:XleOY4IjAEIcxAh+IFwT5JT5Ze3RHiYz6m+4ZfZ0rc0=
+github.com/matterbridge/logrus-prefixed-formatter v0.5.3-0.20200523233437-d971309a77ba/go.mod h1:iXGEotOvwI1R1SjLxRc+BF5rUORTMtE0iMZBT2lxqAU=
+github.com/mattermost/go-i18n v1.11.0 h1:1hLKqn/ZvhZ80OekjVPGYcCrBfMz+YxNNgqS+beL7zE=
+github.com/mattermost/go-i18n v1.11.0/go.mod h1:RyS7FDNQlzF1PsjbJWHRI35exqaKGSO9qD4iv8QjE34=
+github.com/mattermost/gorp v2.0.1-0.20190301154413-3b31e9a39d05+incompatible/go.mod h1:0kX1qa3DOpaPJyOdMLeo7TcBN0QmUszj9a/VygOhDe0=
+github.com/mattermost/gosaml2 v0.3.2/go.mod h1:Z429EIOiEi9kbq6yHoApfzlcXpa6dzRDc6pO+Vy2Ksk=
+github.com/mattermost/ldap v0.0.0-20191128190019-9f62ba4b8d4d h1:2DV7VIlEv6J5R5o6tUcb3ZMKJYeeZuWZL7Rv1m23TgQ=
+github.com/mattermost/ldap v0.0.0-20191128190019-9f62ba4b8d4d/go.mod h1:HLbgMEI5K131jpxGazJ97AxfPDt31osq36YS1oxFQPQ=
+github.com/mattermost/mattermost-server/v5 v5.25.2 h1:A1nyhIbRgY6NoSqg5zQP47F3zt2KEDEBcQs0sy5fAmw=
+github.com/mattermost/mattermost-server/v5 v5.25.2/go.mod h1:TVkOfVyk4wGw8j5J2IX3PDCP5R7j20IEP4FAezDK8Wk=
+github.com/mattermost/rsc v0.0.0-20160330161541-bbaefb05eaa0/go.mod h1:nV5bfVpT//+B1RPD2JvRnxbkLmJEYXmRaaVl15fsXjs=
+github.com/mattermost/viper v1.0.4/go.mod h1:uc5hKG9lv4/KRwPOt2c1omOyirS/UnuA2TytiZQSFHM=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
+github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mattn/godown v0.0.0-20200217152941-afc959f6a561 h1:0YGo77enc6tJpXQxUeQWs9bPIQPTH1lbOmc5tgRuq4o=
+github.com/mattn/godown v0.0.0-20200217152941-afc959f6a561/go.mod h1:/ivCKurgV/bx6yqtP/Jtc2Xmrv3beCYBvlfAUl4X5g4=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+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/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
+github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
+github.com/miekg/dns v1.1.29/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/minio/minio-go/v6 v6.0.55/go.mod h1:KQMM+/44DSlSGSQWSfRrAZ12FVMmpWNuX37i2AX0jfI=
+github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
+github.com/missdeer/golib v1.0.3 h1:+kz/tn1lXlPS8i+gjHHVAZC8YcgrmfiMTqELyvOwI4g=
+github.com/missdeer/golib v1.0.3/go.mod h1:Cys1ITPPZxIk2eTcQcKT3jDsBdhICAfrrw+ki/eRXxA=
+github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8=
+github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
+github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
+github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
+github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.2.3 h1:f/MjBEBDLttYCGfRaKBbKSRVF5aV2O6fnBpzknuE3jU=
+github.com/mitchellh/mapstructure v1.2.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/monaco-io/request v1.0.3 h1:FsiIwXCCbHEyWx9A7lgg6JBTMHhHlEEsADsgAOvZ9HA=
+github.com/monaco-io/request v1.0.3/go.mod h1:EmggwHktBsbJmCgwZXqy7o0H1NNsAstQBWZrFVd3xtQ=
+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/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg=
+github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw=
+github.com/muesli/smartcrop v0.2.1-0.20181030220600-548bbf0c0965/go.mod h1:i2fCI/UorTfgEpPPLWiFBv4pye+YAG78RwcQLUkocpI=
+github.com/muesli/smartcrop v0.3.0/go.mod h1:i2fCI/UorTfgEpPPLWiFBv4pye+YAG78RwcQLUkocpI=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
+github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
+github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9 h1:mp6tU1r0xLostUGLkTspf/9/AiHuVD7ptyXhySkDEsE=
+github.com/nelsonken/gomf v0.0.0-20180504123937-a9dd2f9deae9/go.mod h1:A5SRAcpTemjGgIuBq6Kic2yHcoeUFWUinOAlMP/i9xo=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/ngdinhtoan/glide-cleanup v0.2.0/go.mod h1:UQzsmiDOb8YV3nOsCxK/c9zPpCZVNoHScRE3EO9pVMM=
+github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
+github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
+github.com/olivere/elastic v6.2.30+incompatible/go.mod h1:J+q1zQJTgAz9woqsbVRqGeB5G1iqDKVBWLNSYW8yfJ8=
+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/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
+github.com/openzipkin/zipkin-go v0.1.3/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
+github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
+github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c h1:P6XGcuPTigoHf4TSu+3D/7QOQ1MbL6alNwrGhcW7sKw=
+github.com/paulrosania/go-charset v0.0.0-20190326053356-55c9d7a5834c/go.mod h1:YnNlZP7l4MhyGQ4CBRwv6ohZTPrUJJZtEv4ZgADkbs4=
+github.com/pborman/uuid v1.2.0 h1:J7Q5mO4ysT1dv8hyrUGHb9+ooztCXu1D8MY8DZYsu3g=
+github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pelletier/go-toml v1.7.0 h1:7utD74fnzVc/cpcyy8sjrlFr5vYpypUixARcHIMIGuI=
+github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
+github.com/peterbourgon/diskv v0.0.0-20171120014656-2973218375c3/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
+github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/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/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
+github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.4.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/remyoudompheng/bigfft v0.0.0-20190728182440-6a916e37a237/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rickb777/date v1.12.4 h1:+6IzcCCS/1t17DrmnEvrznyq7nM8vPwir6/UhlyohKw=
+github.com/rickb777/date v1.12.4/go.mod h1:xP0eo/I5qmUt97yRGClHZfyLZ3ikMw6v6SU5MOGZTE0=
+github.com/rickb777/plural v1.2.0 h1:5tvEc7UBCZ7l8h/2UeybSkt/uu1DQsZFOFdNevmUhlE=
+github.com/rickb777/plural v1.2.0/go.mod h1:UdpyWFCGbo3mvK3f/PfZOAOrkjzJlYN/sD46XNWJ+Es=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/rs/xid v1.2.1 h1:mhH9Nq+C1fY2l1XIpgxIiUOfNpRBYH1kKcr+qfKgjRc=
+github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
+github.com/rudderlabs/analytics-go v3.2.1+incompatible/go.mod h1:LF8/ty9kUX4PTY3l5c97K3nZZaX5Hwsvt+NBaRL/f30=
+github.com/russellhaering/goxmldsig v0.0.0-20180430223755-7acd5e4a6ef7/go.mod h1:Oz4y6ImuOQZxynhbSXk7btjEfNBtGlj2dcaOvXl2FSM=
+github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk=
+github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+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/satori/go.uuid v0.0.0-20180103174451-36e9d2ebbde5/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/segmentio/analytics-go v3.1.0+incompatible/go.mod h1:C7CYBtQWk4vRk2RyLu0qOcbHJ18E3F1HV2C/8JvKN48=
+github.com/segmentio/backo-go v0.0.0-20200129164019-23eae7c10bd3/go.mod h1:9/Rh6yILuLysoQnZ2oNooD2g7aBnvM7r/fNVxRNWfBc=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+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 v1.8.3-0.20200308224626-80ddf1f43a98 h1:sN07ff+PSRsUNhpSod4uGKAQ+Nc0FXsBPG9FmYMNg4w=
+github.com/shazow/ssh-chat v1.8.3-0.20200308224626-80ddf1f43a98/go.mod h1:xkTgfD+WP+KR4HuG76oal25BBEeu5kJyi2EOsgiu/4Q=
+github.com/shirou/gopsutil v2.20.4+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY=
+github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM=
+github.com/shurcooL/github_flavored_markdown v0.0.0-20181002035957-2122de532470/go.mod h1:2dOwnU2uBioM+SGy2aZoq1f/Sd1l9OkAeAUvjSyvgU0=
+github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
+github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
+github.com/shurcooL/gofontwoff v0.0.0-20180329035133-29b52fc0a18d/go.mod h1:05UtEgK5zq39gLST6uB0cf3NEHjETfB4Fgr3Gx5R9Vw=
+github.com/shurcooL/gopherjslib v0.0.0-20160914041154-feb6d3990c2c/go.mod h1:8d3azKNyqcHP1GaQE/c6dDgjkgSx2BZ4IoEi4F1reUI=
+github.com/shurcooL/highlight_diff v0.0.0-20170515013008-09bb4053de1b/go.mod h1:ZpfEhSmds4ytuByIcDnOLkTHGUI6KNqRNPDLHDk+mUU=
+github.com/shurcooL/highlight_go v0.0.0-20181028180052-98c3abbbae20/go.mod h1:UDKB5a1T23gOMUJrI+uSuH0VRDStOiUVSjBTRDVBVag=
+github.com/shurcooL/home v0.0.0-20181020052607-80b7ffcb30f9/go.mod h1:+rgNQw2P9ARFAs37qieuu7ohDNQ3gds9msbT2yn85sg=
+github.com/shurcooL/htmlg v0.0.0-20170918183704-d01228ac9e50/go.mod h1:zPn1wHpTIePGnXSHpsVPWEktKXHr6+SS6x/IKRb7cpw=
+github.com/shurcooL/httperror v0.0.0-20170206035902-86b7830d14cc/go.mod h1:aYMfkZ6DWSJPJ6c4Wwz3QtW22G7mf/PEgaB9k/ik5+Y=
+github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg=
+github.com/shurcooL/httpgzip v0.0.0-20180522190206-b1c53ac65af9/go.mod h1:919LwcH0M7/W4fcZ0/jy0qGght1GIhqyS/EgWGH2j5Q=
+github.com/shurcooL/issues v0.0.0-20181008053335-6292fdc1e191/go.mod h1:e2qWDig5bLteJ4fwvDAc2NHzqFEthkqn7aOZAOpj+PQ=
+github.com/shurcooL/issuesapp v0.0.0-20180602232740-048589ce2241/go.mod h1:NPpHK2TI7iSaM0buivtFUc9offApnI0Alt/K8hcHy0I=
+github.com/shurcooL/notifications v0.0.0-20181007000457-627ab5aea122/go.mod h1:b5uSkrEVM1jQUspwbixRBhaIjIzL2xazXp6kntxYle0=
+github.com/shurcooL/octicon v0.0.0-20181028054416-fa4f57f9efb2/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ=
+github.com/shurcooL/reactions v0.0.0-20181006231557-f2e0b4ca5b82/go.mod h1:TCR1lToEk4d2s07G3XGfz2QrgHXg4RJBvjrOozvoWfk=
+github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4=
+github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/skip2/go-qrcode v0.0.0-20190110000554-dc11ecdae0a9 h1:lpEzuenPuO1XNTeikEmvqYFcU37GVLl8SRNblzyvGBE=
+github.com/skip2/go-qrcode v0.0.0-20190110000554-dc11ecdae0a9/go.mod h1:PLPIyL7ikehBD1OAjmKKiOEhbvWyHGaNDjquXMcYABo=
+github.com/slack-go/slack v0.6.5 h1:IkDKtJ2IROJNoe3d6mW870/NRKvq2fhLB/Q5XmzWk00=
+github.com/slack-go/slack v0.6.5/go.mod h1:FGqNzJBmxIsZURAxh2a8D21AnOVvvXZvGligs4npPUM=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v1.0.0 h1:UVQPSSmc3qtTi+zPPkCXvZX9VvW/xT/NsRvKfwY81a8=
+github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
+github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/smartystreets/goconvey v0.0.0-20190710185942-9d28bd7c0945/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
+github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
+github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
+github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
+github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
+github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
+github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
+github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/spf13/viper v1.7.0 h1:xVKxvI7ouOI5I+U9s2eeiUfMaWBVoXA3AWskkrqK0VM=
+github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
+github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf/go.mod h1:RJID2RhlZKId02nZ62WenDCkgHFerpIOmW0iT7GKmXM=
+github.com/steveyen/gtreap v0.1.0/go.mod h1:kl/5J7XbrOmlIbYIXdRHDDE5QxHqpk0cmkT7Z4dM9/Y=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
+github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
+github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
+github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8=
+github.com/technoweenie/multipartstreamer v1.0.1 h1:XRztA5MXiR1TIRHxH2uNxXxaIkKQDeX7m2XsSOlQEnM=
+github.com/technoweenie/multipartstreamer v1.0.1/go.mod h1:jNVxdtShOxzAsukZwTSw6MDx5eUJoiEBsSvzDU9uzog=
+github.com/throttled/throttled v2.2.4+incompatible/go.mod h1:0BjlrEGQmvxps+HuXLsyRdqpSRvJpq0PNIsOtqP9Nos=
+github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+github.com/tinylib/msgp v1.1.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
+github.com/tylerb/graceful v1.2.15/go.mod h1:LPYTbOYmUTdabwRt0TGhLllQ0MUNbs0Y5q1WXJOI9II=
+github.com/uber/jaeger-client-go v2.23.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
+github.com/uber/jaeger-lib v2.2.0+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/valyala/fasttemplate v1.1.0 h1:RZqt0yGBsps8NGvLSGW804QQqCUYYLsaOjTVHy1Ocw4=
+github.com/valyala/fasttemplate v1.1.0/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
+github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
+github.com/wiggin77/cfg v1.0.2/go.mod h1:b3gotba2e5bXTqTW48DwIFoLc+4lWKP7WPi/CdvZ4aE=
+github.com/wiggin77/logr v1.0.4/go.mod h1:h98FF6GPfThhDrHCg063hZA1sIyOEzQ/P85wgqI0IqE=
+github.com/wiggin77/merror v1.0.2/go.mod h1:uQTcIU0Z6jRK4OwqganPYerzQxSFJ4GSHM3aurxxQpg=
+github.com/wiggin77/srslog v1.0.1/go.mod h1:fehkyYDq1QfuYn60TDPu9YdY2bB85VUW2mvN1WynEls=
+github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
+github.com/writeas/go-strip-markdown v2.0.1+incompatible h1:IIqxTM5Jr7RzhigcL6FkrCNfXkvbR+Nbu1ls48pXYcw=
+github.com/writeas/go-strip-markdown v2.0.1+incompatible/go.mod h1:Rsyu10ZhbEK9pXdk8V6MVnZmTzRG0alMNLMwa0J01fE=
+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/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xlab/treeprint v1.0.0/go.mod h1:IoImgRak9i3zJyuxOKUP1v4UZd1tMoKkq/Cimt1uhCg=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/xtgo/uuid v0.0.0-20140804021211-a0b114877d4c/go.mod h1:UrdRz5enIKZ63MEE3IF9l2/ebyx59GyGgPi+tICQdmM=
+github.com/yaegashi/msgraph.go v0.1.3 h1:xeknrGbPGqUVvjjtXGuxvesHLNJ6jEfiOtqJToZe0qw=
+github.com/yaegashi/msgraph.go v0.1.3/go.mod h1:dpty8G9hMEC1xBQeXp6Z2hCXKalqczk2BLvK9me/TUU=
+github.com/yaegashi/wtz.go v0.0.2/go.mod h1:nOLA5QXsmdkRxBkP5tljhua13ADHCKirLBrzPf4PEJc=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/zfjagann/golang-ring v0.0.0-20190304061218-d34796e0a6c2 h1:UQwvu7FjUEdVYofx0U6bsc5odNE7wa5TSA0fl559GcA=
+github.com/zfjagann/golang-ring v0.0.0-20190304061218-d34796e0a6c2/go.mod h1:0MsIttMJIF/8Y7x0XjonJP7K99t3sR6bjj4m5S4JmqU=
+github.com/ziutek/mymysql v1.5.4/go.mod h1:LMSpPZ6DbqWFxNCHW77HeMg9I646SAhApZ/wKdgO/C0=
+go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
+go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
+go.opencensus.io v0.19.1/go.mod h1:gug0GbSHa8Pafr0d2urOSgoXHZ6x/RUlaiT0d9pqb4A=
+go.opencensus.io v0.19.2/go.mod h1:NO/8qkisMZLZ1FCsKNqtJPwc8/TaclWyY0B6wcYNg9M=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk=
+go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A=
+go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM=
+go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
+golang.org/dl v0.0.0-20190829154251-82a15e2f2ead/go.mod h1:IUMfjQLJQd4UTqG1Z90tenwKoCX93Gn3MAQJMOSBsDQ=
+golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
+golang.org/x/build v0.0.0-20190314133821-5284462c4bec/go.mod h1:atTaCNAy0f16Ah5aV1gMSwgiKVHwu/JncqDpuRr7lS4=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190320223903-b7391e95e576/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899 h1:DZhuSZLsGlFL4CmhA8BcRA0mnthyA/nZ00AqCUo7vHg=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190321063152-3fc05d484e9f/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20200618115811-c13761719519 h1:1e2ufUJNM3lCHEY5jIgac/7UTjd6cgJNdatjPdFWf34=
+golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20181217174547-8f45f776aaf1/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180530234432-1e491301e022/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5 h1:WQ8q63x+f/zpC8Ac1s9wLElVoHhm32p6tudrU72n1QA=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190319182350-c85d3e98c914/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181218192612-074acd46bca6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181221143128-b4a75ba826a6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190316082340-a2f829d7f35f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190321052220-f7bb7a8bee54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9 h1:YTzHMGlqJu67/uEo1lBv0n3wBXhXNeUbB1XfN2vmTm0=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181219222714-6e267b5cc78e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190424220101-1e8e1cfdf96b/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200428021058-7ae4988eb4d9/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200529172331-a64b76657301 h1:G6CNEgFU8/XwexSnuFw+Jq/WePjRitgy6ofBcPnAIPo=
+golang.org/x/tools v0.0.0-20200529172331-a64b76657301/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gomod.garykim.dev/nc-talk v0.0.2 h1:QagJzL1Ie/sJDachAC42fEXlIh2mK8IDk1/ue0u8IcI=
+gomod.garykim.dev/nc-talk v0.0.2/go.mod h1:0/Ksg0osAYmnWKs1OcCG+gBQ4HU1xiF1699g9B6jWZw=
+google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.0.0-20181220000619-583d854617af/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y=
+google.golang.org/api v0.2.0/go.mod h1:IfRCZScioGtypHNTlz3gFk67J8uePVW7uDTBzXuIkhU=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1 h1:QzqyMA1tlu6CgqCDUtU9V+ZKhLFT2dkJuANu5QaxI3I=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/genproto v0.0.0-20170818010345-ee236bd376b0/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
+google.golang.org/genproto v0.0.0-20181219182458-5a97ab628bfb/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
+google.golang.org/genproto v0.0.0-20190306203927-b5d61aea6440/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190321212433-e79c0c59cdb5/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200424135956-bca184e23272/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/grpc v1.8.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+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/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/ini.v1 v1.42.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.51.0 h1:AQvPpx3LzTDM0AjnIRlVFwFFGC+npRopjZxLJj6gdno=
+gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.55.0 h1:E8yzL5unfpW3M6fz/eB7Cb5MQAYSZ7GKo4Qth+N2sgQ=
+gopkg.in/ini.v1 v1.55.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/mail.v2 v2.3.1/go.mod h1:htwXN1Qh09vZJ1NVKxQqHPBaCBbzKhp5GzuJEA4VJWw=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/olivere/elastic.v6 v6.2.30/go.mod h1:2cTT8Z+/LcArSWpCgvZqBgt3VOqXiy7v00w12Lz8bd4=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+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-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20180920025451-e3ad64cb4ed3/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3 h1:sXmLre5bzIR6ypkjXCDI3jHPssRhc8KD/Ome589sc3U=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/goversion v1.2.0/go.mod h1:Eih9y/uIBS3ulggl7KNJ09xGSLcuNaLgmvvqa07sgfo=
+sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck=
+sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=
+willnorris.com/go/gifresize v1.0.0/go.mod h1:eBM8gogBGCcaH603vxSpnfjwXIpq6nmnj/jauBDKtAk=
+willnorris.com/go/imageproxy v0.10.0/go.mod h1:2tWdKRneln3E9X/zwH1RINpQAQWPeUiNynZ7UQ9OROk=

hook/rockethook/rockethook.go

@@ -0,0 +1,107 @@
+package rockethook
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+)
+
+// Message for rocketchat outgoing webhook.
+type Message struct {
+	Token       string `json:"token"`
+	ChannelID   string `json:"channel_id"`
+	ChannelName string `json:"channel_name"`
+	Timestamp   string `json:"timestamp"`
+	UserID      string `json:"user_id"`
+	UserName    string `json:"user_name"`
+	Text        string `json:"text"`
+}
+
+// Client for Rocketchat.
+type Client struct {
+	In         chan Message
+	httpclient *http.Client
+	Config
+}
+
+// Config for client.
+type Config struct {
+	BindAddress        string // Address to listen on
+	Token              string // Only allow this token from Rocketchat. (Allow everything when empty)
+	InsecureSkipVerify bool   // disable certificate checking
+}
+
+// New Rocketchat client.
+func New(url string, config Config) *Client {
+	c := &Client{In: make(chan Message), Config: config}
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: config.InsecureSkipVerify}, //nolint:gosec
+	}
+	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
+}