Use tulir/go-whatsapp fork

Enable discordgo debugging with debuglevel=1 under the [discord.xxx] section, for even more debugging fun.

.dockerignore

@@ -0,0 +1,2 @@
+Dockerfile
+tgs.Dockerfile

.fixmie.yml

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

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -1,6 +1,7 @@
 ---
 name: Bug report
 about: Create a report to help us improve. (Check the FAQ on the wiki first)
+labels: bug
 
 ---
 

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -1,6 +1,7 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
+labels: enhancement
 
 ---
 

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+  schedule:
+    - cron: '0 16 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
+        language: ['go']
+        # Learn more...
+        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # If this run was triggered by a pull request event, then checkout
+    # the head of the pull request instead of the merge commit.
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file. 
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.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

@@ -7,7 +7,7 @@ run:
   # concurrency: 4
 
   # timeout for analysis, e.g. 30s, 5m, default is 1m
-  deadline: 1m
+  deadline: 2m
 
   # exit code when at least one issue was found, default is 1
   issues-exit-code: 1
@@ -23,7 +23,7 @@ run:
   # 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:
+  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
@@ -91,7 +91,6 @@ linters-settings:
     # 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
@@ -105,10 +104,6 @@ linters-settings:
     # with golangci-lint call it on a directory with the changed file.
     check-exported: false
   unparam:
-    # call graph construction algorithm (cha, rta). In general, use cha for libraries,
-    # and rta for programs with main packages. Default is cha.
-    algo: rta
-
     # 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
@@ -178,7 +173,15 @@ linters:
     - lll
     - maligned
     - prealloc
-
+    - wsl
+    - gomnd
+    - godox
+    - goerr113
+    - testpackage
+    - godot
+    - interfacer
+    - goheader
+    - noctx
 
 # rules to deal with reported isues
 issues:

.goreleaser.yml

@@ -21,14 +21,18 @@ builds:
   ldflags:
     - -s -w -X main.githash={{.ShortCommit}}
 
-archive:
-  name_template: "{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
-  format: binary
-  files:
-    - none*
-  replacements:
-    386: 32bit
-    amd64: 64bit
+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'

.travis.yml

@@ -1,75 +0,0 @@
-language: go
-go:
-    - 1.11.x
-go_import_path: github.com/42wim/matterbridge
-
-# we have everything vendored
-install: true
-
-git:
-  depth: 200
-
-env:
-  global:
-    - GOOS=linux GOARCH=amd64
-    - GO111MODULE=on
-    - GOLANGCI_VERSION="v1.14.0"
-
-matrix:
-  # It's ok if our code fails on unstable development versions of Go.
-  allow_failures:
-    - go: tip
-  # Don't wait for tip tests to finish. Mark the test run green if the
-  # tests pass on the stable versions of Go.
-  fast_finish: true
-
-notifications:
-      email: false
-
-before_script:
-  # Get version info from tags.
-  - MY_VERSION="$(git describe --tags)"
-  # Retrieve the golangci-lint linter binary.
-  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s -- -b ${GOPATH}/bin ${GOLANGCI_VERSION}
-  # Retrieve and prepare CodeClimate's test coverage reporter.
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  - ./cc-test-reporter before-build
-
-script:
-  # Ensure that the module files are being kept correctly and that vendored dependencies are up-to-date.
-  - go mod tidy
-  - go mod vendor
-  - git diff --exit-code --quiet || (echo "Please run 'go mod tidy' to clean up the 'go.mod' and 'go.sum' files."; false)
-
-  # Run the linter.
-  - golangci-lint run
-
-  # Run all the tests with the race detector and generate coverage.
-  - go test -v -race -coverprofile c.out ./...
-
-  # Run the build script to generate the necessary binaries and images.
-  - /bin/bash ci/bintray.sh
-
-after_script:
-  # Upload test coverage to CodeClimate.
-  - ./cc-test-reporter after-build --exit-code ${TRAVIS_TEST_RESULT}
-
-branches:
-  only:
-    - master
-
-deploy:
-  on:
-     all_branches: true
-  provider: bintray
-  on:
-    all_branches: true
-  edge:
-    branch: v1.8.47
-  file: ci/deploy.json
-  user: 42wim
-  on:
-     all_branches: true
-  key:
-     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="

Dockerfile

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

@@ -3,158 +3,207 @@
 # matterbridge
 
 ![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>
+**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>
 
    <sup>
 
-   [Gitter][mb-gitter] |
-   [IRC][mb-irc] |
-      [Discord][mb-discord] |
-      [Matrix][mb-matrix] |
-      [Slack][mb-slack] |
-      [Mattermost][mb-mattermost] |
-      [Rocket.Chat][mb-rocketchat] |
-      [XMPP][mb-xmpp] |
-      [Twitch][mb-twitch] |
-      [WhatsApp][mb-whatsapp] |
-      [Zulip][mb-zulip] |
-      [Telegram][mb-telegram] |
-      And more...
-   </sup>
+[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>
+
+---
 
-----
 [![Download stable](https://img.shields.io/github/release/42wim/matterbridge.svg?label=download%20stable)](https://github.com/42wim/matterbridge/releases/latest)
-   [![Download dev](https://img.shields.io/bintray/v/42wim/nightly/Matterbridge.svg?label=download%20dev&colorB=007ec6)](https://bintray.com/42wim/nightly/Matterbridge/_latestVersion)
-   [![Maintainability](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/maintainability)](https://codeclimate.com/github/42wim/matterbridge/maintainability)
-   [![Test Coverage](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/test_coverage)](https://codeclimate.com/github/42wim/matterbridge/test_coverage)<br />
+[![Maintainability](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/maintainability)](https://codeclimate.com/github/42wim/matterbridge/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/82dff70ef2ba85a6173a/test_coverage)](https://codeclimate.com/github/42wim/matterbridge/test_coverage)<br />
+
   <hr />
 </div>
 <div align="right"><sup>
 
 **Note:** Matter<em>most</em> isn't required to run matter<em>bridge</em>.</sup></div>
 
-### Table of Contents
- * [Features](https://github.com/42wim/matterbridge/wiki/Features)
-   * [Natively supported](#natively-supported)
-   * [3rd party via matterbridge api](#3rd-party-via-matterbridge-api)
-   * [API](#API)
- * [Chat with us](#chat-with-us)
- * [Screenshots](https://github.com/42wim/matterbridge/wiki/)
- * [Installing](#installing)
-   * [Binaries](#binaries)
-   * [Building](#building)
- * [Configuration](#configuration)
-   * [Howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config)
-   * [Examples](#examples)
- * [Running](#running)
-   * [Docker](#docker)
- * [Changelog](#changelog)
- * [FAQ](#faq)
- * [Related projects](#related-projects)
- * [Articles](#articles)
- * [Thanks](#thanks)
+<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 / Tutorials](#articles--tutorials)
+  - [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)
+
+- [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
 
-* [Mattermost](https://github.com/mattermost/mattermost-server/) 4.x, 5.x
-* [IRC](http://www.mirc.com/servers.html)
-* [XMPP](https://xmpp.org)
-* [Gitter](https://gitter.im)
-* [Slack](https://slack.com)
-* [Discord](https://discordapp.com)
-* [Telegram](https://telegram.org)
-* [Hipchat](https://www.hipchat.com)
-* [Rocket.chat](https://rocket.chat)
-* [Matrix](https://matrix.org)
-* [Steam](https://store.steampowered.com/)
-* [Twitch](https://twitch.tv)
-* [Ssh-chat](https://github.com/shazow/ssh-chat)
-* [WhatsApp](https://www.whatsapp.com/)
-* [Zulip](https://zulipchat.com)
+- [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/)
+- [Microsoft Teams](https://teams.microsoft.com)
+- [Mumble](https://www.mumble.info/)
+- [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/)~~
+  - Not supported anymore, see [here](https://github.com/Philipp15b/go-steam/issues/94) for more info.
+- [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
-* [Minecraft](https://github.com/elytra/MatterLink)
-* [Reddit](https://github.com/bonehurtingjuice/mattereddit)
-* [Facebook messenger](https://github.com/VictorNine/fbridge)
-* [Discourse](https://github.com/DeclanHoare/matterbabble)
+
+- [Discourse](https://github.com/DeclanHoare/matterbabble)
+- [Facebook messenger](https://github.com/VictorNine/fbridge)
+- [Minecraft](https://github.com/elytra/MatterLink)
+- [Minecraft](https://github.com/raws/mattercraft)
+- [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)
+- [Vintage Story](https://github.com/NikkyAI/vs-matterbridge)
 
 ### API
-The API is very basic at the moment.   
+
+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)
+- [MatterLink](https://github.com/elytra/MatterLink) (Matterbridge link for Minecraft Server chat)
+- [Minecraft](https://github.com/raws/mattercraft) (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)
+- [Vintage Story](https://github.com/NikkyAI/vs-matterbridge)
 
 ## Chat with us
 
 Questions or want to test on your favorite platform? Join below:
 
-* [Gitter][mb-gitter]
-* [IRC][mb-irc]
-* [Discord][mb-discord]
-* [Matrix][mb-matrix]
-* [Slack][mb-slack]
-* [Mattermost][mb-mattermost]
-* [Rocket.Chat][mb-rocketchat]
-* [XMPP][mb-xmpp]
-* [Twitch][mb-twitch]
-* [Zulip][mb-zulip]
-* [Telegram][mb-telegram]
+- [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
+See <https://github.com/42wim/matterbridge/wiki>
+
+## Installing / upgrading
+
 ### Binaries
-* Latest stable release [v1.14.0](https://github.com/42wim/matterbridge/releases/latest)
-* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)
+
+- Latest stable release [v1.21.0](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). On \*nix platforms you may need to make the binary executable - you can do this by running `chmod a+x` on the binary (example: `chmod a+x matterbridge-1.20.0-linux-64bit`). After downloading (and making the binary executable, if necessary), 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)
 
-### Building
-Go 1.9+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH](https://golang.org/doc/code.html#GOPATH).
+- [Overview](https://repology.org/metapackage/matterbridge/versions)
+- [snap](https://snapcraft.io/matterbridge)
 
-After Go is setup, download matterbridge to your $GOPATH directory.
+## Building
 
-```
-cd $GOPATH
+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.13+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed.
+
+```bash
 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/
+```bash
+$ ls ~/go/bin/
 matterbridge
 ```
 
 ## Configuration
+
 ### Basic configuration
+
 See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
 
+### Settings
+
+All possible [settings](https://github.com/42wim/matterbridge/wiki/Settings) for each bridge.
+
 ### Advanced configuration
-* [matterbridge.toml.sample](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
+
+- [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]
@@ -183,6 +232,7 @@ enable=true
 ```
 
 #### Bridge slack (#general) - discord (general)
+
 ```toml
 [slack]
 [slack.test]
@@ -214,7 +264,7 @@ RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
 
 See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
 
-```
+```bash
 Usage of ./matterbridge:
   -conf string
         config file (default "matterbridge.toml")
@@ -227,12 +277,11 @@ Usage of ./matterbridge:
 ```
 
 ### Docker
-Create your matterbridge.toml file locally eg in `/tmp/matterbridge.toml`
-```
-docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
-```
+
+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
@@ -240,61 +289,82 @@ See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.m
 See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)
 
 ## Related projects
-* [FOSSRIT/infrastructure - roles/matterbridge](https://github.com/FOSSRIT/infrastructure/tree/master/roles/matterbridge) (Ansible role used to automate deployments of 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/
+- [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)
+- [nextcloud talk](https://github.com/nextcloud/talk_matterbridge) (Integrates matterbridge in Nextcloud Talk)
+- [mattercraft](https://github.com/raws/mattercraft) (Minecraft bridge)
+- [vs-matterbridge](https://github.com/NikkyAI/vs-matterbridge) (Vintage Story bridge)
+
+## Articles / Tutorials
+
+- [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/>
+- <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>
+- <https://nextcloud.com/blog/bridging-chat-services-in-talk/>
+- Youtube: [whatsapp - telegram bridging](https://www.youtube.com/watch?v=W-VXISoKtNc)
 
 ## Thanks
-[![Digitalocean](https://snag.gy/3LVifX.jpg)](https://www.digitalocean.com/) for sponsoring demo/testing droplets.
+
+<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
-* mattermost - https://github.com/mattermost/mattermost-server
-* matrix - https://github.com/matrix-org/gomatrix
-* sshchat - https://github.com/shazow/ssh-chat
-* slack - https://github.com/nlopes/slack
-* steam - https://github.com/Philipp15b/go-steam
-* telegram - https://github.com/go-telegram-bot-api/telegram-bot-api
-* xmpp - https://github.com/mattn/go-xmpp
-* whatsapp - https://github.com/Rhymen/go-whatsapp/
-* zulip - https://github.com/ifo/gozulipbot
-* tengo - https://github.com/d5/tengo
+
+- 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>
+- gumble - <https://github.com/layeh/gumble>
+- 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>
+- mumble - <https://github.com/layeh/gumble>
+- nctalk - <https://github.com/gary-kim/go-nc-talk>
+- 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-gitter]: https://gitter.im/42wim/matterbridge
-   [mb-irc]: https://webchat.freenode.net/?channels=matterbridgechat
-   [mb-discord]: https://discord.gg/AkKPtrQ
-   [mb-matrix]: https://riot.im/app/#/room/#matterbridge:matrix.org
-   [mb-slack]: https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA
-   [mb-mattermost]: https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e
-   [mb-rocketchat]: https://open.rocket.chat/channel/matterbridge
-   [mb-xmpp]: https://inverse.chat/
-   [mb-twitch]: https://www.twitch.tv/matterbridge
-   [mb-whatsapp]: https://www.whatsapp.com/
-   [mb-zulip]: https://matterbridge.zulipchat.com/register/
-   [mb-telegram]: https://t.me/Matterbridge
+[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/t/matterbridgechat/shared_invite/zt-2ourq2h2-7YvyYBq2WFGC~~zEzA68_Q
+[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

@@ -6,17 +6,20 @@ import (
 	"sync"
 	"time"
 
+	"gopkg.in/olahol/melody.v1"
+
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
-	"github.com/zfjagann/golang-ring"
+	ring "github.com/zfjagann/golang-ring"
 )
 
 type API struct {
 	Messages ring.Ring
 	sync.RWMutex
 	*bridge.Config
+	mrouter *melody.Melody
 }
 
 type Message struct {
@@ -32,6 +35,32 @@ func New(cfg *bridge.Config) bridge.Bridger {
 	e := echo.New()
 	e.HideBanner = true
 	e.HidePort = true
+
+	b.mrouter = melody.New()
+	b.mrouter.HandleMessage(func(s *melody.Session, msg []byte) {
+		message := config.Message{}
+		err := json.Unmarshal(msg, &message)
+		if err != nil {
+			b.Log.Errorf("failed to decode message from byte[] '%s'", string(msg))
+			return
+		}
+		b.handleWebsocketMessage(message, s)
+	})
+	b.mrouter.HandleConnect(func(session *melody.Session) {
+		greet := b.getGreeting()
+		data, err := json.Marshal(greet)
+		if err != nil {
+			b.Log.Errorf("failed to encode message '%v'", greet)
+			return
+		}
+		err = session.Write(data)
+		if err != nil {
+			b.Log.Errorf("failed to write message '%s'", string(data))
+			return
+		}
+		// TODO: send message history buffer from `b.Messages` here
+	})
+
 	b.Messages = ring.Ring{}
 	if b.GetInt("Buffer") != 0 {
 		b.Messages.SetCapacity(b.GetInt("Buffer"))
@@ -41,9 +70,17 @@ func New(cfg *bridge.Config) bridge.Bridger {
 			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") == "" {
@@ -58,13 +95,13 @@ func New(cfg *bridge.Config) bridge.Bridger {
 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) {
@@ -74,7 +111,14 @@ func (b *API) Send(msg config.Message) (string, error) {
 	if msg.Event == config.EventMsgDelete {
 		return "", nil
 	}
-	b.Messages.Enqueue(&msg)
+	b.Log.Debugf("enqueueing message from %s on ring buffer", msg.Username)
+	b.Messages.Enqueue(msg)
+
+	data, err := json.Marshal(msg)
+	if err != nil {
+		b.Log.Errorf("failed to encode message  '%s'", msg)
+	}
+	_ = b.mrouter.Broadcast(data)
 	return "", nil
 }
 
@@ -106,18 +150,23 @@ func (b *API) handleMessages(c echo.Context) error {
 	return nil
 }
 
-func (b *API) handleStream(c echo.Context) error {
-	c.Response().Header().Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	c.Response().WriteHeader(http.StatusOK)
-	greet := config.Message{
+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 {
+		// TODO: this causes issues, messages should be broadcasted to all connected clients
 		msg := b.Messages.Dequeue()
 		if msg != nil {
 			if err := json.NewEncoder(c.Response()).Encode(msg); err != nil {
@@ -128,3 +177,31 @@ func (b *API) handleStream(c echo.Context) error {
 		time.Sleep(200 * time.Millisecond)
 	}
 }
+
+func (b *API) handleWebsocketMessage(message config.Message, s *melody.Session) {
+	message.Channel = "api"
+	message.Protocol = "api"
+	message.Account = b.Account
+	message.ID = ""
+	message.Timestamp = time.Now()
+
+	data, err := json.Marshal(message)
+	if err != nil {
+		b.Log.Errorf("failed to encode message for loopback '%v'", message)
+		return
+	}
+	_ = b.mrouter.BroadcastOthers(data, s)
+
+	b.Log.Debugf("Sending websocket message from %s on %s to gateway", message.Username, "api")
+	b.Remote <- message
+}
+
+func (b *API) handleWebsocket(c echo.Context) error {
+	err := b.mrouter.HandleRequest(c.Response(), c.Request())
+	if err != nil {
+		b.Log.Errorf("error in websocket handling  '%v'", err)
+		return err
+	}
+
+	return nil
+}

bridge/bridge.go

@@ -1,8 +1,10 @@
 package bridge
 
 import (
+	"log"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/sirupsen/logrus"
@@ -41,6 +43,10 @@ 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]
 
@@ -69,6 +75,7 @@ func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map
 	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
@@ -79,8 +86,16 @@ func (b *Bridge) joinChannels(channels map[string]config.ChannelInfo, exists map
 	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.Account + "." + key)
+	val, ok := b.Config.GetBool(b.GetConfigKey(key))
 	if !ok {
 		val, _ = b.Config.GetBool("general." + key)
 	}
@@ -88,7 +103,7 @@ func (b *Bridge) GetBool(key string) bool {
 }
 
 func (b *Bridge) GetInt(key string) int {
-	val, ok := b.Config.GetInt(b.Account + "." + key)
+	val, ok := b.Config.GetInt(b.GetConfigKey(key))
 	if !ok {
 		val, _ = b.Config.GetInt("general." + key)
 	}
@@ -96,7 +111,7 @@ func (b *Bridge) GetInt(key string) int {
 }
 
 func (b *Bridge) GetString(key string) string {
-	val, ok := b.Config.GetString(b.Account + "." + key)
+	val, ok := b.Config.GetString(b.GetConfigKey(key))
 	if !ok {
 		val, _ = b.Config.GetString("general." + key)
 	}
@@ -104,7 +119,7 @@ func (b *Bridge) GetString(key string) string {
 }
 
 func (b *Bridge) GetStringSlice(key string) []string {
-	val, ok := b.Config.GetStringSlice(b.Account + "." + key)
+	val, ok := b.Config.GetStringSlice(b.GetConfigKey(key))
 	if !ok {
 		val, _ = b.Config.GetStringSlice("general." + key)
 	}
@@ -112,7 +127,7 @@ func (b *Bridge) GetStringSlice(key string) []string {
 }
 
 func (b *Bridge) GetStringSlice2D(key string) [][]string {
-	val, ok := b.Config.GetStringSlice2D(b.Account + "." + key)
+	val, ok := b.Config.GetStringSlice2D(b.GetConfigKey(key))
 	if !ok {
 		val, _ = b.Config.GetStringSlice2D("general." + key)
 	}

bridge/config/config.go

@@ -3,6 +3,8 @@ package config
 import (
 	"bytes"
 	"io/ioutil"
+	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -24,8 +26,11 @@ const (
 	EventAPIConnected      = "api_connected"
 	EventUserTyping        = "user_typing"
 	EventGetChannelMembers = "get_channel_members"
+	EventNoticeIRC         = "notice_irc"
 )
 
+const ParentIDNotFound = "msg-parent-not-found"
+
 type Message struct {
 	Text      string    `json:"text"`
 	Channel   string    `json:"channel"`
@@ -42,6 +47,14 @@ type Message struct {
 	Extra     map[string][]interface{}
 }
 
+func (m Message) ParentNotFound() bool {
+	return m.ParentID == ParentIDNotFound
+}
+
+func (m Message) ParentValid() bool {
+	return m.ParentID != "" && !m.ParentNotFound()
+}
+
 type FileInfo struct {
 	Name    string
 	Data    *[]byte
@@ -76,23 +89,29 @@ type Protocol struct {
 	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
@@ -109,38 +128,46 @@ type Protocol struct {
 	NicksPerRow            int        // mattermost, slack
 	NoHomeServerSuffix     bool       // matrix
 	NoSendJoinPart         bool       // all protocols
-	NoTLS                  bool       // mattermost
+	NoTLS                  bool       // mattermost, xmpp
 	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
+	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
+	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
+	UseUserName            bool       // discord, matrix
 	UseInsecureURL         bool       // telegram
+	VerboseJoinPart        bool       // IRC
 	WebhookBindAddress     string     // mattermost, slack
 	WebhookURL             string     // mattermost, slack
 }
@@ -166,6 +193,13 @@ type Gateway struct {
 	InOut  []Bridge
 }
 
+type Tengo struct {
+	InMessage        string
+	Message          string
+	RemoteNickFormat string
+	OutMessage       string
+}
+
 type SameChannelGateway struct {
 	Name     string
 	Enable   bool
@@ -189,13 +223,18 @@ type BridgeValues struct {
 	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
+	Mumble             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)
@@ -221,7 +260,17 @@ func NewConfig(rootLogger *logrus.Logger, cfgfile string) Config {
 		logger.Fatalf("Failed to read configuration file: %#v", err)
 	}
 
-	mycfg := newConfigFromString(logger, input)
+	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
 	}
@@ -232,25 +281,37 @@ func NewConfig(rootLogger *logrus.Logger, cfgfile string) Config {
 	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)
+	return newConfigFromString(logger, input, "toml")
 }
 
-func newConfigFromString(logger *logrus.Entry, input []byte) *config {
-	viper.SetConfigType("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: %#v", err)
+		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: %#v", err)
+		logger.Fatalf("Failed to load the configuration: %s", err)
 	}
 	return &config{
 		logger: logger,
@@ -263,6 +324,16 @@ 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()
@@ -322,6 +393,11 @@ type TestConfig struct {
 	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 {

bridge/discord/discord.go

@@ -2,15 +2,15 @@ package bdiscord
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"strings"
 	"sync"
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/discord/transmitter"
 	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/bwmarrin/discordgo"
+	"github.com/matterbridge/discordgo"
 )
 
 const MessageLength = 1950
@@ -20,12 +20,9 @@ type Bdiscord struct {
 
 	c *discordgo.Session
 
-	nick            string
-	useChannelID    bool
-	guildID         string
-	webhookID       string
-	webhookToken    string
-	canEditWebhooks bool
+	nick    string
+	userID  string
+	guildID string
 
 	channelsMutex  sync.RWMutex
 	channels       []*discordgo.Channel
@@ -34,6 +31,10 @@ type Bdiscord struct {
 	membersMutex  sync.RWMutex
 	userMemberMap map[string]*discordgo.Member
 	nickMemberMap map[string]*discordgo.Member
+
+	// Webhook specific logic
+	useAutoWebhooks bool
+	transmitter     *transmitter.Transmitter
 }
 
 func New(cfg *bridge.Config) bridge.Bridger {
@@ -41,23 +42,18 @@ func New(cfg *bridge.Config) bridge.Bridger {
 	b.userMemberMap = make(map[string]*discordgo.Member)
 	b.nickMemberMap = make(map[string]*discordgo.Member)
 	b.channelInfoMap = make(map[string]*config.ChannelInfo)
-	if b.GetString("WebhookURL") != "" {
-		b.Log.Debug("Configuring Discord Incoming Webhook")
-		b.webhookID, b.webhookToken = b.splitURL(b.GetString("WebhookURL"))
+
+	b.useAutoWebhooks = b.GetBool("AutoWebhooks")
+	if b.useAutoWebhooks {
+		b.Log.Debug("Using automatic webhooks")
 	}
 	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")
 	}
@@ -72,9 +68,11 @@ func (b *Bdiscord) Connect() error {
 	}
 	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()
@@ -91,55 +89,108 @@ func (b *Bdiscord) Connect() error {
 	}
 	serverName := strings.Replace(b.GetString("Server"), "ID:", "", -1)
 	b.nick = userinfo.Username
+	b.userID = userinfo.ID
+
+	// Try and find this account's guild, and populate channels
 	b.channelsMutex.Lock()
 	for _, guild := range guilds {
-		if guild.Name == serverName || guild.ID == serverName {
-			b.channels, err = b.c.GuildChannels(guild.ID)
-			b.guildID = guild.ID
-			guildFound = true
-			if err != nil {
-				break
-			}
+		// Skip, if the server name does not match the visible name or the ID
+		if guild.Name != serverName && guild.ID != serverName {
+			continue
 		}
+
+		// Complain about an ambiguous Server setting. Two Discord servers could have the same title!
+		// For IDs, practically this will never happen. It would only trigger if some server's name is also an ID.
+		if b.guildID != "" {
+			return fmt.Errorf("found multiple Discord servers with the same name %#v, expected to see only one", serverName)
+		}
+
+		// Getting this guild's channel could result in a permission error
+		b.channels, err = b.c.GuildChannels(guild.ID)
+		if err != nil {
+			return fmt.Errorf("could not get %#v's channels: %w", b.GetString("Server"), err)
+		}
+
+		b.guildID = guild.ID
 	}
 	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 {
+	// If we couldn't find a guild, we print extra debug information and return a nice error
+	if b.guildID == "" {
+		err = fmt.Errorf("could not find Discord server %#v", b.GetString("Server"))
+		b.Log.Error(err.Error())
+
+		// Print all of the possible server values
+		b.Log.Info("Possible server values:")
+		for _, guild := range guilds {
+			b.Log.Infof("\t- Server=%#v # by name", guild.Name)
+			b.Log.Infof("\t- Server=%#v # by ID", guild.ID)
+		}
+
+		// If there are no results, we should say that
+		if len(guilds) == 0 {
+			b.Log.Info("\t- (none found)")
+		}
+
 		return err
 	}
-	b.channelsMutex.RLock()
-	if b.GetString("WebhookURL") == "" {
-		for _, channel := range b.channels {
-			b.Log.Debugf("found channel %#v", channel)
-		}
-	} else {
-		b.canEditWebhooks = true
-		for _, channel := range b.channels {
-			b.Log.Debugf("found channel %#v; verifying PermissionManageWebhooks", channel)
-			perms, permsErr := b.c.State.UserChannelPermissions(userinfo.ID, channel.ID)
-			manageWebhooks := discordgo.PermissionManageWebhooks
-			if permsErr != nil || perms&manageWebhooks != manageWebhooks {
-				b.Log.Warnf("Can't manage webhooks in channel \"%s\"", channel.Name)
-				b.canEditWebhooks = false
+
+	// Legacy note: WebhookURL used to have an actual webhook URL that we would edit,
+	// but we stopped doing that due to Discord making rate limits more aggressive.
+	//
+	// Even older: the same WebhookURL used to be used by every channel, which is usually unexpected.
+	// This is no longer possible.
+	if b.GetString("WebhookURL") != "" {
+		message := "The global WebhookURL setting has been removed. "
+		message += "You can get similar \"webhook editing\" behaviour by replacing this line with `AutoWebhooks=true`. "
+		message += "If you rely on the old-OLD (non-editing) behaviour, can move the WebhookURL to specific channel sections."
+		b.Log.Errorln(message)
+		return fmt.Errorf("use of removed WebhookURL setting")
+	}
+
+	if b.GetInt("debuglevel") > 0 {
+		b.Log.Debug("enabling even more discord debug")
+		b.c.Debug = true
+	}
+
+	// Initialise webhook management
+	b.transmitter = transmitter.New(b.c, b.guildID, "matterbridge", b.useAutoWebhooks)
+	b.transmitter.Log = b.Log
+
+	var webhookChannelIDs []string
+	for _, channel := range b.Channels {
+		channelID := b.getChannelID(channel.Name) // note(qaisjp): this readlocks channelsMutex
+
+		// If a WebhookURL was not explicitly provided for this channel,
+		// there are two options: just a regular bot message (ugly) or this is should be webhook sent
+		if channel.Options.WebhookURL == "" {
+			// If it should be webhook sent, we should enforce this via the transmitter
+			if b.useAutoWebhooks {
+				webhookChannelIDs = append(webhookChannelIDs, channelID)
 			}
+			continue
 		}
-		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")
+
+		whID, whToken, ok := b.splitURL(channel.Options.WebhookURL)
+		if !ok {
+			return fmt.Errorf("failed to parse WebhookURL %#v for channel %#v", channel.Options.WebhookURL, channel.ID)
+		}
+
+		b.transmitter.AddWebhook(channelID, &discordgo.Webhook{
+			ID:        whID,
+			Token:     whToken,
+			GuildID:   b.guildID,
+			ChannelID: channelID,
+		})
+	}
+
+	if b.useAutoWebhooks {
+		err = b.transmitter.RefreshGuildWebhooks(webhookChannelIDs)
+		if err != nil {
+			b.Log.WithError(err).Println("transmitter could not refresh guild webhooks")
+			return err
 		}
 	}
-	b.channelsMutex.RUnlock()
 
 	// Obtaining guild members and initializing nickname mapping.
 	b.membersMutex.Lock()
@@ -172,10 +223,6 @@ func (b *Bdiscord) JoinChannel(channel config.ChannelInfo) error {
 	defer b.channelsMutex.Unlock()
 
 	b.channelInfoMap[channel.ID] = &channel
-	idcheck := strings.Split(channel.Name, "ID:")
-	if len(idcheck) > 1 {
-		b.useChannelID = true
-	}
 	return nil
 }
 
@@ -187,81 +234,36 @@ func (b *Bdiscord) Send(msg config.Message) (string, error) {
 		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
-		}
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentNotFound() {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
 	}
-	b.channelsMutex.RUnlock()
 
 	// Use webhook to send the message
-	if wID != "" {
-		// skip events
-		if msg.Event != "" && msg.Event != config.EventJoinLeave && msg.Event != config.EventTopicChange {
-			return "", nil
-		}
-		b.Log.Debugf("Broadcasting using Webhook")
-		for _, f := range msg.Extra["file"] {
-			fi := f.(config.FileInfo)
-			if fi.Comment != "" {
-				msg.Text += fi.Comment + ": "
-			}
-			if fi.URL != "" {
-				msg.Text = fi.URL
-				if fi.Comment != "" {
-					msg.Text = fi.Comment + ": " + fi.URL
-				}
-			}
-		}
-		// skip empty messages
-		if msg.Text == "" {
-			return "", nil
-		}
-
-		msg.Text = helper.ClipMessage(msg.Text, MessageLength)
-		msg.Text = b.replaceUserMentions(msg.Text)
-		// discord username must be [0..32] max
-		if len(msg.Username) > 32 {
-			msg.Username = msg.Username[0:32]
-		}
-		// 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
-			}
-		}
-		err := b.c.WebhookExecute(
-			wID,
-			wToken,
-			true,
-			&discordgo.WebhookParams{
-				Content:   msg.Text,
-				Username:  msg.Username,
-				AvatarURL: msg.Avatar,
-			})
-		return "", err
+	useWebhooks := b.shouldMessageUseWebhooks(&msg)
+	if useWebhooks && msg.Event != config.EventMsgDelete && msg.ParentID == "" {
+		return b.handleEventWebhook(&msg, channelID)
 	}
 
+	return b.handleEventBotUser(&msg, channelID)
+}
+
+// handleEventDirect handles events via the bot user
+func (b *Bdiscord) handleEventBotUser(msg *config.Message, channelID string) (string, error) {
 	b.Log.Debugf("Broadcasting using token (API)")
 
 	// Delete message
@@ -275,7 +277,7 @@ func (b *Bdiscord) Send(msg config.Message) (string, error) {
 
 	// Upload a file if it exists
 	if msg.Extra != nil {
-		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
+		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)
@@ -283,7 +285,7 @@ func (b *Bdiscord) Send(msg config.Message) (string, error) {
 		}
 		// check if we have files to upload (from slack, telegram or mattermost)
 		if len(msg.Extra["file"]) > 0 {
-			return b.handleUploadFile(&msg, channelID)
+			return b.handleUploadFile(msg, channelID)
 		}
 	}
 
@@ -296,52 +298,25 @@ func (b *Bdiscord) Send(msg config.Message) (string, error) {
 		return msg.ID, err
 	}
 
+	m := discordgo.MessageSend{
+		Content: msg.Username + msg.Text,
+	}
+
+	if msg.ParentValid() {
+		m.Reference = &discordgo.MessageReference{
+			MessageID: msg.ParentID,
+			ChannelID: channelID,
+			GuildID:   b.guildID,
+		}
+	}
+
 	// Post normal message
-	res, err := b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
+	res, err := b.c.ChannelMessageSendComplex(channelID, &m)
 	if err != nil {
 		return "", err
 	}
-	return res.ID, err
-}
 
-// 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
+	return res.ID, nil
 }
 
 // handleUploadFile handles native upload of files

bridge/discord/handlers.go

@@ -2,20 +2,50 @@ package bdiscord
 
 import (
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/bwmarrin/discordgo"
+	"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)
-	if b.useChannelID {
-		rmsg.Channel = "ID:" + m.ChannelID
-	}
+
 	b.Log.Debugf("<= Sending message from %s to gateway", b.Account)
 	b.Log.Debugf("<= Message is %#v", rmsg)
 	b.Remote <- rmsg
 }
 
+// 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
@@ -24,7 +54,10 @@ func (b *Bdiscord) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdat
 	if m.Message.EditedTimestamp != "" {
 		b.Log.Debugf("Sending edit message")
 		m.Content += b.GetString("EditSuffix")
-		b.messageCreate(s, (*discordgo.MessageCreate)(m))
+		msg := &discordgo.MessageCreate{
+			Message: m.Message,
+		}
+		b.messageCreate(s, msg)
 	}
 }
 
@@ -36,7 +69,7 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 		return
 	}
 	// if using webhooks, do not relay if it's ours
-	if b.useWebhook() && m.Author.Bot { // && b.isWebhookID(m.Author.ID) {
+	if m.Author.Bot && b.transmitter.HasWebhook(m.Author.ID) {
 		return
 	}
 
@@ -51,7 +84,6 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 
 	if m.Content != "" {
 		b.Log.Debugf("== Receiving event %#v", m.Message)
-		m.Message.Content = b.stripCustomoji(m.Message.Content)
 		m.Message.Content = b.replaceChannelMentions(m.Message.Content)
 		rmsg.Text, err = m.ContentWithMoreMentionsReplaced(b.c)
 		if err != nil {
@@ -62,16 +94,13 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 
 	// set channel name
 	rmsg.Channel = b.getChannelName(m.ChannelID)
-	if b.useChannelID {
-		rmsg.Channel = "ID:" + m.ChannelID
-	}
 
-	// set username
-	if !b.GetBool("UseUserName") {
-		rmsg.Username = b.getNick(m.Author)
+	fromWebhook := m.WebhookID != ""
+	if !fromWebhook && !b.GetBool("UseUserName") {
+		rmsg.Username = b.getNick(m.Author, m.GuildID)
 	} else {
 		rmsg.Username = m.Author.Username
-		if b.GetBool("UseDiscriminator") {
+		if !fromWebhook && b.GetBool("UseDiscriminator") {
 			rmsg.Username += "#" + m.Author.Discriminator
 		}
 	}
@@ -79,7 +108,7 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 	// if we have embedded content add it to text
 	if b.GetBool("ShowEmbeds") && m.Message.Embeds != nil {
 		for _, embed := range m.Message.Embeds {
-			rmsg.Text = rmsg.Text + "embed: " + embed.Title + " - " + embed.Description + " - " + embed.URL + "\n"
+			rmsg.Text += handleEmbed(embed)
 		}
 	}
 
@@ -95,6 +124,14 @@ func (b *Bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 		rmsg.Event = config.EventUserAction
 	}
 
+	// Replace emotes
+	rmsg.Text = replaceEmotes(rmsg.Text)
+
+	// Add our parent id if it exists, and if it's not referring to a message in another channel
+	if ref := m.MessageReference; ref != nil && ref.ChannelID == m.ChannelID {
+		rmsg.ParentID = ref.MessageID
+	}
+
 	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
@@ -168,3 +205,33 @@ func (b *Bdiscord) memberRemove(s *discordgo.Session, m *discordgo.GuildMemberRe
 	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

@@ -6,10 +6,10 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/bwmarrin/discordgo"
+	"github.com/matterbridge/discordgo"
 )
 
-func (b *Bdiscord) getNick(user *discordgo.User) string {
+func (b *Bdiscord) getNick(user *discordgo.User, guildID string) string {
 	b.membersMutex.RLock()
 	defer b.membersMutex.RUnlock()
 
@@ -23,9 +23,9 @@ func (b *Bdiscord) getNick(user *discordgo.User) string {
 	}
 
 	// If we didn't find nick, search for it.
-	member, err := b.c.GuildMember(b.guildID, user.ID)
+	member, err := b.c.GuildMember(guildID, user.ID)
 	if err != nil {
-		b.Log.Warnf("Failed to fetch information for member %#v: %s", user, err)
+		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)
@@ -51,6 +51,9 @@ func (b *Bdiscord) getGuildMemberByNick(nick string) (*discordgo.Member, error)
 }
 
 func (b *Bdiscord) getChannelID(name string) string {
+	if strings.Contains(name, "/") {
+		return b.getCategoryChannelID(name)
+	}
 	b.channelsMutex.RLock()
 	defer b.channelsMutex.RUnlock()
 
@@ -59,40 +62,92 @@ func (b *Bdiscord) getChannelID(name string) string {
 		return idcheck[1]
 	}
 	for _, channel := range b.channels {
-		if channel.Name == name {
+		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 channel.Name
+			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]+>")
-	emojiRE          = 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 {
-		var err error
 		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"
@@ -128,19 +183,20 @@ func (b *Bdiscord) replaceUserMentions(text string) string {
 	return userMentionRE.ReplaceAllStringFunc(text, replaceUserMentionFunc)
 }
 
-func (b *Bdiscord) stripCustomoji(text string) string {
-	return emojiRE.ReplaceAllString(text, `$1`)
+func replaceEmotes(text string) string {
+	return emoteRE.ReplaceAllString(text, "$1")
 }
 
 func (b *Bdiscord) replaceAction(text string) (string, bool) {
-	if strings.HasPrefix(text, "_") && strings.HasSuffix(text, "_") {
-		return text[1:], true
+	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) {
+func (b *Bdiscord) splitURL(url string) (string, string, bool) {
 	const (
 		expectedWebhookSplitCount = 7
 		webhookIdxID              = 5
@@ -148,9 +204,9 @@ func (b *Bdiscord) splitURL(url string) (string, string) {
 	)
 	webhookURLSplit := strings.Split(url, "/")
 	if len(webhookURLSplit) != expectedWebhookSplitCount {
-		b.Log.Fatalf("%s is no correct discord WebhookURL", url)
+		return "", "", false
 	}
-	return webhookURLSplit[webhookIdxID], webhookURLSplit[webhookIdxToken]
+	return webhookURLSplit[webhookIdxID], webhookURLSplit[webhookIdxToken], true
 }
 
 func enumerateUsernames(s string) []string {

bridge/discord/transmitter/transmitter.go

@@ -0,0 +1,258 @@
+// Package transmitter provides functionality for transmitting
+// arbitrary webhook messages to Discord.
+//
+// The package provides the following functionality:
+//
+// - Creating new webhooks, whenever necessary
+// - Loading webhooks that we have previously created
+// - Sending new messages
+// - Editing messages, via message ID
+// - Deleting messages, via message ID
+//
+// The package has been designed for matterbridge, but with other
+// Go bots in mind. The public API should be matterbridge-agnostic.
+package transmitter
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/matterbridge/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+// A Transmitter represents a message manager for a single guild.
+type Transmitter struct {
+	session    *discordgo.Session
+	guild      string
+	title      string
+	autoCreate bool
+
+	// channelWebhooks maps from a channel ID to a webhook instance
+	channelWebhooks map[string]*discordgo.Webhook
+
+	mutex sync.RWMutex
+
+	Log *log.Entry
+}
+
+// ErrWebhookNotFound is returned when a valid webhook for this channel/message combination does not exist
+var ErrWebhookNotFound = errors.New("webhook for this channel and message does not exist")
+
+// ErrPermissionDenied is returned if the bot does not have permission to manage webhooks.
+//
+// Bots can be granted a guild-wide permission and channel-specific permissions to manage webhooks.
+// Despite potentially having guild-wide permission, channel specific overrides could deny a bot's permission to manage webhooks.
+var ErrPermissionDenied = errors.New("missing 'Manage Webhooks' permission")
+
+// New returns a new Transmitter given a Discord session, guild ID, and title.
+func New(session *discordgo.Session, guild string, title string, autoCreate bool) *Transmitter {
+	return &Transmitter{
+		session:    session,
+		guild:      guild,
+		title:      title,
+		autoCreate: autoCreate,
+
+		channelWebhooks: make(map[string]*discordgo.Webhook),
+
+		Log: log.NewEntry(nil),
+	}
+}
+
+// Send transmits a message to the given channel with the provided webhook data, and waits until Discord responds with message data.
+func (t *Transmitter) Send(channelID string, params *discordgo.WebhookParams) (*discordgo.Message, error) {
+	wh, err := t.getOrCreateWebhook(channelID)
+	if err != nil {
+		return nil, err
+	}
+
+	msg, err := t.session.WebhookExecute(wh.ID, wh.Token, true, params)
+	if err != nil {
+		return nil, fmt.Errorf("execute failed: %w", err)
+	}
+
+	return msg, nil
+}
+
+// Edit will edit a message in a channel, if possible.
+func (t *Transmitter) Edit(channelID string, messageID string, params *discordgo.WebhookParams) error {
+	wh := t.getWebhook(channelID)
+
+	if wh == nil {
+		return ErrWebhookNotFound
+	}
+
+	uri := discordgo.EndpointWebhookToken(wh.ID, wh.Token) + "/messages/" + messageID
+	_, err := t.session.RequestWithBucketID("PATCH", uri, params, discordgo.EndpointWebhookToken("", ""))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// HasWebhook checks whether the transmitter is using a particular webhook.
+func (t *Transmitter) HasWebhook(id string) bool {
+	t.mutex.RLock()
+	defer t.mutex.RUnlock()
+
+	for _, wh := range t.channelWebhooks {
+		if wh.ID == id {
+			return true
+		}
+	}
+
+	return false
+}
+
+// AddWebhook allows you to register a channel's webhook with the transmitter.
+func (t *Transmitter) AddWebhook(channelID string, webhook *discordgo.Webhook) bool {
+	t.Log.Debugf("Manually added webhook %#v to channel %#v", webhook.ID, channelID)
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+
+	_, replaced := t.channelWebhooks[channelID]
+	t.channelWebhooks[channelID] = webhook
+	return replaced
+}
+
+// RefreshGuildWebhooks loads "relevant" webhooks into the transmitter, with careful permission handling.
+//
+// Notes:
+//
+// - A webhook is "relevant" if it was created by this bot -- the ApplicationID should match the bot's ID.
+// - The term "having permission" means having the "Manage Webhooks" permission. See ErrPermissionDenied for more information.
+// - This function is additive and will not unload previously loaded webhooks.
+// - A nil channelIDs slice is treated the same as an empty one.
+//
+// If the bot has guild-wide permission:
+//
+// 1. it will load any "relevant" webhooks from the entire guild
+// 2. the given slice is ignored
+//
+// If the bot does not have guild-wide permission:
+//
+// 1. it will load any "relevant" webhooks in each channel
+// 2. a single error will be returned if any error occurs (incl. if there is no permission for any of these channels)
+//
+// If any channel has more than one "relevant" webhook, it will randomly pick one.
+func (t *Transmitter) RefreshGuildWebhooks(channelIDs []string) error {
+	t.Log.Debugln("Refreshing guild webhooks")
+
+	botID, err := getDiscordUserID(t.session)
+	if err != nil {
+		return fmt.Errorf("could not get current user: %w", err)
+	}
+
+	// Get all existing webhooks
+	hooks, err := t.session.GuildWebhooks(t.guild)
+	if err != nil {
+		switch {
+		case isDiscordPermissionError(err):
+			// We fallback on manually fetching hooks from individual channels
+			// if we don't have the "Manage Webhooks" permission globally.
+			// We can only do this if we were provided channelIDs, though.
+			if len(channelIDs) == 0 {
+				return ErrPermissionDenied
+			}
+			t.Log.Debugln("Missing global 'Manage Webhooks' permission, falling back on per-channel permission")
+			return t.fetchChannelsHooks(channelIDs, botID)
+		default:
+			return fmt.Errorf("could not get webhooks: %w", err)
+		}
+	}
+
+	t.Log.Debugln("Refreshing guild webhooks using global permission")
+	t.assignHooksByAppID(hooks, botID, false)
+	return nil
+}
+
+// createWebhook creates a webhook for a specific channel.
+func (t *Transmitter) createWebhook(channel string) (*discordgo.Webhook, error) {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+
+	wh, err := t.session.WebhookCreate(channel, t.title+time.Now().Format(" 3:04:05PM"), "")
+	if err != nil {
+		return nil, err
+	}
+
+	t.channelWebhooks[channel] = wh
+	return wh, nil
+}
+
+func (t *Transmitter) getWebhook(channel string) *discordgo.Webhook {
+	t.mutex.RLock()
+	defer t.mutex.RUnlock()
+
+	return t.channelWebhooks[channel]
+}
+
+func (t *Transmitter) getOrCreateWebhook(channelID string) (*discordgo.Webhook, error) {
+	// If we have a webhook for this channel, immediately return it
+	wh := t.getWebhook(channelID)
+	if wh != nil {
+		return wh, nil
+	}
+
+	// Early exit if we don't want to automatically create one
+	if !t.autoCreate {
+		return nil, ErrWebhookNotFound
+	}
+
+	t.Log.Infof("Creating a webhook for %s\n", channelID)
+	wh, err := t.createWebhook(channelID)
+	if err != nil {
+		return nil, fmt.Errorf("could not create webhook: %w", err)
+	}
+
+	return wh, nil
+}
+
+// fetchChannelsHooks fetches hooks for the given channelIDs and calls assignHooksByAppID for each channel's hooks
+func (t *Transmitter) fetchChannelsHooks(channelIDs []string, botID string) error {
+	// For each channel, search for relevant hooks
+	var failedHooks []string
+	for _, channelID := range channelIDs {
+		hooks, err := t.session.ChannelWebhooks(channelID)
+		if err != nil {
+			failedHooks = append(failedHooks, "\n- "+channelID+": "+err.Error())
+			continue
+		}
+		t.assignHooksByAppID(hooks, botID, true)
+	}
+
+	// Compose an error if any hooks failed
+	if len(failedHooks) > 0 {
+		return errors.New("failed to fetch hooks:" + strings.Join(failedHooks, ""))
+	}
+
+	return nil
+}
+
+func (t *Transmitter) assignHooksByAppID(hooks []*discordgo.Webhook, appID string, channelTargeted bool) {
+	logLine := "Picking up webhook"
+	if channelTargeted {
+		logLine += " (channel targeted)"
+	}
+
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+
+	for _, wh := range hooks {
+		if wh.ApplicationID != appID {
+			continue
+		}
+
+		t.channelWebhooks[wh.ChannelID] = wh
+		t.Log.WithFields(log.Fields{
+			"id":      wh.ID,
+			"name":    wh.Name,
+			"channel": wh.ChannelID,
+		}).Println(logLine)
+		break
+	}
+}

bridge/discord/transmitter/utils.go

@@ -0,0 +1,32 @@
+package transmitter
+
+import (
+	"github.com/matterbridge/discordgo"
+)
+
+// isDiscordPermissionError returns false for nil, and true if a Discord RESTError with code discordgo.ErrorCodeMissionPermissions
+func isDiscordPermissionError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	restErr, ok := err.(*discordgo.RESTError)
+	if !ok {
+		return false
+	}
+
+	return restErr.Message != nil && restErr.Message.Code == discordgo.ErrCodeMissingPermissions
+}
+
+// getDiscordUserID gets own user ID from state, and fallback on API request
+func getDiscordUserID(session *discordgo.Session) (string, error) {
+	if user := session.State.User; user != nil {
+		return user.ID, nil
+	}
+
+	user, err := session.User("@me")
+	if err != nil {
+		return "", err
+	}
+	return user.ID, nil
+}

bridge/discord/webhook.go

@@ -0,0 +1,147 @@
+package bdiscord
+
+import (
+	"bytes"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/matterbridge/discordgo"
+)
+
+// shouldMessageUseWebhooks checks if have a channel specific webhook, if we're not using auto webhooks
+func (b *Bdiscord) shouldMessageUseWebhooks(msg *config.Message) bool {
+	if b.useAutoWebhooks {
+		return true
+	}
+
+	b.channelsMutex.RLock()
+	defer b.channelsMutex.RUnlock()
+	if ci, ok := b.channelInfoMap[msg.Channel+b.Account]; ok {
+		if ci.Options.WebhookURL != "" {
+			return true
+		}
+	}
+	return false
+}
+
+// maybeGetLocalAvatar checks if UseLocalAvatar contains the message's
+// account or protocol, and if so, returns the Discord avatar (if exists)
+func (b *Bdiscord) maybeGetLocalAvatar(msg *config.Message) string {
+	for _, val := range b.GetStringSlice("UseLocalAvatar") {
+		if msg.Protocol != val && msg.Account != val {
+			continue
+		}
+
+		member, err := b.getGuildMemberByNick(msg.Username)
+		if err != nil {
+			return ""
+		}
+
+		return member.User.AvatarURL("")
+	}
+	return ""
+}
+
+// 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, channelID string) (*discordgo.Message, error) {
+	var (
+		res *discordgo.Message
+		err error
+	)
+
+	// If avatar is unset, mutate the message to include the local avatar (but only if settings say we should do this)
+	if msg.Avatar == "" {
+		msg.Avatar = b.maybeGetLocalAvatar(msg)
+	}
+
+	// WebhookParams can have either `Content` or `File`.
+
+	// We can't send empty messages.
+	if msg.Text != "" {
+		res, err = b.transmitter.Send(
+			channelID,
+			&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.transmitter.Send(
+				channelID,
+				&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) handleEventWebhook(msg *config.Message, channelID string) (string, error) {
+	// skip events
+	if msg.Event != "" && msg.Event != config.EventUserAction && msg.Event != config.EventJoinLeave && msg.Event != config.EventTopicChange {
+		return "", nil
+	}
+
+	// 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 msg.ID != "" {
+		b.Log.Debugf("Editing webhook message")
+		err := b.transmitter.Edit(channelID, msg.ID, &discordgo.WebhookParams{
+			Content:  msg.Text,
+			Username: msg.Username,
+		})
+		if err == nil {
+			return msg.ID, nil
+		}
+		b.Log.Errorf("Could not edit webhook message: %s", err)
+	}
+
+	b.Log.Debugf("Processing webhook sending for message %#v", msg)
+	discordMsg, err := b.webhookSend(msg, channelID)
+	if err != nil {
+		b.Log.Errorf("Could not broadcast via webhook for message %#v: %s", msg, err)
+		return "", err
+	}
+	if discordMsg == nil {
+		return "", nil
+	}
+
+	return discordMsg.ID, nil
+}

bridge/helper/helper.go

@@ -5,7 +5,10 @@ import (
 	"fmt"
 	"image/png"
 	"io"
+	"io/ioutil"
 	"net/http"
+	"os"
+	"os/exec"
 	"regexp"
 	"strings"
 	"time"
@@ -14,8 +17,10 @@ import (
 	"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"
-	"gitlab.com/golang-commonmark/markdown"
 )
 
 // DownloadFile downloads the given non-authenticated URL.
@@ -176,15 +181,21 @@ func ClipMessage(text string, length int) string {
 	return text
 }
 
+// ParseMarkdown takes in an input string as markdown and parses it to html
 func ParseMarkdown(input string) string {
-	md := markdown.New(markdown.XHTMLOutput(true), markdown.Breaks(true))
-	res := md.RenderToString([]byte(input))
+	extensions := parser.HardLineBreak | parser.NoIntraEmphasis | parser.FencedCode
+	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 convert input data (which should be WebP format to PNG format)
+// 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)
@@ -199,3 +210,49 @@ func ConvertWebPToPNG(data *[]byte) error {
 	*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/irc/handlers.go

@@ -4,15 +4,14 @@ import (
 	"bytes"
 	"fmt"
 	"io/ioutil"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/dfordsoft/golib/ic"
 	"github.com/lrstanley/girc"
+	"github.com/missdeer/golib/ic"
 	"github.com/paulrosania/go-charset/charset"
 	"github.com/saintfish/chardet"
 
@@ -55,12 +54,12 @@ func (b *Birc) handleFiles(msg *config.Message) bool {
 	for _, f := range msg.Extra["file"] {
 		fi := f.(config.FileInfo)
 		if fi.Comment != "" {
-			msg.Text += fi.Comment + ": "
+			msg.Text += fi.Comment + " : "
 		}
 		if fi.URL != "" {
 			msg.Text = fi.URL
 			if fi.Comment != "" {
-				msg.Text = fi.Comment + ": " + fi.URL
+				msg.Text = fi.Comment + " : " + fi.URL
 			}
 		}
 		b.Local <- config.Message{Text: msg.Text, Username: msg.Username, Channel: msg.Channel, Event: msg.Event}
@@ -68,6 +67,20 @@ func (b *Birc) handleFiles(msg *config.Message) bool {
 	return true
 }
 
+func (b *Birc) handleInvite(client *girc.Client, event girc.Event) {
+	if len(event.Params) != 2 {
+		return
+	}
+
+	channel := event.Params[1]
+
+	b.Log.Debugf("got invite for %s", channel)
+
+	if _, ok := b.channels[channel]; ok {
+		b.i.Cmd.Join(channel)
+	}
+}
+
 func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
 	if len(event.Params) == 0 {
 		b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
@@ -91,12 +104,13 @@ func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
 		if b.GetBool("nosendjoinpart") {
 			return
 		}
-		b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
-		// QUIT isn't channel bound, happens for all channels on the bridge
-		if event.Command == "QUIT" {
-			channel = ""
-		}
 		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
@@ -109,14 +123,15 @@ func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
 	i := b.i
 	b.Nick = event.Params[0]
 
-	i.Handlers.Add("PRIVMSG", b.handlePrivMsg)
-	i.Handlers.Add("CTCP_ACTION", b.handlePrivMsg)
+	i.Handlers.AddBg("PRIVMSG", b.handlePrivMsg)
+	i.Handlers.AddBg("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)
+	i.Handlers.AddBg(girc.NOTICE, b.handleNotice)
+	i.Handlers.AddBg("JOIN", b.handleJoinPart)
+	i.Handlers.AddBg("PART", b.handleJoinPart)
+	i.Handlers.AddBg("QUIT", b.handleJoinPart)
+	i.Handlers.AddBg("KICK", b.handleJoinPart)
+	i.Handlers.Add("INVITE", b.handleInvite)
 }
 
 func (b *Birc) handleNickServ() {
@@ -160,14 +175,24 @@ func (b *Birc) handleOtherAuth(client *girc.Client, event girc.Event) {
 	b.handleNickServ()
 	b.handleRunCommands()
 	// we are now fully connected
-	b.connected <- nil
+	// 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}
+
+	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
@@ -175,13 +200,14 @@ func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
 		rmsg.Event = config.EventUserAction
 	}
 
+	// set NOTICE event
+	if event.Command == "NOTICE" {
+		rmsg.Event = config.EventNoticeIRC
+	}
+
 	// strip action, we made an event if it was an action
 	rmsg.Text += event.StripAction()
 
-	// strip IRC colors
-	re := regexp.MustCompile(`\x03(?:\d{1,2}(?:,\d{1,2})?)?|[[:cntrl:]]`)
-	rmsg.Text = re.ReplaceAllString(rmsg.Text, "")
-
 	// start detecting the charset
 	mycharset := b.GetString("Charset")
 	if mycharset == "" {

bridge/irc/irc.go

@@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"fmt"
 	"hash/crc32"
+	"io/ioutil"
 	"net"
 	"sort"
 	"strconv"
@@ -14,6 +15,7 @@ import (
 	"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
@@ -28,6 +30,7 @@ type Birc struct {
 	Local                                     chan config.Message // local queue for flood control
 	FirstConnection, authDone                 bool
 	MessageDelay, MessageQueue, MessageLength int
+	channels                                  map[string]bool
 
 	*bridge.Config
 }
@@ -38,6 +41,8 @@ func New(cfg *bridge.Config) bridge.Bridger {
 	b.Nick = b.GetString("Nick")
 	b.names = make(map[string][]string)
 	b.connected = make(chan error)
+	b.channels = make(map[string]bool)
+
 	if b.GetInt("MessageDelay") == 0 {
 		b.MessageDelay = 1300
 	} else {
@@ -110,6 +115,7 @@ func (b *Birc) Disconnect() error {
 }
 
 func (b *Birc) JoinChannel(channel config.ChannelInfo) error {
+	b.channels[channel.Name] = true
 	// need to check if we have nickserv auth done before joining channels
 	for {
 		if b.authDone {
@@ -137,6 +143,7 @@ func (b *Birc) Send(msg config.Message) (string, error) {
 	// 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
@@ -155,6 +162,10 @@ func (b *Birc) Send(msg config.Message) (string, error) {
 	}
 
 	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 {
@@ -166,12 +177,8 @@ func (b *Birc) Send(msg config.Message) (string, error) {
 			return "", nil
 		}
 
-		b.Local <- config.Message{
-			Text:     msgLines[i],
-			Username: msg.Username,
-			Channel:  msg.Channel,
-			Event:    msg.Event,
-		}
+		msg.Text = msgLines[i]
+		b.Local <- msg
 	}
 	return "", nil
 }
@@ -198,22 +205,58 @@ func (b *Birc) doConnect() {
 	}
 }
 
+// Sanitize nicks for RELAYMSG: replace IRC characters with special meanings with "-"
+func sanitizeNick(nick string) string {
+	sanitize := func(r rune) rune {
+		if strings.ContainsRune("!+%@&#$:'\"?*,. ", r) {
+			return '-'
+		}
+		return r
+	}
+	return strings.Map(sanitize, nick)
+}
+
 func (b *Birc) doSend() {
 	rate := time.Millisecond * time.Duration(b.MessageDelay)
 	throttle := time.NewTicker(rate)
 	for msg := range b.Local {
 		<-throttle.C
 		username := msg.Username
-		if b.GetBool("Colornicks") {
-			checksum := crc32.ChecksumIEEE([]byte(msg.Username))
-			colorCode := checksum%14 + 2 // quick fix - prevent white or black color codes
-			username = fmt.Sprintf("\x03%02d%s\x0F", colorCode, msg.Username)
-		}
-		if msg.Event == config.EventUserAction {
-			b.i.Cmd.Action(msg.Channel, username+msg.Text)
+		// Optional support for the proposed RELAYMSG extension, described at
+		// https://github.com/jlu5/ircv3-specifications/blob/master/extensions/relaymsg.md
+		// nolint:nestif
+		if (b.i.HasCapability("overdrivenetworks.com/relaymsg") || b.i.HasCapability("draft/relaymsg")) &&
+			b.GetBool("UseRelayMsg") {
+			username = sanitizeNick(username)
+			text := msg.Text
+
+			// Work around girc chomping leading commas on single word messages?
+			if strings.HasPrefix(text, ":") && !strings.ContainsRune(text, ' ') {
+				text = ":" + text
+			}
+
+			if msg.Event == config.EventUserAction {
+				b.i.Cmd.SendRawf("RELAYMSG %s %s :\x01ACTION %s\x01", msg.Channel, username, text) //nolint:errcheck
+			} else {
+				b.Log.Debugf("Sending RELAYMSG to channel %s: nick=%s", msg.Channel, username)
+				b.i.Cmd.SendRawf("RELAYMSG %s %s :%s", msg.Channel, username, text) //nolint:errcheck
+			}
 		} else {
-			b.Log.Debugf("Sending to channel %s", msg.Channel)
-			b.i.Cmd.Message(msg.Channel, username+msg.Text)
+			if b.GetBool("Colornicks") {
+				checksum := crc32.ChecksumIEEE([]byte(msg.Username))
+				colorCode := checksum%14 + 2 // quick fix - prevent white or black color codes
+				username = fmt.Sprintf("\x03%02d%s\x0F", colorCode, msg.Username)
+			}
+			switch msg.Event {
+			case config.EventUserAction:
+				b.i.Cmd.Action(msg.Channel, username+msg.Text)
+			case config.EventNoticeIRC:
+				b.Log.Debugf("Sending notice to channel %s", msg.Channel)
+				b.i.Cmd.Notice(msg.Channel, username+msg.Text)
+			default:
+				b.Log.Debugf("Sending to channel %s", msg.Channel)
+				b.i.Cmd.Message(msg.Channel, username+msg.Text)
+			}
 		}
 	}
 }
@@ -231,13 +274,25 @@ func (b *Birc) getClient() (*girc.Client, error) {
 	// fix strict user handling of girc
 	user := b.GetString("Nick")
 	for !girc.IsValidUser(user) {
-		if len(user) == 1 {
+		if len(user) == 1 || len(user) == 0 {
 			user = "matterbridge"
 			break
 		}
 		user = user[1:]
 	}
 
+	debug := ioutil.Discard
+	if b.GetInt("DebugLevel") == 2 {
+		debug = b.Log.Writer()
+	}
+
+	pingDelay, err := time.ParseDuration(b.GetString("pingdelay"))
+	if err != nil || pingDelay == 0 {
+		pingDelay = time.Minute
+	}
+
+	b.Log.Debugf("setting pingdelay to %s", pingDelay)
+
 	i := girc.New(girc.Config{
 		Server:     server,
 		ServerPass: b.GetString("Password"),
@@ -247,7 +302,11 @@ func (b *Birc) getClient() (*girc.Client, error) {
 		Name:       b.GetString("Nick"),
 		SSL:        b.GetBool("UseTLS"),
 		TLSConfig:  &tls.Config{InsecureSkipVerify: b.GetBool("SkipTLSVerify"), ServerName: server}, //nolint:gosec
-		PingDelay:  time.Minute,
+		PingDelay:  pingDelay,
+		// skip gIRC internal rate limiting, since we have our own throttling
+		AllowFlood:    true,
+		Debug:         debug,
+		SupportedCaps: map[string][]string{"overdrivenetworks.com/relaymsg": nil, "draft/relaymsg": nil},
 	})
 	return i, nil
 }
@@ -273,7 +332,7 @@ func (b *Birc) skipPrivMsg(event girc.Event) bool {
 	b.Nick = b.i.GetNick()
 
 	// freenode doesn't send 001 as first reply
-	if event.Command == "NOTICE" {
+	if event.Command == "NOTICE" && len(event.Params) != 2 {
 		return true
 	}
 	// don't forward queries to the bot
@@ -284,6 +343,15 @@ func (b *Birc) skipPrivMsg(event girc.Event) bool {
 	if event.Source.Name == b.Nick {
 		return true
 	}
+	// don't forward messages we sent via RELAYMSG
+	if relayedNick, ok := event.Tags.Get("draft/relaymsg"); ok && relayedNick == b.Nick {
+		return true
+	}
+	// This is the old name of the cap sent in spoofed messages; I've kept this in
+	// for compatibility reasons
+	if relayedNick, ok := event.Tags.Get("relaymsg"); ok && relayedNick == b.Nick {
+		return true
+	}
 	return false
 }
 

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

@@ -0,0 +1,215 @@
+package bmatrix
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"html"
+	"strings"
+	"time"
+
+	matrix "github.com/matrix-org/gomatrix"
+)
+
+func newMatrixUsername(username string) *matrixUsername {
+	mUsername := new(matrixUsername)
+
+	// check if we have a </tag>. if we have, we don't escape HTML. #696
+	if htmlTag.MatchString(username) {
+		mUsername.formatted = username
+		// remove the HTML formatting for beautiful push messages #1188
+		mUsername.plain = htmlReplacementTag.ReplaceAllString(username, "")
+	} else {
+		mUsername.formatted = html.EscapeString(username)
+		mUsername.plain = username
+	}
+
+	return mUsername
+}
+
+// getRoomID retrieves a matching room ID from the channel name.
+func (b *Bmatrix) getRoomID(channel string) string {
+	b.RLock()
+	defer b.RUnlock()
+	for ID, name := range b.RoomMap {
+		if name == channel {
+			return ID
+		}
+	}
+
+	return ""
+}
+
+// interface2Struct marshals and immediately unmarshals an interface.
+// Useful for converting map[string]interface{} to a struct.
+func interface2Struct(in interface{}, out interface{}) error {
+	jsonObj, err := json.Marshal(in)
+	if err != nil {
+		return err //nolint:wrapcheck
+	}
+
+	return json.Unmarshal(jsonObj, out)
+}
+
+// getDisplayName retrieves the displayName for mxid, querying the homserver if the mxid is not in the cache.
+func (b *Bmatrix) getDisplayName(mxid string) string {
+	if b.GetBool("UseUserName") {
+		return mxid[1:]
+	}
+
+	b.RLock()
+	if val, present := b.NicknameMap[mxid]; present {
+		b.RUnlock()
+
+		return val.displayName
+	}
+	b.RUnlock()
+
+	displayName, err := b.mc.GetDisplayName(mxid)
+	var httpError *matrix.HTTPError
+	if errors.As(err, &httpError) {
+		b.Log.Warnf("Couldn't retrieve the display name for %s", mxid)
+	}
+
+	if err != nil {
+		return b.cacheDisplayName(mxid, mxid[1:])
+	}
+
+	return b.cacheDisplayName(mxid, displayName.DisplayName)
+}
+
+// cacheDisplayName stores the mapping between a mxid and a display name, to be reused later without performing a query to the homserver.
+// Note that old entries are cleaned when this function is called.
+func (b *Bmatrix) cacheDisplayName(mxid string, displayName string) string {
+	now := time.Now()
+
+	// scan to delete old entries, to stop memory usage from becoming too high with old entries.
+	// In addition, we also detect if another user have the same username, and if so, we append their mxids to their usernames to differentiate them.
+	toDelete := []string{}
+	conflict := false
+
+	b.Lock()
+	for mxid, v := range b.NicknameMap {
+		// to prevent username reuse across matrix servers - or even on the same server, append
+		// the mxid to the username when there is a conflict
+		if v.displayName == displayName {
+			conflict = true
+			// TODO: it would be nice to be able to rename previous messages from this user.
+			// The current behavior is that only users with clashing usernames and *that have spoken since the bridge last started* will get their mxids shown, and I don't know if that's the expected behavior.
+			v.displayName = fmt.Sprintf("%s (%s)", displayName, mxid)
+			b.NicknameMap[mxid] = v
+		}
+
+		if now.Sub(v.lastUpdated) > 10*time.Minute {
+			toDelete = append(toDelete, mxid)
+		}
+	}
+
+	if conflict {
+		displayName = fmt.Sprintf("%s (%s)", displayName, mxid)
+	}
+
+	for _, v := range toDelete {
+		delete(b.NicknameMap, v)
+	}
+
+	b.NicknameMap[mxid] = NicknameCacheEntry{
+		displayName: displayName,
+		lastUpdated: now,
+	}
+	b.Unlock()
+
+	return displayName
+}
+
+// handleError converts errors into httpError.
+//nolint:exhaustivestruct
+func handleError(err error) *httpError {
+	var mErr matrix.HTTPError
+	if !errors.As(err, &mErr) {
+		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
+}
+
+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 {
+	urlPath := b.mc.BuildURL("profile", sender, "avatar_url")
+
+	s := struct {
+		AvatarURL string `json:"avatar_url"`
+	}{}
+
+	err := b.mc.MakeRequest("GET", urlPath, nil, &s)
+	if err != nil {
+		b.Log.Errorf("getAvatarURL failed: %s", err)
+
+		return ""
+	}
+
+	url := strings.ReplaceAll(s.AvatarURL, "mxc://", b.GetString("Server")+"/_matrix/media/r0/thumbnail/")
+	if url != "" {
+		url += "?width=37&height=37&method=crop"
+	}
+
+	return url
+}
+
+// handleRatelimit handles the ratelimit errors and return if we're ratelimited and the amount of time to sleep
+func (b *Bmatrix) handleRatelimit(err error) (time.Duration, bool) {
+	httpErr := handleError(err)
+	if httpErr.Errcode != "M_LIMIT_EXCEEDED" {
+		return 0, false
+	}
+
+	b.Log.Debugf("ratelimited: %s", httpErr.Err)
+	b.Log.Infof("getting ratelimited by matrix, sleeping approx %d seconds before retrying", httpErr.RetryAfterMs/1000)
+
+	return time.Duration(httpErr.RetryAfterMs) * time.Millisecond, true
+}
+
+// retry function will check if we're ratelimited and retries again when backoff time expired
+// returns original error if not 429 ratelimit
+func (b *Bmatrix) retry(f func() error) error {
+	b.rateMutex.Lock()
+	defer b.rateMutex.Unlock()
+
+	for {
+		if err := f(); err != nil {
+			if backoff, ok := b.handleRatelimit(err); ok {
+				time.Sleep(backoff)
+			} else {
+				return err
+			}
+		} else {
+			return nil
+		}
+	}
+}

bridge/matrix/matrix.go

@@ -3,31 +3,72 @@ package bmatrix
 import (
 	"bytes"
 	"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"
+	matrix "github.com/matrix-org/gomatrix"
 )
 
+var (
+	htmlTag            = regexp.MustCompile("</.*?>")
+	htmlReplacementTag = regexp.MustCompile("<[^>]*>")
+)
+
+type NicknameCacheEntry struct {
+	displayName string
+	lastUpdated time.Time
+}
+
 type Bmatrix struct {
-	mc      *matrix.Client
-	UserID  string
-	RoomMap map[string]string
+	mc          *matrix.Client
+	UserID      string
+	NicknameMap map[string]NicknameCacheEntry
+	RoomMap     map[string]string
+	rateMutex   sync.RWMutex
 	sync.RWMutex
-	htmlTag *regexp.Regexp
 	*bridge.Config
 }
 
+type httpError struct {
+	Errcode      string `json:"errcode"`
+	Err          string `json:"error"`
+	RetryAfterMs int    `json:"retry_after_ms"`
+}
+
+type matrixUsername struct {
+	plain     string
+	formatted string
+}
+
+// SubTextMessage represents the new content of the message in edit messages.
+type SubTextMessage struct {
+	MsgType string `json:"msgtype"`
+	Body    string `json:"body"`
+}
+
+// MessageRelation explains how the current message relates to a previous message.
+// Notably used for message edits.
+type MessageRelation struct {
+	EventID string `json:"event_id"`
+	Type    string `json:"rel_type"`
+}
+
+type EditedMessage struct {
+	NewContent SubTextMessage  `json:"m.new_content"`
+	RelatedTo  MessageRelation `json:"m.relates_to"`
+	matrix.TextMessage
+}
+
 func New(cfg *bridge.Config) bridge.Bridger {
 	b := &Bmatrix{Config: cfg}
-	b.htmlTag = regexp.MustCompile("</.*?>")
 	b.RoomMap = make(map[string]string)
+	b.NicknameMap = make(map[string]NicknameCacheEntry)
 	return b
 }
 
@@ -39,9 +80,10 @@ func (b *Bmatrix) Connect() error {
 		return err
 	}
 	resp, err := b.mc.Login(&matrix.ReqLogin{
-		Type:     "m.login.password",
-		User:     b.GetString("Login"),
-		Password: b.GetString("Password"),
+		Type:       "m.login.password",
+		User:       b.GetString("Login"),
+		Password:   b.GetString("Password"),
+		Identifier: matrix.NewUserIdentifier(b.GetString("Login")),
 	})
 	if err != nil {
 		return err
@@ -58,14 +100,18 @@ func (b *Bmatrix) Disconnect() error {
 }
 
 func (b *Bmatrix) JoinChannel(channel config.ChannelInfo) error {
-	resp, err := b.mc.JoinRoom(channel.Name, "", nil)
-	if err != nil {
-		return err
-	}
-	b.Lock()
-	b.RoomMap[resp.RoomID] = channel.Name
-	b.Unlock()
-	return err
+	return b.retry(func() error {
+		resp, err := b.mc.JoinRoom(channel.Name, "", nil)
+		if err != nil {
+			return err
+		}
+
+		b.Lock()
+		b.RoomMap[resp.RoomID] = channel.Name
+		b.Unlock()
+
+		return nil
+	})
 }
 
 func (b *Bmatrix) Send(msg config.Message) (string, error) {
@@ -74,17 +120,30 @@ func (b *Bmatrix) Send(msg config.Message) (string, error) {
 	channel := b.getRoomID(msg.Channel)
 	b.Log.Debugf("Channel %s maps to channel id %s", msg.Channel, channel)
 
+	username := newMatrixUsername(msg.Username)
+
 	// Make a action /me of the message
 	if msg.Event == config.EventUserAction {
 		m := matrix.TextMessage{
-			MsgType: "m.emote",
-			Body:    msg.Username + msg.Text,
+			MsgType:       "m.emote",
+			Body:          username.plain + msg.Text,
+			FormattedBody: username.formatted + msg.Text,
 		}
-		resp, err := b.mc.SendMessageEvent(channel, "m.room.message", m)
-		if err != nil {
-			return "", err
-		}
-		return resp.EventID, err
+
+		msgID := ""
+
+		err := b.retry(func() error {
+			resp, err := b.mc.SendMessageEvent(channel, "m.room.message", m)
+			if err != nil {
+				return err
+			}
+
+			msgID = resp.EventID
+
+			return err
+		})
+
+		return msgID, err
 	}
 
 	// Delete message
@@ -92,17 +151,34 @@ func (b *Bmatrix) Send(msg config.Message) (string, error) {
 		if msg.ID == "" {
 			return "", nil
 		}
-		resp, err := b.mc.RedactEvent(channel, msg.ID, &matrix.ReqRedact{})
-		if err != nil {
-			return "", err
-		}
-		return resp.EventID, err
+
+		msgID := ""
+
+		err := b.retry(func() error {
+			resp, err := b.mc.RedactEvent(channel, msg.ID, &matrix.ReqRedact{})
+			if err != nil {
+				return err
+			}
+
+			msgID = resp.EventID
+
+			return err
+		})
+
+		return msgID, 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 {
+			rmsg := rmsg
+
+			err := b.retry(func() error {
+				_, err := b.mc.SendText(channel, rmsg.Username+rmsg.Text)
+
+				return err
+			})
+			if err != nil {
 				b.Log.Errorf("sendText failed: %s", err)
 			}
 		}
@@ -113,45 +189,105 @@ func (b *Bmatrix) Send(msg config.Message) (string, error) {
 	}
 
 	// Edit message if we have an ID
-	// matrix has no editing support
+	if msg.ID != "" {
+		rmsg := EditedMessage{TextMessage: matrix.TextMessage{
+			Body:    username.plain + msg.Text,
+			MsgType: "m.text",
+		}}
+		if b.GetBool("HTMLDisable") {
+			rmsg.TextMessage.FormattedBody = username.formatted + "* " + msg.Text
+		} else {
+			rmsg.Format = "org.matrix.custom.html"
+			rmsg.TextMessage.FormattedBody = username.formatted + "* " + helper.ParseMarkdown(msg.Text)
+		}
+		rmsg.NewContent = SubTextMessage{
+			Body:    rmsg.TextMessage.Body,
+			MsgType: "m.text",
+		}
+		rmsg.RelatedTo = MessageRelation{
+			EventID: msg.ID,
+			Type:    "m.replace",
+		}
 
-	// Use notices to send join/leave events
-	if msg.Event == config.EventJoinLeave {
-		resp, err := b.mc.SendNotice(channel, msg.Username+msg.Text)
+		err := b.retry(func() error {
+			_, err := b.mc.SendMessageEvent(channel, "m.room.message", rmsg)
+
+			return err
+		})
 		if err != nil {
 			return "", err
 		}
+
+		return msg.ID, nil
+	}
+
+	// Use notices to send join/leave events
+	if msg.Event == config.EventJoinLeave {
+		m := matrix.TextMessage{
+			MsgType:       "m.notice",
+			Body:          username.plain + msg.Text,
+			FormattedBody: username.formatted + msg.Text,
+		}
+
+		var (
+			resp *matrix.RespSendEvent
+			err  error
+		)
+
+		err = b.retry(func() error {
+			resp, err = b.mc.SendMessageEvent(channel, "m.room.message", m)
+
+			return err
+		})
+		if err != nil {
+			return "", err
+		}
+
 		return resp.EventID, err
 	}
 
-	username := html.EscapeString(msg.Username)
-	// check if we have a </tag>. if we have, we don't escape HTML. #696
-	if b.htmlTag.MatchString(msg.Username) {
-		username = msg.Username
+	if b.GetBool("HTMLDisable") {
+		var (
+			resp *matrix.RespSendEvent
+			err  error
+		)
+
+		err = b.retry(func() error {
+			resp, err = b.mc.SendText(channel, username.plain+msg.Text)
+
+			return err
+		})
+		if err != nil {
+			return "", err
+		}
+
+		return resp.EventID, err
 	}
+
 	// Post normal message with HTML support (eg riot.im)
-	resp, err := b.mc.SendHTML(channel, msg.Username+msg.Text, username+helper.ParseMarkdown(msg.Text))
+	var (
+		resp *matrix.RespSendEvent
+		err  error
+	)
+
+	err = b.retry(func() error {
+		resp, err = b.mc.SendFormattedText(channel, username.plain+msg.Text,
+			username.formatted+helper.ParseMarkdown(msg.Text))
+
+		return err
+	})
 	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 ""
+	return resp.EventID, err
 }
 
 func (b *Bmatrix) handlematrix() {
 	syncer := b.mc.Syncer.(*matrix.DefaultSyncer)
 	syncer.OnEventType("m.room.redaction", b.handleEvent)
 	syncer.OnEventType("m.room.message", b.handleEvent)
+	syncer.OnEventType("m.room.member", b.handleMemberChange)
 	go func() {
 		for {
 			if err := b.mc.Sync(); err != nil {
@@ -161,6 +297,45 @@ func (b *Bmatrix) handlematrix() {
 	}()
 }
 
+func (b *Bmatrix) handleEdit(ev *matrix.Event, rmsg config.Message) bool {
+	relationInterface, present := ev.Content["m.relates_to"]
+	newContentInterface, present2 := ev.Content["m.new_content"]
+	if !(present && present2) {
+		return false
+	}
+
+	var relation MessageRelation
+	if err := interface2Struct(relationInterface, &relation); err != nil {
+		b.Log.Warnf("Couldn't parse 'm.relates_to' object with value %#v", relationInterface)
+		return false
+	}
+
+	var newContent SubTextMessage
+	if err := interface2Struct(newContentInterface, &newContent); err != nil {
+		b.Log.Warnf("Couldn't parse 'm.new_content' object with value %#v", newContentInterface)
+		return false
+	}
+
+	if relation.Type != "m.replace" {
+		return false
+	}
+
+	rmsg.ID = relation.EventID
+	rmsg.Text = newContent.Body
+	b.Remote <- rmsg
+
+	return true
+}
+
+func (b *Bmatrix) handleMemberChange(ev *matrix.Event) {
+	// Update the displayname on join messages, according to https://matrix.org/docs/spec/client_server/r0.6.1#events-on-change-of-profile-information
+	if ev.Content["membership"] == "join" {
+		if dn, ok := ev.Content["displayname"].(string); ok {
+			b.cacheDisplayName(ev.Sender, dn)
+		}
+	}
+}
+
 func (b *Bmatrix) handleEvent(ev *matrix.Event) {
 	b.Log.Debugf("== Receiving event: %#v", ev)
 	if ev.Sender != b.UserID {
@@ -172,10 +347,15 @@ func (b *Bmatrix) handleEvent(ev *matrix.Event) {
 			return
 		}
 
-		// TODO download avatar
-
 		// Create our message
-		rmsg := config.Message{Username: ev.Sender[1:], Channel: channel, Account: b.Account, UserID: ev.Sender, ID: ev.ID}
+		rmsg := config.Message{
+			Username: b.getDisplayName(ev.Sender),
+			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 {
@@ -204,6 +384,11 @@ func (b *Bmatrix) handleEvent(ev *matrix.Event) {
 			rmsg.Event = config.EventUserAction
 		}
 
+		// Is it an edit?
+		if b.handleEdit(ev, rmsg) {
+			return
+		}
+
 		// Do we have attachments
 		if b.containsAttachment(ev.Content) {
 			err := b.handleDownloadFile(&rmsg, ev.Content)
@@ -214,6 +399,11 @@ func (b *Bmatrix) handleEvent(ev *matrix.Event) {
 
 		b.Log.Debugf("<= Sending message from %s on %s to gateway", ev.Sender, b.Account)
 		b.Remote <- rmsg
+
+		// not crucial, so no ratelimit check here
+		if err := b.mc.MarkRead(ev.RoomID, ev.ID); err != nil {
+			b.Log.Errorf("couldn't mark message as read %s", err.Error())
+		}
 	}
 }
 
@@ -288,26 +478,30 @@ func (b *Bmatrix) handleUploadFiles(msg *config.Message, channel string) (string
 
 // handleUploadFile handles native upload of a file.
 func (b *Bmatrix) handleUploadFile(msg *config.Message, channel string, fi *config.FileInfo) {
+	username := newMatrixUsername(msg.Username)
 	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") {
-		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)
-		}
+	// image and video uploads send no username, we have to do this ourself here #715
+	err := b.retry(func() error {
+		_, err := b.mc.SendFormattedText(channel, username.plain+fi.Comment, username.formatted+fi.Comment)
+
+		return err
+	})
+	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)))
+
+	var res *matrix.RespMediaUpload
+
+	err = b.retry(func() error {
+		res, err = b.mc.UploadToContentRepo(content, mtype, int64(len(*fi.Data)))
+
+		return err
+	})
+
 	if err != nil {
 		b.Log.Errorf("file upload failed: %#v", err)
 		return
@@ -316,32 +510,60 @@ func (b *Bmatrix) handleUploadFile(msg *config.Message, channel string, fi *conf
 	switch {
 	case strings.Contains(mtype, "video"):
 		b.Log.Debugf("sendVideo %s", res.ContentURI)
-		_, err = b.mc.SendVideo(channel, fi.Name, res.ContentURI)
+		err = b.retry(func() error {
+			_, err = b.mc.SendVideo(channel, fi.Name, res.ContentURI)
+
+			return err
+		})
 		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)
+		err = b.retry(func() error {
+			_, err = b.mc.SendImage(channel, fi.Name, res.ContentURI)
+
+			return err
+		})
 		if err != nil {
 			b.Log.Errorf("sendImage failed: %#v", err)
 		}
+	case strings.Contains(mtype, "audio"):
+		b.Log.Debugf("sendAudio %s", res.ContentURI)
+		err = b.retry(func() error {
+			_, err = b.mc.SendMessageEvent(channel, "m.room.message", matrix.AudioMessage{
+				MsgType: "m.audio",
+				Body:    fi.Name,
+				URL:     res.ContentURI,
+				Info: matrix.AudioInfo{
+					Mimetype: mtype,
+					Size:     uint(len(*fi.Data)),
+				},
+			})
+
+			return err
+		})
+		if err != nil {
+			b.Log.Errorf("sendAudio failed: %#v", err)
+		}
+	default:
+		b.Log.Debugf("sendFile %s", res.ContentURI)
+		err = b.retry(func() error {
+			_, err = b.mc.SendMessageEvent(channel, "m.room.message", matrix.FileMessage{
+				MsgType: "m.file",
+				Body:    fi.Name,
+				URL:     res.ContentURI,
+				Info: matrix.FileInfo{
+					Mimetype: mtype,
+					Size:     uint(len(*fi.Data)),
+				},
+			})
+
+			return err
+		})
+		if err != nil {
+			b.Log.Errorf("sendFile 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
-}

bridge/matrix/matrix_test.go

@@ -0,0 +1,28 @@
+package bmatrix
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPlainUsername(t *testing.T) {
+	uut := newMatrixUsername("MyUser")
+
+	assert.Equal(t, "MyUser", uut.formatted)
+	assert.Equal(t, "MyUser", uut.plain)
+}
+
+func TestHTMLUsername(t *testing.T) {
+	uut := newMatrixUsername("<b>MyUser</b>")
+
+	assert.Equal(t, "<b>MyUser</b>", uut.formatted)
+	assert.Equal(t, "MyUser", uut.plain)
+}
+
+func TestFancyUsername(t *testing.T) {
+	uut := newMatrixUsername("<MyUser>")
+
+	assert.Equal(t, "&lt;MyUser&gt;", uut.formatted)
+	assert.Equal(t, "<MyUser>", uut.plain)
+}

bridge/mattermost/handlers.go

@@ -4,7 +4,7 @@ import (
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/42wim/matterbridge/matterclient"
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 // handleDownloadAvatar downloads the avatar of userid from channel
@@ -66,6 +66,10 @@ func (b *Bmattermost) handleMatter() {
 		} 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
@@ -104,7 +108,7 @@ func (b *Bmattermost) handleMatterClient(messages chan *config.Message) {
 			Channel:  message.Channel,
 			Text:     message.Text,
 			ID:       message.Post.Id,
-			ParentID: message.Post.ParentId,
+			ParentID: message.Post.RootId, // ParentID is obsolete with mattermost
 			Extra:    make(map[string][]interface{}),
 		}
 

bridge/mattermost/helpers.go

@@ -7,7 +7,7 @@ import (
 	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/42wim/matterbridge/matterclient"
 	"github.com/42wim/matterbridge/matterhook"
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 func (b *Bmattermost) doConnectWebhookBind() error {
@@ -70,6 +70,7 @@ func (b *Bmattermost) apiLogin() error {
 		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()
@@ -186,6 +187,12 @@ func (b *Bmattermost) skipMessage(message *matterclient.Message) bool {
 		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 {

bridge/mattermost/mattermost.go

@@ -121,6 +121,21 @@ func (b *Bmattermost) Send(msg config.Message) (string, error) {
 		return msg.ID, b.mc.DeleteMessage(msg.ID)
 	}
 
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentNotFound() {
+		msg.ParentID = ""
+		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
+	}
+
+	// we only can reply to the root of the thread, not to a specific ID (like discord for example does)
+	if msg.ParentID != "" {
+		post, res := b.mc.Client.GetPost(msg.ParentID, "")
+		if res.Error != nil {
+			b.Log.Errorf("getting post %s failed: %s", msg.ParentID, res.Error.DetailedError)
+		}
+		msg.ParentID = post.RootId
+	}
+
 	// Upload a file if it exists
 	if msg.Extra != nil {
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {

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,227 @@
+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.ParentValid() {
+		return b.sendReply(msg)
+	}
+
+	// Handle prefix hint for unthreaded messages.
+	if msg.ParentNotFound() {
+		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/mumble/handlers.go

@@ -0,0 +1,96 @@
+package bmumble
+
+import (
+	"strconv"
+	"time"
+
+	"layeh.com/gumble/gumble"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+)
+
+func (b *Bmumble) handleServerConfig(event *gumble.ServerConfigEvent) {
+	b.serverConfigUpdate <- *event
+}
+
+func (b *Bmumble) handleTextMessage(event *gumble.TextMessageEvent) {
+	sender := "unknown"
+	if event.TextMessage.Sender != nil {
+		sender = event.TextMessage.Sender.Name
+	}
+	// If the text message is received before receiving a ServerSync
+	// and UserState, Client.Self or Self.Channel are nil
+	if event.Client.Self == nil || event.Client.Self.Channel == nil {
+		b.Log.Warn("Connection bootstrap not finished, discarding text message")
+		return
+	}
+	// Convert Mumble HTML messages to markdown
+	parts, err := b.convertHTMLtoMarkdown(event.TextMessage.Message)
+	if err != nil {
+		b.Log.Error(err)
+	}
+	now := time.Now().UTC()
+	for i, part := range parts {
+		// Construct matterbridge message and pass on to the gateway
+		rmsg := config.Message{
+			Channel:  strconv.FormatUint(uint64(event.Client.Self.Channel.ID), 10),
+			Username: sender,
+			UserID:   sender + "@" + b.Host,
+			Account:  b.Account,
+		}
+		if part.Image == nil {
+			rmsg.Text = part.Text
+		} else {
+			fname := b.Account + "_" + strconv.FormatInt(now.UnixNano(), 10) + "_" + strconv.Itoa(i) + part.FileExtension
+			rmsg.Extra = make(map[string][]interface{})
+			if err = helper.HandleDownloadSize(b.Log, &rmsg, fname, int64(len(part.Image)), b.General); err != nil {
+				b.Log.WithError(err).Warn("not including image in message")
+				continue
+			}
+			helper.HandleDownloadData(b.Log, &rmsg, fname, "", "", &part.Image, b.General)
+		}
+		b.Log.Debugf("Sending message to gateway: %+v", rmsg)
+		b.Remote <- rmsg
+	}
+}
+
+func (b *Bmumble) handleConnect(event *gumble.ConnectEvent) {
+	// Set the user's "bio"/comment
+	if comment := b.GetString("UserComment"); comment != "" && event.Client.Self != nil {
+		event.Client.Self.SetComment(comment)
+	}
+	// No need to talk or listen
+	event.Client.Self.SetSelfDeafened(true)
+	event.Client.Self.SetSelfMuted(true)
+	// if the Channel variable is set, this is a reconnect -> rejoin channel
+	if b.Channel != nil {
+		if err := b.doJoin(event.Client, *b.Channel); err != nil {
+			b.Log.Error(err)
+		}
+		b.Remote <- config.Message{
+			Username: "system",
+			Text:     "rejoin",
+			Channel:  "",
+			Account:  b.Account,
+			Event:    config.EventRejoinChannels,
+		}
+	}
+}
+
+func (b *Bmumble) handleUserChange(event *gumble.UserChangeEvent) {
+	// Only care about changes to self
+	if event.User != event.Client.Self {
+		return
+	}
+	// Someone attempted to move the user out of the configured channel; attempt to join back
+	if b.Channel != nil {
+		if err := b.doJoin(event.Client, *b.Channel); err != nil {
+			b.Log.Error(err)
+		}
+	}
+}
+
+func (b *Bmumble) handleDisconnect(event *gumble.DisconnectEvent) {
+	b.connected <- *event
+}

bridge/mumble/helpers.go

@@ -0,0 +1,143 @@
+package bmumble
+
+import (
+	"fmt"
+	"mime"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/mattn/godown"
+	"github.com/vincent-petithory/dataurl"
+)
+
+type MessagePart struct {
+	Text          string
+	FileExtension string
+	Image         []byte
+}
+
+func (b *Bmumble) decodeImage(uri string, parts *[]MessagePart) error {
+	// Decode the data:image/... URI
+	image, err := dataurl.DecodeString(uri)
+	if err != nil {
+		b.Log.WithError(err).Info("No image extracted")
+		return err
+	}
+	// Determine the file extensions for that image
+	ext, err := mime.ExtensionsByType(image.MediaType.ContentType())
+	if err != nil || len(ext) == 0 {
+		b.Log.WithError(err).Infof("No file extension registered for MIME type '%s'", image.MediaType.ContentType())
+		return err
+	}
+	// Add the image to the MessagePart slice
+	*parts = append(*parts, MessagePart{"", ext[0], image.Data})
+	return nil
+}
+
+func (b *Bmumble) tokenize(t *string) ([]MessagePart, error) {
+	// `^(.*?)` matches everything before the image
+	// `!\[[^\]]*\]\(` matches the `![alt](` part of markdown images
+	// `(data:image\/[^)]+)` matches the data: URI used by Mumble
+	// `\)` matches the closing parenthesis after the URI
+	// `(.*)$` matches the remaining text to be examined in the next iteration
+	p := regexp.MustCompile(`^(?ms)(.*?)!\[[^\]]*\]\((data:image\/[^)]+)\)(.*)$`)
+	remaining := *t
+	var parts []MessagePart
+	for {
+		tokens := p.FindStringSubmatch(remaining)
+		if tokens == nil {
+			// no match -> remaining string is non-image text
+			pre := strings.TrimSpace(remaining)
+			if len(pre) > 0 {
+				parts = append(parts, MessagePart{pre, "", nil})
+			}
+			return parts, nil
+		}
+
+		// tokens[1] is the text before the image
+		if len(tokens[1]) > 0 {
+			pre := strings.TrimSpace(tokens[1])
+			parts = append(parts, MessagePart{pre, "", nil})
+		}
+		// tokens[2] is the image URL
+		uri, err := dataurl.UnescapeToString(strings.TrimSpace(strings.ReplaceAll(tokens[2], " ", "")))
+		if err != nil {
+			b.Log.WithError(err).Info("URL unescaping failed")
+			remaining = strings.TrimSpace(tokens[3])
+			continue
+		}
+		err = b.decodeImage(uri, &parts)
+		if err != nil {
+			b.Log.WithError(err).Info("Decoding the image failed")
+		}
+		// tokens[3] is the text after the image, processed in the next iteration
+		remaining = strings.TrimSpace(tokens[3])
+	}
+}
+
+func (b *Bmumble) convertHTMLtoMarkdown(html string) ([]MessagePart, error) {
+	var sb strings.Builder
+	err := godown.Convert(&sb, strings.NewReader(html), nil)
+	if err != nil {
+		return nil, err
+	}
+	markdown := sb.String()
+	b.Log.Debugf("### to markdown: %s", markdown)
+	return b.tokenize(&markdown)
+}
+
+func (b *Bmumble) extractFiles(msg *config.Message) []config.Message {
+	var messages []config.Message
+	if msg.Extra == nil || len(msg.Extra["file"]) == 0 {
+		return messages
+	}
+	// Create a separate message for each file
+	for _, f := range msg.Extra["file"] {
+		fi := f.(config.FileInfo)
+		imsg := config.Message{
+			Channel:   msg.Channel,
+			Username:  msg.Username,
+			UserID:    msg.UserID,
+			Account:   msg.Account,
+			Protocol:  msg.Protocol,
+			Timestamp: msg.Timestamp,
+			Event:     "mumble_image",
+		}
+		// If no data is present for the file, send a link instead
+		if fi.Data == nil || len(*fi.Data) == 0 {
+			if len(fi.URL) > 0 {
+				imsg.Text = fmt.Sprintf(`<a href="%s">%s</a>`, fi.URL, fi.URL)
+				messages = append(messages, imsg)
+			} else {
+				b.Log.Infof("Not forwarding file without local data")
+			}
+			continue
+		}
+		mimeType := http.DetectContentType(*fi.Data)
+		// Mumble only supports images natively, send a link instead
+		if !strings.HasPrefix(mimeType, "image/") {
+			if len(fi.URL) > 0 {
+				imsg.Text = fmt.Sprintf(`<a href="%s">%s</a>`, fi.URL, fi.URL)
+				messages = append(messages, imsg)
+			} else {
+				b.Log.Infof("Not forwarding file of type %s", mimeType)
+			}
+			continue
+		}
+		mimeType = strings.TrimSpace(strings.Split(mimeType, ";")[0])
+		// Build data:image/...;base64,... style image URL and embed image directly into the message
+		du := dataurl.New(*fi.Data, mimeType)
+		dataURL, err := du.MarshalText()
+		if err != nil {
+			b.Log.WithError(err).Infof("Image Serialization into data URL failed (type: %s, length: %d)", mimeType, len(*fi.Data))
+			continue
+		}
+		imsg.Text = fmt.Sprintf(`<img src="%s"/>`, dataURL)
+		messages = append(messages, imsg)
+	}
+	// Remove files from original message
+	msg.Extra["file"] = nil
+	return messages
+}

bridge/mumble/mumble.go

@@ -0,0 +1,259 @@
+package bmumble
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"strconv"
+	"time"
+
+	"layeh.com/gumble/gumble"
+	"layeh.com/gumble/gumbleutil"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/bridge/helper"
+	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 Bmumble struct {
+	client             *gumble.Client
+	Nick               string
+	Host               string
+	Channel            *uint32
+	local              chan config.Message
+	running            chan error
+	connected          chan gumble.DisconnectEvent
+	serverConfigUpdate chan gumble.ServerConfigEvent
+	serverConfig       gumble.ServerConfigEvent
+	tlsConfig          tls.Config
+
+	*bridge.Config
+}
+
+func New(cfg *bridge.Config) bridge.Bridger {
+	b := &Bmumble{}
+	b.Config = cfg
+	b.Nick = b.GetString("Nick")
+	b.local = make(chan config.Message)
+	b.running = make(chan error)
+	b.connected = make(chan gumble.DisconnectEvent)
+	b.serverConfigUpdate = make(chan gumble.ServerConfigEvent)
+	return b
+}
+
+func (b *Bmumble) Connect() error {
+	b.Log.Infof("Connecting %s", b.GetString("Server"))
+	host, portstr, err := net.SplitHostPort(b.GetString("Server"))
+	if err != nil {
+		return err
+	}
+	b.Host = host
+	_, err = strconv.Atoi(portstr)
+	if err != nil {
+		return err
+	}
+
+	if err = b.buildTLSConfig(); err != nil {
+		return err
+	}
+
+	go b.doSend()
+	go b.connectLoop()
+	err = <-b.running
+	return err
+}
+
+func (b *Bmumble) Disconnect() error {
+	return b.client.Disconnect()
+}
+
+func (b *Bmumble) JoinChannel(channel config.ChannelInfo) error {
+	cid, err := strconv.ParseUint(channel.Name, 10, 32)
+	if err != nil {
+		return err
+	}
+	channelID := uint32(cid)
+	if b.Channel != nil && *b.Channel != channelID {
+		b.Log.Fatalf("Cannot join channel ID '%d', already joined to channel ID %d", channelID, *b.Channel)
+		return errors.New("the Mumble bridge can only join a single channel")
+	}
+	b.Channel = &channelID
+	return b.doJoin(b.client, channelID)
+}
+
+func (b *Bmumble) Send(msg config.Message) (string, error) {
+	// Only process text messages
+	b.Log.Debugf("=> Received local message %#v", msg)
+	if msg.Event != "" && msg.Event != config.EventUserAction {
+		return "", nil
+	}
+
+	attachments := b.extractFiles(&msg)
+	b.local <- msg
+	for _, a := range attachments {
+		b.local <- a
+	}
+	return "", nil
+}
+
+func (b *Bmumble) buildTLSConfig() error {
+	b.tlsConfig = tls.Config{}
+	// Load TLS client certificate keypair required for registered user authentication
+	if cpath := b.GetString("TLSClientCertificate"); cpath != "" {
+		if ckey := b.GetString("TLSClientKey"); ckey != "" {
+			cert, err := tls.LoadX509KeyPair(cpath, ckey)
+			if err != nil {
+				return err
+			}
+			b.tlsConfig.Certificates = []tls.Certificate{cert}
+		}
+	}
+	// Load TLS CA used for server verification.  If not provided, the Go system trust anchor is used
+	if capath := b.GetString("TLSCACertificate"); capath != "" {
+		ca, err := ioutil.ReadFile(capath)
+		if err != nil {
+			return err
+		}
+		b.tlsConfig.RootCAs = x509.NewCertPool()
+		b.tlsConfig.RootCAs.AppendCertsFromPEM(ca)
+	}
+	b.tlsConfig.InsecureSkipVerify = b.GetBool("SkipTLSVerify")
+	return nil
+}
+
+func (b *Bmumble) connectLoop() {
+	firstConnect := true
+	for {
+		err := b.doConnect()
+		if firstConnect {
+			b.running <- err
+		}
+		if err != nil {
+			b.Log.Errorf("Connection to server failed: %#v", err)
+			if firstConnect {
+				break
+			} else {
+				b.Log.Info("Retrying in 10s")
+				time.Sleep(10 * time.Second)
+				continue
+			}
+		}
+		firstConnect = false
+		d := <-b.connected
+		switch d.Type {
+		case gumble.DisconnectError:
+			b.Log.Errorf("Lost connection to the server (%s), attempting reconnect", d.String)
+			continue
+		case gumble.DisconnectKicked:
+			b.Log.Errorf("Kicked from the server (%s), attempting reconnect", d.String)
+			continue
+		case gumble.DisconnectBanned:
+			b.Log.Errorf("Banned from the server (%s), not attempting reconnect", d.String)
+			close(b.connected)
+			close(b.running)
+			return
+		case gumble.DisconnectUser:
+			b.Log.Infof("Disconnect successful")
+			close(b.connected)
+			close(b.running)
+			return
+		}
+	}
+}
+
+func (b *Bmumble) doConnect() error {
+	// Create new gumble config and attach event handlers
+	gumbleConfig := gumble.NewConfig()
+	gumbleConfig.Attach(gumbleutil.Listener{
+		ServerConfig: b.handleServerConfig,
+		TextMessage:  b.handleTextMessage,
+		Connect:      b.handleConnect,
+		Disconnect:   b.handleDisconnect,
+		UserChange:   b.handleUserChange,
+	})
+	gumbleConfig.Username = b.GetString("Nick")
+	if password := b.GetString("Password"); password != "" {
+		gumbleConfig.Password = password
+	}
+
+	client, err := gumble.DialWithDialer(new(net.Dialer), b.GetString("Server"), gumbleConfig, &b.tlsConfig)
+	if err != nil {
+		return err
+	}
+	b.client = client
+	return nil
+}
+
+func (b *Bmumble) doJoin(client *gumble.Client, channelID uint32) error {
+	channel, ok := client.Channels[channelID]
+	if !ok {
+		return fmt.Errorf("no channel with ID %d", channelID)
+	}
+	client.Self.Move(channel)
+	return nil
+}
+
+func (b *Bmumble) doSend() {
+	// Message sending loop that makes sure server-side
+	// restrictions and client-side message traits don't conflict
+	// with each other.
+	for {
+		select {
+		case serverConfig := <-b.serverConfigUpdate:
+			b.Log.Debugf("Received server config update: AllowHTML=%#v, MaximumMessageLength=%#v", serverConfig.AllowHTML, serverConfig.MaximumMessageLength)
+			b.serverConfig = serverConfig
+		case msg := <-b.local:
+			b.processMessage(&msg)
+		}
+	}
+}
+
+func (b *Bmumble) processMessage(msg *config.Message) {
+	b.Log.Debugf("Processing message %s", msg.Text)
+
+	allowHTML := true
+	if b.serverConfig.AllowHTML != nil {
+		allowHTML = *b.serverConfig.AllowHTML
+	}
+
+	// If this is a specially generated image message, send it unmodified
+	if msg.Event == "mumble_image" {
+		if allowHTML {
+			b.client.Self.Channel.Send(msg.Username+msg.Text, false)
+		} else {
+			b.Log.Info("Can't send image, server does not allow HTML messages")
+		}
+		return
+	}
+
+	// Don't process empty messages
+	if len(msg.Text) == 0 {
+		return
+	}
+	// If HTML is allowed, convert markdown into HTML, otherwise strip markdown
+	if allowHTML {
+		msg.Text = helper.ParseMarkdown(msg.Text)
+	} else {
+		msg.Text = stripmd.Strip(msg.Text)
+	}
+
+	// If there is a maximum message length, split and truncate the lines
+	var msgLines []string
+	if maxLength := b.serverConfig.MaximumMessageLength; maxLength != nil {
+		msgLines = helper.GetSubLines(msg.Text, *maxLength-len(msg.Username))
+	} else {
+		msgLines = helper.GetSubLines(msg.Text, 0)
+	}
+	// Send the individual lindes
+	for i := range msgLines {
+		b.client.Self.Channel.Send(msg.Username+msgLines[i], false)
+	}
+}

bridge/nctalk/nctalk.go

@@ -0,0 +1,210 @@
+package nctalk
+
+import (
+	"context"
+	"crypto/tls"
+	"strconv"
+	"strings"
+
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+
+	"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")
+	tconfig := &user.TalkUserConfig{
+		TLSConfig: &tls.Config{
+			InsecureSkipVerify: b.GetBool("SkipTLSVerify"), //nolint:gosec
+		},
+	}
+	var err error
+	b.user, err = user.NewUser(b.GetString("Server"), b.GetString("Login"), b.GetString("Password"), tconfig)
+	if err != nil {
+		b.Log.Error("Config could not be used")
+		return err
+	}
+	_, 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 {
+	tr, err := room.NewTalkRoom(b.user, channel.Name)
+	if err != nil {
+		return err
+	}
+	newRoom := Broom{
+		room: tr,
+	}
+	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)
+
+	// Config
+	guestSuffix := " (Guest)"
+	if b.IsKeySet("GuestSuffix") {
+		guestSuffix = b.GetString("GuestSuffix")
+	}
+
+	go func() {
+		for msg := range c {
+			msg := msg
+
+			if msg.Error != nil {
+				b.Log.Errorf("Fatal message poll error: %s\n", msg.Error)
+
+				return
+			}
+
+			// 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:     formatRichObjectString(msg.Message, msg.MessageParameters),
+				Channel:  newRoom.room.Token,
+				Username: DisplayName(msg, guestSuffix),
+				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)
+			}
+
+			// Handle Files
+			err = b.handleFiles(&remoteMessage, &msg)
+			if err != nil {
+				b.Log.Errorf("Error handling file: %#v", msg)
+
+				continue
+			}
+
+			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
+}
+
+func (b *Btalk) handleFiles(mmsg *config.Message, message *ocs.TalkRoomMessageData) error {
+	for _, parameter := range message.MessageParameters {
+		if parameter.Type == ocs.ROSTypeFile {
+			// Get the file
+			file, err := b.user.DownloadFile(parameter.Path)
+			if err != nil {
+				return err
+			}
+
+			if mmsg.Extra == nil {
+				mmsg.Extra = make(map[string][]interface{})
+			}
+
+			mmsg.Extra["file"] = append(mmsg.Extra["file"], config.FileInfo{
+				Name:   parameter.Name,
+				Data:   file,
+				Size:   int64(len(*file)),
+				Avatar: false,
+			})
+		}
+	}
+
+	return nil
+}
+
+// Spec: https://github.com/nextcloud/server/issues/1706#issue-182308785
+func formatRichObjectString(message string, parameters map[string]ocs.RichObjectString) string {
+	for id, parameter := range parameters {
+		text := parameter.Name
+
+		switch parameter.Type {
+		case ocs.ROSTypeUser, ocs.ROSTypeGroup:
+			text = "@" + text
+		case ocs.ROSTypeFile:
+			if parameter.Link != "" {
+				text = parameter.Name
+			}
+		}
+
+		message = strings.ReplaceAll(message, "{"+id+"}", text)
+	}
+
+	return message
+}
+
+func DisplayName(msg ocs.TalkRoomMessageData, suffix string) string {
+	if msg.ActorType == ocs.ActorGuest {
+		if msg.ActorDisplayName == "" {
+			return "Guest"
+		}
+
+		return msg.ActorDisplayName + suffix
+	}
+
+	return msg.ActorDisplayName
+}

bridge/rocketchat/handlers.go

@@ -2,6 +2,7 @@ package brocketchat
 
 import (
 	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/matterbridge/Rocket.Chat.Go.SDK/models"
 )
 
 func (b *Brocketchat) handleRocket() {
@@ -38,6 +39,23 @@ func (b *Brocketchat) handleRocketHook(messages chan *config.Message) {
 	}
 }
 
+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
@@ -59,7 +77,12 @@ func (b *Brocketchat) handleRocketClient(messages chan *config.Message) {
 			UserID:   message.User.ID,
 			ID:       message.ID,
 		}
-		messages <- rmsg
+
+		// 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
+		}
 	}
 }
 

bridge/rocketchat/helpers.go

@@ -58,6 +58,9 @@ func (b *Brocketchat) doConnectWebhookURL() error {
 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
@@ -95,7 +98,7 @@ func (b *Brocketchat) getChannelID(name string) string {
 	b.RLock()
 	defer b.RUnlock()
 	for k, v := range b.channelMap {
-		if v == name {
+		if v == name || v == "#"+name {
 			return k
 		}
 	}

bridge/rocketchat/rocketchat.go

@@ -29,6 +29,12 @@ type Brocketchat struct {
 	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 {
@@ -108,6 +114,11 @@ func (b *Brocketchat) Send(msg config.Message) (string, error) {
 	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 == "" {

bridge/slack/handlers.go

@@ -1,18 +1,22 @@
 package bslack
 
 import (
+	"errors"
 	"fmt"
 	"html"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/nlopes/slack"
+	"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) != "" {
+	if b.GetString(incomingWebhookConfig) != "" && b.GetString(tokenConfig) == "" {
 		b.Log.Debugf("Choosing webhooks based receiving")
 		go b.handleMatterHook(messages)
 	} else {
@@ -22,20 +26,21 @@ func (b *Bslack) handleSlack() {
 	time.Sleep(time.Second)
 	b.Log.Debug("Start listening for Slack messages")
 	for message := range messages {
-		if message.Event != config.EventUserTyping {
+		// 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)
 		}
 
-		// cleanup the message
-		message.Text = b.replaceMention(message.Text)
-		message.Text = b.replaceVariable(message.Text)
-		message.Text = b.replaceChannel(message.Text)
-		message.Text = b.replaceURL(message.Text)
-		message.Text = html.UnescapeString(message.Text)
-
-		// Add the avatar
-		message.Avatar = b.users.getAvatar(message.UserID)
-
 		b.Log.Debugf("<= Message is %#v", message)
 		b.Remote <- *message
 	}
@@ -43,7 +48,7 @@ func (b *Bslack) handleSlack() {
 
 func (b *Bslack) handleSlackClient(messages chan *config.Message) {
 	for msg := range b.rtm.IncomingEvents {
-		if msg.Type != sUserTyping && msg.Type != sLatencyReport {
+		if msg.Type != sUserTyping && msg.Type != sHello && msg.Type != sLatencyReport {
 			b.Log.Debugf("== Receiving event %#v", msg.Data)
 		}
 		switch ev := msg.Data.(type) {
@@ -52,7 +57,9 @@ func (b *Bslack) handleSlackClient(messages chan *config.Message) {
 				continue
 			}
 			rmsg, err := b.handleTypingEvent(ev)
-			if err != nil {
+			if err == ErrEventIgnored {
+				continue
+			} else if err != nil {
 				b.Log.Errorf("%#v", err)
 				continue
 			}
@@ -86,7 +93,7 @@ func (b *Bslack) handleSlackClient(messages chan *config.Message) {
 			b.Log.Errorf("Connection failed %#v %#v", ev.Error(), ev.ErrorObj)
 		case *slack.MemberJoinedChannelEvent:
 			b.users.populateUser(ev.User)
-		case *slack.LatencyReport:
+		case *slack.HelloEvent, *slack.LatencyReport, *slack.ConnectingEvent:
 			continue
 		default:
 			b.Log.Debugf("Unhandled incoming event: %T", ev)
@@ -123,18 +130,34 @@ func (b *Bslack) skipMessageEvent(ev *slack.MessageEvent) bool {
 		}
 	}
 
-	// Skip any messages that we made ourselves or from 'slackbot' (see #527).
-	if ev.Username == sSlackBotUser ||
-		(b.rtm != nil && ev.Username == b.si.User.Name) ||
-		(len(ev.Attachments) > 0 && ev.Attachments[0].CallbackID == "matterbridge_"+b.uuid) {
-		return true
+	// 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
 	}
 
-	// It seems ev.SubMessage.Edited == nil when slack unfurls.
-	// Do not forward these messages. See Github issue #266.
-	if ev.SubMessage != nil &&
-		ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp &&
-		ev.SubMessage.Edited == nil {
+	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
 	}
 
@@ -263,6 +286,9 @@ func (b *Bslack) handleAttachments(ev *slack.MessageEvent, rmsg *config.Message)
 }
 
 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

bridge/slack/helpers.go

@@ -7,8 +7,8 @@ import (
 	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/nlopes/slack"
 	"github.com/sirupsen/logrus"
+	"github.com/slack-go/slack"
 )
 
 // populateReceivedMessage shapes the initial Matterbridge message that we will forward to the
@@ -188,6 +188,36 @@ func (b *Bslack) replaceURL(text string) string {
 	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 >
+		{
+			regexp.MustCompile(`(?sm)^>`),
+			">",
+		},
+	}
+	for _, rule := range regexReplaceAllString {
+		text = rule.regex.ReplaceAllString(text, rule.rpl)
+	}
+	return text
+}
+
 func (b *Bslack) replaceCodeFence(text string) string {
 	return codeFenceRE.ReplaceAllString(text, "```")
 }

bridge/slack/legacy.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/matterhook"
-	"github.com/nlopes/slack"
+	"github.com/slack-go/slack"
 )
 
 type BLegacy struct {
@@ -13,7 +13,9 @@ type BLegacy struct {
 }
 
 func NewLegacy(cfg *bridge.Config) bridge.Bridger {
-	return &BLegacy{Bslack: newBridge(cfg)}
+	b := &BLegacy{Bslack: newBridge(cfg)}
+	b.legacy = true
+	return b
 }
 
 func (b *BLegacy) Connect() error {

bridge/slack/slack.go

@@ -12,9 +12,9 @@ import (
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
 	"github.com/42wim/matterbridge/matterhook"
-	"github.com/hashicorp/golang-lru"
-	"github.com/nlopes/slack"
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/rs/xid"
+	"github.com/slack-go/slack"
 )
 
 type Bslack struct {
@@ -32,9 +32,11 @@ type Bslack struct {
 
 	channels *channels
 	users    *users
+	legacy   bool
 }
 
 const (
+	sHello           = "hello"
 	sChannelJoin     = "channel_join"
 	sChannelLeave    = "channel_leave"
 	sChannelJoined   = "channel_joined"
@@ -62,6 +64,7 @@ const (
 	editSuffixConfig      = "EditSuffix"
 	iconURLConfig         = "iconurl"
 	noSendJoinConfig      = "nosendjoinpart"
+	messageLength         = 3000
 )
 
 func New(cfg *bridge.Config) bridge.Bridger {
@@ -151,6 +154,18 @@ func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
 		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)
@@ -163,7 +178,8 @@ func (b *Bslack) JoinChannel(channel config.ChannelInfo) error {
 		channel.Name = channelInfo.Name
 	}
 
-	if !channelInfo.IsMember {
+	// 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
@@ -179,6 +195,7 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 		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
@@ -187,7 +204,7 @@ func (b *Bslack) Send(msg config.Message) (string, error) {
 	}
 
 	// Use webhook to send the message
-	if b.GetString(outgoingWebhookConfig) != "" {
+	if b.GetString(outgoingWebhookConfig) != "" && b.GetString(tokenConfig) == "" {
 		return "", b.sendWebhook(msg)
 	}
 	return b.sendRTM(msg)
@@ -282,7 +299,7 @@ func (b *Bslack) sendRTM(msg config.Message) (string, error) {
 	}
 
 	// Handle prefix hint for unthreaded messages.
-	if msg.ParentID == "msg-parent-not-found" {
+	if msg.ParentNotFound() {
 		msg.ParentID = ""
 		msg.Text = fmt.Sprintf("[thread]: %s", msg.Text)
 	}
@@ -393,7 +410,6 @@ func (b *Bslack) editMessage(msg *config.Message, channelInfo *slack.Channel) (b
 	}
 	messageOptions := b.prepareMessageOptions(msg)
 	for {
-		messageOptions = append(messageOptions, slack.MsgOptionText(msg.Text, false))
 		_, _, _, err := b.rtm.UpdateMessage(channelInfo.ID, msg.ID, messageOptions...)
 		if err == nil {
 			return true, nil
@@ -412,11 +428,6 @@ func (b *Bslack) postMessage(msg *config.Message, channelInfo *slack.Channel) (s
 		return "", nil
 	}
 	messageOptions := b.prepareMessageOptions(msg)
-	messageOptions = append(
-		messageOptions,
-		slack.MsgOptionText(msg.Text, false),
-		slack.MsgOptionEnableLinkUnfurl(),
-	)
 	for {
 		_, id, err := b.rtm.PostMessage(channelInfo.ID, messageOptions...)
 		if err == nil {
@@ -482,8 +493,6 @@ func (b *Bslack) prepareMessageOptions(msg *config.Message) []slack.MsgOption {
 	}
 
 	var attachments []slack.Attachment
-	// add a callback ID so we can see we created it
-	attachments = append(attachments, slack.Attachment{CallbackID: "matterbridge_" + b.uuid})
 	// add file attachments
 	attachments = append(attachments, b.createAttach(msg.Extra)...)
 	// add slack attachments (from another slack bridge)
@@ -494,6 +503,19 @@ func (b *Bslack) prepareMessageOptions(msg *config.Message) []slack.MsgOption {
 	}
 
 	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

bridge/slack/users_channels.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/nlopes/slack"
 	"github.com/sirupsen/logrus"
+	"github.com/slack-go/slack"
 )
 
 const minimumRefreshInterval = 10 * time.Second
@@ -87,7 +87,11 @@ func (b *users) populateUser(userID string) {
 			// in case the previous query failed for some reason.
 		} else {
 			b.usersSyncPoints[userID] = make(chan struct{})
-			b.usersMutex.Unlock()
+			defer func() {
+				// Wake up any waiting goroutines and remove the synchronization point.
+				close(b.usersSyncPoints[userID])
+				delete(b.usersSyncPoints, userID)
+			}()
 			break
 		}
 	}
@@ -107,10 +111,6 @@ func (b *users) populateUser(userID string) {
 
 	// Register user information.
 	b.users[userID] = user
-
-	// Wake up any waiting goroutines and remove the synchronization point.
-	close(b.usersSyncPoints[userID])
-	delete(b.usersSyncPoints, userID)
 }
 
 func (b *users) populateUsers(wait bool) {

bridge/sshchat/sshchat.go

@@ -130,6 +130,10 @@ func (b *Bsshchat) handleSSHChat() error {
 			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

bridge/steam/handlers.go

@@ -85,7 +85,7 @@ func (b *Bsteam) handleEvents() {
 
 func (b *Bsteam) handleLogOnFailed(e *steam.LogOnFailedEvent, myLoginInfo *steam.LogOnDetails) error {
 	switch e.Result {
-	case steamlang.EResult_AccountLogonDeniedNeedTwoFactorCode:
+	case steamlang.EResult_AccountLoginDeniedNeedTwoFactor:
 		b.Log.Info("Steam guard isn't letting me in! Enter 2FA code:")
 		var code string
 		fmt.Scanf("%s", &code)

bridge/telegram/handlers.go

@@ -5,10 +5,11 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"unicode/utf16"
 
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/go-telegram-bot-api/telegram-bot-api"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
 )
 
 func (b *Btelegram) handleUpdate(rmsg *config.Message, message, posted, edited *tgbotapi.Message) *tgbotapi.Message {
@@ -38,22 +39,32 @@ func (b *Btelegram) handleGroups(rmsg *config.Message, message *tgbotapi.Message
 
 // handleForwarded handles forwarded messages
 func (b *Btelegram) handleForwarded(rmsg *config.Message, message *tgbotapi.Message) {
-	if message.ForwardFrom != nil {
-		usernameForward := ""
-		if b.GetBool("UseFirstName") {
+	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 = message.ForwardFrom.UserName
-			if usernameForward == "" {
-				usernameForward = message.ForwardFrom.FirstName
-			}
-		}
-		if usernameForward == "" {
-			usernameForward = unknownUser
-		}
-		rmsg.Text = "Forwarded from " + usernameForward + ": " + rmsg.Text
 	}
+
+	if usernameForward == "" {
+		usernameForward = unknownUser
+	}
+
+	rmsg.Text = "Forwarded from " + usernameForward + ": " + rmsg.Text
 }
 
 // handleQuoting handles quoting of previous messages
@@ -94,7 +105,7 @@ func (b *Btelegram) handleUsername(rmsg *config.Message, message *tgbotapi.Messa
 			}
 		}
 		// only download avatars if we have a place to upload them (configured mediaserver)
-		if b.General.MediaServerUpload != "" {
+		if b.General.MediaServerUpload != "" || (b.General.MediaServerDownload != "" && b.General.MediaDownloadPath != "") {
 			b.handleDownloadAvatar(message.From.ID, rmsg.Channel)
 		}
 	}
@@ -125,6 +136,11 @@ func (b *Btelegram) handleRecv(updates <-chan tgbotapi.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)
@@ -201,6 +217,46 @@ func (b *Btelegram) handleDownloadAvatar(userid int, channel string) {
 	}
 }
 
+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
@@ -248,15 +304,18 @@ func (b *Btelegram) handleDownload(rmsg *config.Message, message *tgbotapi.Messa
 	if err != nil {
 		return err
 	}
-	if strings.HasSuffix(name, ".webp") && b.GetBool("MediaConvertWebPToPNG") {
-		b.Log.Debugf("WebP to PNG conversion enabled, converting %s", name)
-		err := helper.ConvertWebPToPNG(data)
-		if err != nil {
-			b.Log.Errorf("conversion failed: %s", err)
-		} else {
-			name = strings.Replace(name, ".webp", ".png", 1)
-		}
+
+	if strings.HasSuffix(name, ".tgs.webp") {
+		b.maybeConvertTgs(&name, data)
+	} else if strings.HasSuffix(name, ".webp") {
+		b.maybeConvertWebp(&name, data)
 	}
+
+	// rename .oga to .ogg  https://github.com/42wim/matterbridge/issues/906#issuecomment-741793512
+	if strings.HasSuffix(name, ".oga") && message.Audio != nil {
+		name = strings.Replace(name, ".oga", ".ogg", 1)
+	}
+
 	helper.HandleDownloadData(b.Log, rmsg, name, message.Caption, "", data, b.General)
 	return nil
 }
@@ -306,6 +365,9 @@ func (b *Btelegram) handleEdit(msg *config.Message, chatid int64) (string, error
 	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")
@@ -327,7 +389,7 @@ func (b *Btelegram) handleUploadFile(msg *config.Message, chatid int64) string {
 			Name:  fi.Name,
 			Bytes: *fi.Data,
 		}
-		re := regexp.MustCompile(".(jpg|png)$")
+		re := regexp.MustCompile(".(jpg|jpe|png)$")
 		if re.MatchString(fi.Name) {
 			c = tgbotapi.NewPhotoUpload(chatid, file)
 		} else {
@@ -351,6 +413,14 @@ func (b *Btelegram) handleQuote(message, quoteNick, quoteMessage string) string
 	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)
@@ -370,8 +440,13 @@ func (b *Btelegram) handleEntities(rmsg *config.Message, message *tgbotapi.Messa
 				b.Log.Errorf("entity text_link url parse failed: %s", err)
 				continue
 			}
-			link := rmsg.Text[e.Offset : e.Offset+e.Length]
-			rmsg.Text = strings.Replace(rmsg.Text, link, url.String(), 1)
+			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/telegram.go

@@ -2,19 +2,23 @@ package btelegram
 
 import (
 	"html"
+	"log"
 	"strconv"
 	"strings"
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/bridge/helper"
-	"github.com/go-telegram-bot-api/telegram-bot-api"
+	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 {
@@ -24,6 +28,16 @@ type Btelegram struct {
 }
 
 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)}
 }
 
@@ -81,8 +95,8 @@ func (b *Btelegram) Send(msg config.Message) (string, error) {
 	// Upload a file if it exists
 	if msg.Extra != nil {
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			if _, err := b.sendMessage(chatid, rmsg.Username, rmsg.Text); err != nil {
-				b.Log.Errorf("sendMessage failed: %s", err)
+			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)
@@ -97,7 +111,14 @@ func (b *Btelegram) Send(msg config.Message) (string, error) {
 	}
 
 	// Post normal message
-	return b.sendMessage(chatid, msg.Username, msg.Text)
+	// 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 {
@@ -119,11 +140,18 @@ func (b *Btelegram) sendMessage(chatid int64, username, text string) (string, er
 		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

bridge/whatsapp/handlers.go

@@ -1,14 +1,15 @@
 package bwhatsapp
 
 import (
+	"fmt"
+	"mime"
 	"strings"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge/config"
-
-	"github.com/matterbridge/go-whatsapp"
-
-	whatsappExt "github.com/matterbridge/mautrix-whatsapp/whatsapp-ext"
+	"github.com/42wim/matterbridge/bridge/helper"
+	"github.com/Rhymen/go-whatsapp"
+	"github.com/jpillora/backoff"
 )
 
 /*
@@ -21,12 +22,56 @@ Check:
 
 // HandleError received from WhatsApp
 func (b *Bwhatsapp) HandleError(err error) {
-	b.Log.Errorf("%v", err) // TODO implement proper handling? at least respond to different error types
+	// 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") {
+	if message.Info.FromMe {
 		return
 	}
 	// whatsapp sends last messages to show context , cut them
@@ -34,17 +79,17 @@ func (b *Bwhatsapp) HandleTextMessage(message whatsapp.TextMessage) {
 		return
 	}
 
-	messageTime := time.Unix(int64(message.Info.Timestamp), 0) // TODO check how behaves between timezones
-	groupJid := message.Info.RemoteJid
+	groupJID := message.Info.RemoteJid
+	senderJID := message.Info.SenderJid
 
-	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
+	if len(senderJID) == 0 {
+		if message.Info.Source != nil && message.Info.Source.Participant != nil {
+			senderJID = *message.Info.Source.Participant
+		}
 	}
 
-	// translate sender's Jid to the nicest username we can get
-	senderName := b.getSenderName(senderJid)
+	// translate sender's JID to the nicest username we can get
+	senderName := b.getSenderName(senderJID)
 	if senderName == "" {
 		senderName = "Someone" // don't expose telephone number
 	}
@@ -52,53 +97,214 @@ func (b *Bwhatsapp) HandleTextMessage(message whatsapp.TextMessage) {
 	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)
+		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] + whatsappExt.NewUserSuffix)
+			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}
+		UserID:   senderJID,
+		Username: senderName,
+		Text:     message.Text,
+		Channel:  groupJID,
+		Account:  b.Account,
+		Protocol: b.Protocol,
+		Extra:    make(map[string][]interface{}),
+		//	ParentID: TODO, // TODO handle thread replies  // map from Info.QuotedMessageID string
+		ID: message.Info.Id,
+	}
 
-	if avatarURL, exists := b.userAvatars[senderJid]; exists {
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
 		rmsg.Avatar = avatarURL
 	}
 
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
 	b.Log.Debugf("<= Message is %#v", rmsg)
+
 	b.Remote <- rmsg
 }
 
-//
-//func (b *Bwhatsapp) HandleImageMessage(message whatsapp.ImageMessage) {
-//	fmt.Println(message) // TODO implement
-//}
-//
-//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
+// HandleImageMessage sent from WhatsApp, relay it to the brige
+func (b *Bwhatsapp) HandleImageMessage(message whatsapp.ImageMessage) {
+	if message.Info.FromMe || message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	senderJID := message.Info.SenderJid
+	if len(message.Info.SenderJid) == 0 && message.Info.Source != nil && message.Info.Source.Participant != nil {
+		senderJID = *message.Info.Source.Participant
+	}
+
+	senderName := b.getSenderName(message.Info.SenderJid)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	rmsg := config.Message{
+		UserID:   senderJID,
+		Username: senderName,
+		Channel:  message.Info.RemoteJid,
+		Account:  b.Account,
+		Protocol: b.Protocol,
+		Extra:    make(map[string][]interface{}),
+		ID:       message.Info.Id,
+	}
+
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	fileExt, err := mime.ExtensionsByType(message.Type)
+	if err != nil {
+		b.Log.Errorf("Mimetype detection error: %s", err)
+
+		return
+	}
+
+	// rename .jfif to .jpg https://github.com/42wim/matterbridge/issues/1292
+	if fileExt[0] == ".jfif" {
+		fileExt[0] = ".jpg"
+	}
+
+	filename := fmt.Sprintf("%v%v", message.Info.Id, fileExt[0])
+
+	b.Log.Debugf("Trying to download %s with type %s", filename, message.Type)
+
+	data, err := message.Download()
+	if err != nil {
+		b.Log.Errorf("Download image failed: %s", err)
+
+		return
+	}
+
+	// Move file to bridge storage
+	helper.HandleDownloadData(b.Log, &rmsg, filename, message.Caption, "", &data, b.General)
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+
+	b.Remote <- rmsg
+}
+
+// HandleVideoMessage downloads video messages
+func (b *Bwhatsapp) HandleVideoMessage(message whatsapp.VideoMessage) {
+	if message.Info.FromMe || message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	senderJID := message.Info.SenderJid
+	if len(message.Info.SenderJid) == 0 && message.Info.Source != nil && message.Info.Source.Participant != nil {
+		senderJID = *message.Info.Source.Participant
+	}
+
+	senderName := b.getSenderName(message.Info.SenderJid)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	rmsg := config.Message{
+		UserID:   senderJID,
+		Username: senderName,
+		Channel:  message.Info.RemoteJid,
+		Account:  b.Account,
+		Protocol: b.Protocol,
+		Extra:    make(map[string][]interface{}),
+		ID:       message.Info.Id,
+	}
+
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	fileExt, err := mime.ExtensionsByType(message.Type)
+	if err != nil {
+		b.Log.Errorf("Mimetype detection error: %s", err)
+
+		return
+	}
+
+	filename := fmt.Sprintf("%v%v", message.Info.Id, fileExt[0])
+
+	b.Log.Debugf("Trying to download %s with size %#v and type %s", filename, message.Length, message.Type)
+
+	data, err := message.Download()
+	if err != nil {
+		b.Log.Errorf("Download video failed: %s", err)
+
+		return
+	}
+
+	// Move file to bridge storage
+	helper.HandleDownloadData(b.Log, &rmsg, filename, message.Caption, "", &data, b.General)
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+
+	b.Remote <- rmsg
+}
+
+// HandleAudioMessage downloads audio messages
+func (b *Bwhatsapp) HandleAudioMessage(message whatsapp.AudioMessage) {
+	if message.Info.FromMe || message.Info.Timestamp < b.startedAt {
+		return
+	}
+
+	senderJID := message.Info.SenderJid
+	if len(message.Info.SenderJid) == 0 && message.Info.Source != nil && message.Info.Source.Participant != nil {
+		senderJID = *message.Info.Source.Participant
+	}
+
+	senderName := b.getSenderName(message.Info.SenderJid)
+	if senderName == "" {
+		senderName = "Someone" // don't expose telephone number
+	}
+
+	rmsg := config.Message{
+		UserID:   senderJID,
+		Username: senderName,
+		Channel:  message.Info.RemoteJid,
+		Account:  b.Account,
+		Protocol: b.Protocol,
+		Extra:    make(map[string][]interface{}),
+		ID:       message.Info.Id,
+	}
+
+	if avatarURL, exists := b.userAvatars[senderJID]; exists {
+		rmsg.Avatar = avatarURL
+	}
+
+	fileExt, err := mime.ExtensionsByType(message.Type)
+	if err != nil {
+		b.Log.Errorf("Mimetype detection error: %s", err)
+
+		return
+	}
+
+	filename := fmt.Sprintf("%v%v", message.Info.Id, fileExt[0])
+
+	b.Log.Debugf("Trying to download %s with size %#v and type %s", filename, message.Length, message.Type)
+
+	data, err := message.Download()
+	if err != nil {
+		b.Log.Errorf("Download audio failed: %s", err)
+
+		return
+	}
+
+	// Move file to bridge storage
+	helper.HandleDownloadData(b.Log, &rmsg, filename, "audio message", "", &data, b.General)
+
+	b.Log.Debugf("<= Sending message from %s on %s to gateway", senderJID, b.Account)
+	b.Log.Debugf("<= Message is %#v", rmsg)
+
+	b.Remote <- rmsg
+}

bridge/whatsapp/helpers.go

@@ -2,17 +2,28 @@ package bwhatsapp
 
 import (
 	"encoding/gob"
+	"encoding/json"
 	"errors"
+	"fmt"
 	"os"
+	"strings"
 
 	qrcodeTerminal "github.com/Baozisoftware/qrcode-terminal-go"
-	"github.com/matterbridge/go-whatsapp"
+	"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)
 		}
@@ -35,13 +46,12 @@ func (b *Bwhatsapp) readSession() (whatsapp.Session, error) {
 	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
+
+	return session, decoder.Decode(&session)
 }
 
 func (b *Bwhatsapp) writeSession(session whatsapp.Session) error {
@@ -56,11 +66,31 @@ func (b *Bwhatsapp) writeSession(session whatsapp.Session) error {
 	if err != nil {
 		return err
 	}
-	defer file.Close()
-	encoder := gob.NewEncoder(file)
-	err = encoder.Encode(session)
 
-	return err
+	defer file.Close()
+
+	encoder := gob.NewEncoder(file)
+
+	return encoder.Encode(session)
+}
+
+func (b *Bwhatsapp) restoreSession() (*whatsapp.Session, error) {
+	session, err := b.readSession()
+	if err != nil {
+		b.Log.Warn(err.Error())
+	}
+
+	b.Log.Debugln("Restoring WhatsApp session..")
+
+	session, err = b.conn.RestoreWithSession(session)
+	if err != nil {
+		// restore session connection timed out (I couldn't get over it without logging in again)
+		return nil, errors.New("failed to restore session: " + err.Error())
+	}
+
+	b.Log.Debugln("Session restored successfully!")
+
+	return &session, nil
 }
 
 func (b *Bwhatsapp) getSenderName(senderJid string) string {
@@ -71,8 +101,33 @@ func (b *Bwhatsapp) getSenderName(senderJid string) string {
 		// 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
-		return sender.Notify
+		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 ""
 }
 
@@ -80,5 +135,29 @@ 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
+}
+
+func isGroupJid(identifier string) bool {
+	return strings.HasSuffix(identifier, "@g.us") ||
+		strings.HasSuffix(identifier, "@temp") ||
+		strings.HasSuffix(identifier, "@broadcast")
+}

bridge/whatsapp/whatsapp.go

@@ -1,20 +1,20 @@
 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/matterbridge/go-whatsapp"
-
-	whatsappExt "github.com/matterbridge/mautrix-whatsapp/whatsapp-ext"
+	"github.com/Rhymen/go-whatsapp"
 )
 
 const (
@@ -28,11 +28,8 @@ const (
 type Bwhatsapp struct {
 	*bridge.Config
 
-	// https://github.com/Rhymen/go-whatsapp/blob/c31092027237441cffba1b9cb148eadf7c83c3d2/session.go#L18-L21
-	session *whatsapp.Session
-	conn    *whatsapp.Conn
-	// https://github.com/tulir/mautrix-whatsapp/blob/master/whatsapp-ext/whatsapp.go
-	connExt   *whatsappExt.ExtendedConn
+	session   *whatsapp.Session
+	conn      *whatsapp.Conn
 	startedAt uint64
 
 	users       map[string]whatsapp.Contact
@@ -42,6 +39,7 @@ type Bwhatsapp struct {
 // 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")
 	}
@@ -52,21 +50,17 @@ func New(cfg *bridge.Config) bridge.Bridger {
 		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")
+		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)
 	if err != nil {
@@ -74,42 +68,23 @@ func (b *Bwhatsapp) Connect() error {
 	}
 
 	b.conn = conn
-	b.connExt = whatsappExt.ExtendConn(b.conn)
-	// TODO do we want to use it? b.connExt.SetClientName("Matterbridge WhatsApp bridge", "mb-wa")
 
 	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.RestoreSession(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())
-		}
+	b.session, err = b.restoreSession()
+	if err != nil {
+		b.Log.Warn(err.Error())
 	}
 
 	// login to a new session
 	if b.session == nil {
-		err = b.Login()
-		if err != nil {
+		if err = b.Login(); err != nil {
 			return err
 		}
 	}
+
 	b.startedAt = uint64(time.Now().Unix())
 
 	_, err = b.conn.Contacts()
@@ -117,6 +92,13 @@ func (b *Bwhatsapp) Connect() error {
 		return fmt.Errorf("error on update of contacts: %v", err)
 	}
 
+	// see https://github.com/Rhymen/go-whatsapp/issues/137#issuecomment-480316013
+	for len(b.conn.Store.Contacts) == 0 {
+		b.conn.Contacts() // nolint:errcheck
+
+		<-time.After(1 * time.Second)
+	}
+
 	// map all the users
 	for id, contact := range b.conn.Store.Contacts {
 		if !isGroupJid(id) && id != "status@broadcast" {
@@ -130,15 +112,16 @@ func (b *Bwhatsapp) Connect() error {
 		b.Log.Debug("Getting user avatars..")
 
 		for jid := range b.users {
-			info, err := b.connExt.GetProfilePicThumb(jid)
+			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.Lock()
 				b.userAvatars[jid] = info.URL
+				b.Unlock()
 			}
 		}
+
 		b.Log.Debug("Finished getting avatars..")
 	}()
 
@@ -155,8 +138,10 @@ func (b *Bwhatsapp) Login() error {
 	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)
@@ -167,74 +152,122 @@ func (b *Bwhatsapp) Login() error {
 		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)
 
+	// see https://github.com/Rhymen/go-whatsapp/issues/137#issuecomment-480316013
+	for len(b.conn.Store.Contacts) == 0 {
+		b.conn.Contacts() // nolint:errcheck
+		<-time.After(1 * time.Second)
+	}
+
 	// 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)
+		return nil
+	}
 
-		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)
+	// 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)
 		}
 	}
 
-	return nil
+	switch len(jids) {
+	case 0:
+		// didn't match any group - print out possibilites
+		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)
+	}
+}
+
+// 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
@@ -248,14 +281,12 @@ func (b *Bwhatsapp) Send(msg config.Message) (string, error) {
 		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
+
+		_, err := b.conn.RevokeMessage(msg.Channel, msg.ID, true)
+
+		return "", err
 	}
 
 	// Edit message
@@ -263,21 +294,27 @@ func (b *Bwhatsapp) Send(msg config.Message) (string, error) {
 		b.Log.Debugf("updating message with id %s", msg.ID)
 
 		msg.Text += " (edited)"
-		// TODO handle edit as a message reply with updated text
 	}
 
-	//// TODO Handle Upload a file
-	//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)
-	//	}
-	//}
+	// 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
-	text := whatsapp.TextMessage{
+	message := whatsapp.TextMessage{
 		Info: whatsapp.MessageInfo{
 			RemoteJid: msg.Channel, // which equals to group id
 		},
@@ -286,17 +323,7 @@ func (b *Bwhatsapp) Send(msg config.Message) (string, error) {
 
 	b.Log.Debugf("=> Sending %#v", msg)
 
-	// create message ID
-	// TODO follow and act if https://github.com/Rhymen/go-whatsapp/issues/101 implemented
-	bytes := make([]byte, 10)
-	if _, err := rand.Read(bytes); err != nil {
-		b.Log.Warn(err.Error())
-	}
-	text.Info.Id = strings.ToUpper(hex.EncodeToString(bytes))
-
-	err := b.conn.Send(text)
-
-	return text.Info.Id, err
+	return b.conn.Send(message)
 }
 
 // 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

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

@@ -1,8 +1,13 @@
 package bxmpp
 
 import (
+	"bytes"
 	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net/http"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/42wim/matterbridge/bridge"
@@ -14,50 +19,36 @@ import (
 )
 
 type Bxmpp struct {
-	xc      *xmpp.Client
-	xmppMap map[string]string
 	*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 {
-	b := &Bxmpp{Config: cfg}
-	b.xmppMap = make(map[string]string)
-	return b
+	return &Bxmpp{
+		Config:             cfg,
+		xmppMap:            make(map[string]string),
+		avatarAvailability: make(map[string]bool),
+		avatarMap:          make(map[string]string),
+	}
 }
 
 func (b *Bxmpp) Connect() error {
-	var err error
 	b.Log.Infof("Connecting %s", b.GetString("Server"))
-	b.xc, err = b.createXMPP()
-	if err != nil {
+	if err := b.createXMPP(); err != nil {
 		b.Log.Debugf("%#v", err)
 		return err
 	}
+
 	b.Log.Info("Connection succeeded")
-	go func() {
-		initial := true
-		bf := &backoff.Backoff{
-			Min:    time.Second,
-			Max:    5 * time.Minute,
-			Jitter: true,
-		}
-		for {
-			if initial {
-				b.handleXMPP()
-				initial = false
-			}
-			d := bf.Duration()
-			b.Log.Infof("Disconnected. Reconnecting in %s", d)
-			time.Sleep(d)
-			b.xc, err = b.createXMPP()
-			if err == nil {
-				b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: "", Account: b.Account, Event: config.EventRejoinChannels}
-				b.handleXMPP()
-				bf.Reset()
-			}
-		}
-	}()
+	go b.manageConnection()
 	return nil
 }
 
@@ -76,58 +67,176 @@ func (b *Bxmpp) JoinChannel(channel config.ChannelInfo) error {
 }
 
 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)
 
-	// Upload a file (in xmpp case send the upload URL because xmpp has no native upload support)
+	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).
+	var err error
 	if msg.Extra != nil {
 		for _, rmsg := range helper.HandleExtra(&msg, b.General) {
-			b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: rmsg.Channel + "@" + b.GetString("Muc"), Text: rmsg.Username + rmsg.Text})
+			b.Log.Debugf("=> Sending attachement message %#v", rmsg)
+			if b.GetString("WebhookURL") != "" {
+				err = b.postSlackCompatibleWebhook(msg)
+			} else {
+				_, err = b.xc.Send(xmpp.Chat{
+					Type:   "groupchat",
+					Remote: rmsg.Channel + "@" + b.GetString("Muc"),
+					Text:   rmsg.Username + rmsg.Text,
+				})
+			}
+
+			if err != nil {
+				b.Log.WithError(err).Error("Unable to send message with share URL.")
+			}
 		}
 		if len(msg.Extra["file"]) > 0 {
-			return b.handleUploadFile(&msg)
+			return "", b.handleUploadFile(&msg)
 		}
 	}
 
-	var msgreplaceid string
-	msgid := xid.New().String()
-	if msg.ID != "" {
-		msgid = msg.ID
-		msgreplaceid = msg.ID
+	if b.GetString("WebhookURL") != "" {
+		b.Log.Debugf("Sending message using Webhook")
+		err := b.postSlackCompatibleWebhook(msg)
+		if err != nil {
+			b.Log.Errorf("Failed to send message using webhook: %s", err)
+			return "", err
+		}
+
+		return "", nil
 	}
-	// Post normal message
-	_, err := b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Text: msg.Username + msg.Text, ID: msgid, ReplaceID: msgreplaceid})
-	if err != nil {
+
+	// Post normal message.
+	var msgReplaceID string
+	msgID := xid.New().String()
+	if msg.ID != "" {
+		msgID = msg.ID
+		msgReplaceID = msg.ID
+	}
+	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
+	return msgID, nil
 }
 
-func (b *Bxmpp) createXMPP() (*xmpp.Client, error) {
-	tc := new(tls.Config)
-	tc.InsecureSkipVerify = b.GetBool("SkipTLSVerify")
-	tc.ServerName = strings.Split(b.GetString("Server"), ":")[0]
+func (b *Bxmpp) postSlackCompatibleWebhook(msg config.Message) error {
+	type XMPPWebhook struct {
+		Username string `json:"username"`
+		Text     string `json:"text"`
+	}
+	webhookBody, err := json.Marshal(XMPPWebhook{
+		Username: msg.Username,
+		Text:     msg.Text,
+	})
+	if err != nil {
+		b.Log.Errorf("Failed to marshal webhook: %s", err)
+		return err
+	}
+
+	resp, err := http.Post(b.GetString("WebhookURL")+"/"+msg.Channel, "application/json", bytes.NewReader(webhookBody))
+	resp.Body.Close()
+	return err
+}
+
+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,
+		StartTLS:                     !b.GetBool("NoTLS"),
 		TLSConfig:                    tc,
 		Debug:                        b.GetBool("debug"),
-		Logger:                       b.Log.Writer(),
 		Session:                      true,
 		Status:                       "",
 		StatusMessage:                "",
 		Resource:                     "",
-		InsecureAllowUnencryptedAuth: false,
+		InsecureAllowUnencryptedAuth: b.GetBool("NoTLS"),
 	}
 	var err error
 	b.xc, err = options.NewClient()
-	return b.xc, err
+	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 {
@@ -139,8 +248,7 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 			select {
 			case <-ticker.C:
 				b.Log.Debugf("PING")
-				err := b.xc.PingC2S("", "")
-				if err != nil {
+				if err := b.xc.PingC2S("", ""); err != nil {
 					b.Log.Debugf("PING failed %#v", err)
 				}
 			case <-done:
@@ -152,53 +260,74 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 }
 
 func (b *Bxmpp) handleXMPP() error {
-	var ok bool
-	var msgid string
 	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)
-				event := ""
-				// skip invalid messages
+
+				// Skip invalid messages.
 				if b.skipMessage(v) {
 					continue
 				}
+
+				var event string
 				if strings.Contains(v.Text, "has set the subject to:") {
 					event = config.EventTopicChange
 				}
-				msgid = v.ID
+
+				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
+					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,
+					ID:       msgID,
 					Event:    event,
 				}
 
-				// check if we have an action 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
+			// Do nothing.
 		}
 	}
 }
@@ -211,30 +340,41 @@ func (b *Bxmpp) replaceAction(text string) (string, bool) {
 }
 
 // handleUploadFile handles native upload of files
-func (b *Bxmpp) handleUploadFile(msg *config.Message) (string, error) {
-	var urldesc = ""
+func (b *Bxmpp) handleUploadFile(msg *config.Message) error {
+	var urlDesc string
 
-	for _, f := range msg.Extra["file"] {
-		fi := f.(config.FileInfo)
-		if fi.Comment != "" {
-			msg.Text += fi.Comment + ": "
+	for _, file := range msg.Extra["file"] {
+		fileInfo := file.(config.FileInfo)
+		if fileInfo.Comment != "" {
+			msg.Text += fileInfo.Comment + ": "
 		}
-		if fi.URL != "" {
-			msg.Text = fi.URL
-			if fi.Comment != "" {
-				msg.Text = fi.Comment + ": " + fi.URL
-				urldesc = fi.Comment
+		if fileInfo.URL != "" {
+			msg.Text = fileInfo.URL
+			if fileInfo.Comment != "" {
+				msg.Text = fileInfo.Comment + ": " + fileInfo.URL
+				urlDesc = fileInfo.Comment
 			}
 		}
-		_, err := b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Text: msg.Username + msg.Text})
-		if err != nil {
-			return "", err
+		if _, err := b.xc.Send(xmpp.Chat{
+			Type:   "groupchat",
+			Remote: msg.Channel + "@" + b.GetString("Muc"),
+			Text:   msg.Username + msg.Text,
+		}); err != nil {
+			return err
 		}
-		if fi.URL != "" {
-			b.xc.SendOOB(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.GetString("Muc"), Ooburl: fi.URL, Oobdesc: urldesc})
+
+		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
+	return nil
 }
 
 func (b *Bxmpp) parseNick(remote string) string {
@@ -278,7 +418,23 @@ func (b *Bxmpp) skipMessage(message xmpp.Chat) bool {
 		return true
 	}
 
+	// Ignore messages posted by our webhook
+	if b.GetString("WebhookURL") != "" && strings.Contains(message.ID, "webhookbot") {
+		return true
+	}
+
 	// skip delayed messages
-	t := time.Time{}
-	return message.Stamp != t
+	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

@@ -135,19 +135,25 @@ func (b *Bzulip) handleQueue() error {
 			if m.SenderEmail == b.GetString("login") {
 				continue
 			}
+
+			avatarURL := m.AvatarURL
+			if !strings.HasPrefix(avatarURL, "http") {
+				avatarURL = b.GetString("server") + avatarURL
+			}
+
 			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,
+				Avatar:   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)
 	}
 }

changelog.md

@@ -1,3 +1,471 @@
+# v1.21.0
+
+## Breaking Changes
+
+- discord: Remove WebhookURL support (discord) (#1323)
+
+`WebhookURL` global setting for discord is removed and will quit matterbridge.
+New `AutoWebhooks=true` setting, which will automatically use (and create, if they do not exist) webhooks inside specific channels. This only works if the bot has Manage Webhooks permission in bridged channels (global permission or as a channel permission override). Backwards compatibility with channel-specific webhooks. More info [here](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample#L862). 
+
+## New features
+
+- discord: Create webhooks automatically (#1323)
+- discord: Add threading support with token (discord) (#1342)
+- irc: Join on invite (irc). Fixes #1231 (#1306)
+- irc: Add support for stateless bridging via draft/relaymsg (irc) (#1339)
+- whatsapp: Add support for deleting messages (whatsapp) (#1316)
+- whatsapp: Handle video downloads (whatsapp) (#1316)
+- whatsapp: Handle audio downloads (whatsapp) (#1316)
+
+## Enhancements
+
+- general: Parse fencedcode in ParseMarkdown. Fixes #1127 (#1329)
+- discord: Refactor guild finding code (discord) (#1319)
+- discord: Add a prefix handler for unthreaded messages (discord) (#1346)
+- irc: Add support for irc to irc notice (irc). Fixes #754 (#1305)
+- irc: Make handlers run async (irc) (#1325)
+- matrix: Show mxids in case of clashing usernames (matrix) (#1309)
+- matrix: Implement ratelimiting (matrix). Fixes #1238 (#1326)
+- matrix: Mark messages as read (matrix). Fixes #1317 (#1328)
+- nctalk: Update go-nc-talk (nctalk) (#1333)
+- rocketchat: Update rocketchat vendor (#1327)
+- tengo: Add UserID to RemoteNickFormat and Tengo (#1308)
+- whatsapp: Retry until we have contacts (whatsapp). Fixes #1122 (#1304)
+- whatsapp: Refactor/cleanup code (whatsapp)
+- whatsapp: Refactor handleTextMessage (whatsapp)
+- whatsapp: Refactor image downloads (whatsapp)
+- whatsapp: Rename jfif to jpg (whatsapp). Fixes #1292
+
+## Bugfix
+
+- discord: Reject cross-channel message references (discord) (#1345)
+- mumble: Add nil checks to text message handling (mumble) (#1321)
+
+This release couldn't exist without the following contributors:
+@nightmared, @qaisjp, @jlu5, @wschwab, @gary-kim, @s3lph, @JeremyRand
+
+# v1.20.0
+
+## Breaking
+
+- matrix: Send the display name instead of the user name (matrix) (#1282)  
+  Matrix now sends the displayname if set instead of the username. If you want to keep the username, add  `UseUsername=true` to your matrix config. <https://github.com/42wim/matterbridge/wiki/Settings#useusername-1>
+- discord: Disable webhook editing (discord) (#1296)  
+  Because of issues with ratelimiting of webhook editing, this feature is now disabled. If you have multiple discord channels you bridge, you'll need to add a `webhookURL` to the `[gateway.inout.options]`. See <https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample#L1864-L1870> for an example.
+
+## New features
+
+- general: Allow tengo to drop messages using msgDrop (#1272)
+- general: Update libraries (whatsapp,markdown,mattermost,ssh-chat)
+- irc: Add PingDelay option (irc) (#1269)
+- matrix: Allow message edits on matrix (#1286)
+- xmpp: add NoTLS option to allow plaintext XMPP connections (#1288)
+
+## Enhancements
+
+- discord: Edit messages via webhook (1287)
+- general: Add extra debug to log time spent sending a message per bridge (#1299)
+
+This release couldn't exist without the following contributors:
+@nightmared, @zhoreeq
+
+# v1.19.0
+
+## New features
+
+- mumble: new protocol added: Add Mumble support (#1245)
+- nctalk: Add support for downloading files (nctalk) (#1249)
+- nctalk: Append a suffix if user is a guest user (nctalk) (#1250)
+
+## Enhancements
+
+- irc: Add even more debug for irc (#1266)
+- matrix: Add username formatting for all events (matrix) (#1233)
+- matrix: Permit uploading files of other mimetypes (#1237)
+- whatsapp: Use vendored whatsapp version (#1258)
+- whatsapp: Add username for images from WhatsApp (#1232)
+
+This release couldn't exist without the following contributors:
+@Dellle, @42wim, @gary-kim, @s3lph, @BenWiederhake
+
+# v1.18.3
+
+## Enhancements
+
+- nctalk: Add TLSConfig to nctalk (#1195)
+- whatsapp: Handle broadcasts as groups in Whatsapp #1213
+- matrix: switch to upstream gomatrix #1219
+- api: support multiple websocket clients #1205
+
+## Bugfix
+
+- general: update vendor
+- zulip: Check location of avatarURL (zulip). Fixes #1214 (#1227)
+- nctalk: Fix issue with too many open files #1223
+- nctalk: Fix mentions #1222
+- nctalk: Fix message replays #1220
+
+This release couldn't exist without the following contributors:
+@gary-kim, @tilosp, @NikkyAI, @escoand, @42wim
+
+# v1.18.2
+
+## Bugfix
+
+- zulip: Fix error loop (zulip) (#1210)
+- whatsapp: Update whatsapp vendor and fix a panic (#1209)
+
+This release couldn't exist without the following contributors:
+@SuperSandro2000, @42wim
+
+# v1.18.1
+
+## New features
+
+- telegram: Support Telegram animated stickers (tgs) format (#1173). See https://github.com/42wim/matterbridge/wiki/Settings#mediaConverttgs for more info
+
+## Enhancements
+
+- matrix: Remove HTML formatting for push messages (#1188) (#1189)
+- mattermost: Use mattermost v5 module (#1192)
+
+## Bugfix
+
+- whatsapp: Handle panic in whatsapp. Fixes #1180 (#1184)
+- nctalk: Fix Nextcloud Talk connection failure (#1179)
+- matrix: Sleep when ratelimited on joins (matrix). Fixes #1201 (#1206)
+
+This release couldn't exist without the following contributors:
+@42wim, @BenWiederhake, @Dellle, @gary-kim
+
+# v1.18.0
+
+## New features
+
+- nctalk: new protocol added. Add Nextcloud Talk support #1167
+- general: Add an option to log into a file rather than stdout (#1168)
+- api: Add websocket to API (#970)
+
+## Enhancements
+
+- telegram: Fix MarkdownV2 support in Telegram (#1169)
+- whatsapp: Reload user information when a new contact is detected (whatsapp) (#1160)
+- api: Add sane RemoteNickFormat default for API (#1157)
+- irc: Skip gIRC built-in rate limiting (irc) (#1164)
+- irc: Only colour IRC nicks if there is one. (#1161)
+- docker: Combine runs to one layer (#1151)
+
+## Bugfix
+
+- general: Update dependencies for 1.18.0 release (#1175)
+
+Discord users are encouraged to upgrade, this release works with the move to the discord.com domain.
+
+This release couldn't exist without the following contributors:
+@42wim, @jlu5, @qaisjp, @TheHolyRoger, @SuperSandro2000, @gary-kim, @z3bra, @greenx, @haykam821, @nathanaelhoun
+
+# v1.17.5
+
+## Enhancements
+
+- irc: Add StripMarkdown option (irc). (#1145)
+- general: Increase debug logging with function,file and linenumber (#1147)
+- general: Update Dockerfile so inotify works (#1148)
+- matrix: Add an option to disable sending HTML to matrix. Fixes #1022 (#1135)
+- xmpp: Implement xep-0245 (xmpp). Closes #1137 (#1144)
+
+## Bugfix
+
+- discord: Fix #1120: replaceAction "_" crash (discord) (#1121)
+- discord: Fix #1049: missing space before embeds (discord) (#1124)
+- discord: Fix webhook EventUserAction messages being skipped (discord) (#1133)
+- matrix: Avoid creating invalid url when the user doesn't have an avatar (matrix) (#1130)
+- msteams: Ignore non-user messages (msteams). Fixes #1141 (#1149)
+- slack: Do not use webhooks when token is configured (slack) (fixes #1123) (#1134)
+- telegram: Fix forward from hidden users (telegram). Closes #1131 (#1143)
+- xmpp: Prevent re-requesting avatar data (xmpp) (#1117)
+
+This release couldn't exist without the following contributors:
+@qaisjp, @xnaas, @42wim, @Polynomdivision, @tfve
+
+# v1.17.4
+
+## Bugfix
+
+- general: Lowercase account names. Fixes #1108 (#1110)
+- msteams: Remove panics and retry polling on failure (msteams). Fixes #1104 (#1105
+- whatsapp: Update Rhymen/go-whatsapp. Fixes #1107 (#1109) (make whatsapp working again)
+- discord: Add an ID cache (discord). Fixes #1106 (#1111) (fix delete/edits with webhooks)
+
+# v1.17.3
+
+## Enhancements
+
+- xmpp: Implement User Avatar spoofing of XMPP users #1090
+- rocketchat: Relay Joins/Topic changes in RocketChat bridge (#1085)
+- irc: Add JoinDelay option (irc). Fixes #1084 (#1098)
+- slack: Clip too long messages on 3000 length (slack). Fixes #1081 (#1102)
+
+## Bugfix
+
+- general: Fix the behavior of ShowTopicChange and SyncTopic (#1086)
+- slack: Prevent image/message looping (slack). Fixes #1088 (#1096)
+- whatsapp: Ignore non-critical errors (whatsapp). Fixes #1094 (#1100)
+- irc: Add extra space before colon in attachments (irc). Fixes #1089 (#1101)
+
+This release couldn't exist without the following contributors:
+@42wim, @ldruschk, @qaisjp, @Polynomdivision
+
+# v1.17.2
+
+## Enhancements
+
+- slack: Update vendor slack-go/slack (#1068)
+- general: Update vendor d5/tengo (#1066)
+- general: Clarify terminology used in mapping group chat IDs to channels in config (#1079)
+
+## Bugfix
+
+- whatsapp: Update Rhymen/go-whatsapp vendor and whatsapp version (#1078). Fixes Media upload #1074
+- whatsapp: Reset start timestamp on reconnect (whatsapp). Fixes #1059 (#1064)
+
+This release couldn't exist without the following contributors:
+@42wim, @jheiselman
+
+# v1.17.1
+
+## Enhancements
+
+- docker: Remove build dependencies from final image (multistage build) #1057
+
+## Bugfix
+
+- general: Don't transmit typing events from ourselves #1056
+- general: Add support for build tags #1054
+- discord: Strip extra info from emotes (discord) #1052
+- msteams: fix macos build: Update vendor yaegashi/msgraph.go to v0.1.2 #1036
+- whatsapp: Update client version whatsapp. Fixes #1061 #1062
+
+This release couldn't exist without the following contributors:
+@awigen, @qaisjp, @42wim
+
+# v1.17.0
+
+## New features
+
+- msteams: new protocol added. Add initial Microsoft Teams support #967
+  See https://github.com/42wim/matterbridge/wiki/MS-Teams-setup for a complete walkthrough
+- discord: Add ability to procure avatars from the destination bridge #1000
+- matrix: Add support for avatars from matrix. #1007
+- general: support JSON and YAML config formats #1045
+
+## Enhancements
+
+- discord: Check only bridged channels for PermManageWebhooks #1001
+- irc: Be less lossy when throttling IRC messages #1004
+- keybase: updated library #1002, #1019
+- matrix: Rebase gomatrix vendor with upstream #1006
+- slack: Use upstream slack-go/slack again #1018
+- slack: Ignore ConnectingEvent #1041
+- slack: use blocks not attachments #1048
+- sshchat: Update vendor shazow/ssh-chat #1029
+- telegram: added markdownv2 mode for telegram #1037
+- whatsapp: Implement basic reconnect (whatsapp). Fixes #987 #1003
+
+## Bugfix
+
+- discord: Fix webhook permission checks sometimes failing #1043
+- discord: Fix #1027: warning when handling inbound webhooks #1044
+- discord: Fix duplicate separator on empty description/url (discord) #1035
+- matrix: Fix issue with underscores in links #999
+- slack: Fix #1039: messages sent to Slack being synced back #1046
+- telegram: Make avatars download work with mediaserverdownload (telegram). Fixes #920 
+
+This release couldn't exist without the following contributors:
+@qaisjp, @jakubgs, @burner1024, @notpushkin, @MartijnBraam, @42wim
+
+# v1.16.5
+
+- Fix version bump
+
+# v1.16.4
+
+## New features
+
+- whatsapp: Add support for WhatsApp media (jpeg/png/gif) bridging (#974)
+- telegram: Add QuoteLengthLimit option (telegram) fixes #963 (#985)
+- telegram: Add DisableWebPagePreview option (telegram). Closes #980 (#994)
+
+## Enhancements
+
+- general: update dependencies
+- tengo: update to tengo v2
+- general: Add Docker Compose configuration (#990)
+
+## Bugfix
+
+- general: Fail with message instead of panic. #988 (#991)
+- telegram: Add extra mimetypes to docker image. Fixes #969
+- discord: Fix channel ID problem with multiple gateways (discord). Fixes #953 (#977)
+- discord: Show file comment in webhook if normal message is empty (discord). Fixes #962 (#995)
+- matrix: Fix parsing issues - Disable smartypants in markdown parser. Fixes #989, #983 (#993)
+- sshchat: Fix duplicated messages (sshchat). Fixes #950 (#996)
+
+This release couldn't exist without the following contributors:
+@jwflory, @42wim, @pbek, @Humorhenker, @c0ncord2, @glazzara
+
+# v1.16.3
+
+## Bugfix
+
+- slack: Fix issues with ratelimiting #959
+- mattermost: Fix bug when using webhookURL and login/token together #960
+
+# v1.16.2
+
+## New features
+
+- keybase: Add support for receiving attachments (keybase) (#923)
+
+## Enhancements
+
+- general: Switch to new emoji library kyokomi/emoji (#948)
+- general: Update markdown parsing library to github.com/gomarkdown/markdown (#944)
+- ssh-chat: Update shazow/ssh-chat dependency (#947)
+
+## Bugfix
+
+- slack: Fix issues with the slack block kit API #937 (#943).
+
+This release couldn't exist without the following contributors:
+@42wim, @bmpickford, @goncalor
+
+# v1.16.1
+
+## New features
+
+* rocketchat: add token support #892
+* matrix: Add support for uploading application/x and audio/x (matrix). #929
+
+## Enhancements
+
+* general: Do configuration validation on start-up. Fixes #888
+* general: updated vendored libraries (discord/whatsapp) #932
+* discord: user typing messages #914
+* slack: Convert slack bold/strike to correct markdown (slack). Fixes #918
+
+## Bugfix
+
+* discord: fix Failed to fetch information for members message. #894
+* discord: remove obsolete file upload links (discord). #931
+* slack: suppress unhandled HelloEvent message #913
+* mattermost: Fix panic on WebhookURL only setting (mattermost). #917
+* matrix: fix corrupted links between slack and matrix #924
+
+This release couldn't exist without the following contributors:
+@qaisjp, @hramrach, @42wim
+
+# v1.16.0
+
+## New features
+
+* keybase: new protocol added. Add initial Keybase Chat support #877 Thanks to @hyperobject
+* discord: Support webhook files in discord #872
+
+## Enhancements
+
+* general: update dependencies
+
+## Bugfix
+
+* discord: Underscores from Discord don't arrive correctly #864
+* xmpp: Fix possible panic at startup of the XMPP bridge #869
+* mattermost: Make getChannelIdTeam behave like GetChannelId for groups (mattermost) #873
+
+This release couldn't exist without the following contributors:
+@hyperobject, @42wim, @bucko909, @MOZGIII
+
+# v1.15.1
+
+## New features
+* discord: Support webhook message deletions (discord) (#853)
+
+## Enhancements
+
+* discord: Support bulk deletions #851
+* discord: Support channels in categories #863 (use category/channel. See matterbridge.toml.sample for more info)
+* mattermost: Add an option to skip the Mattermost server version check #849
+
+## Bugfix
+
+* xmpp: fix segfault when disconnected/reconnected #856
+* telegram: fix panic in handleEntities #858
+
+This release couldn't exist without the following contributors:
+@42wim, @qaisjp, @joohoi
+
+# v1.15.0
+## New features
+* Add scripting (tengo) support for every outgoing message (#806)
+  See https://github.com/42wim/matterbridge/wiki/Settings#tengo and 
+  https://github.com/42wim/matterbridge/wiki/Settings#outmessage for more information
+* Add tengo support to RemoteNickFormat (#793)
+  See https://github.com/42wim/matterbridge/wiki/Settings#remotenickformat-2
+  * Deprecated `Message` under `[tengo]` to `InMessage`
+
+## Enhancements
+  * general: Forward only user-typing messages if supported by protocol (#832)
+  * general: updated wiki with all possible settings: https://github.com/42wim/matterbridge/wiki/Settings
+  * tengo: Add msg event to tengo
+  * xmpp: Verify TLS against JID domain, not the host. (xmpp) (#834)
+  * xmpp: Allow messages with timestamp (xmpp). Fixes #835 (#847)
+  * irc: Add verbose IRC joins/parts (ident@host) (#805)
+  See https://github.com/42wim/matterbridge/wiki/Settings#verbosejoinpart
+  * rocketchat: Add useraction support (rocketchat). Closes #772 (#794)
+
+## Bugfix
+  * slack: Fix regression in autojoining with legacy tokens (slack). Fixes #651 (#848)
+  * xmpp: Revert xmpp to orig behaviour. Closes #844
+* whatsapp: Update github.com/Rhymen/go-whatsapp vendor. Fixes #843
+* mattermost: Update channels of all teams (mattermost)
+
+This release couldn't exist without the following contributors:
+@42wim, @Helcaraxan, @chotaire, @qaisjp, @dajohi, @kousu
+
+# v1.14.4
+
+## Bugfix
+* mattermost: Add Id to EditMessage (mattermost). Fixes #802
+* mattermost: Fix panic on nil message.Post (mattermost). Fixes #804
+* mattermost: Handle unthreaded messages (mattermost). Fixes #803
+* mattermost: Use paging in initUser and UpdateUsers (mattermost)
+* slack: Add lacking clean-up in Slack synchronisation (#811)
+* slack: Disable user lookups on delete messages (slack) (#812)
+
+# v1.14.3
+
+## Bugfix
+* irc: Fix deadlock on reconnect (irc). Closes #757
+
+# v1.14.2
+
+## Bugfix
+* general: Update tengo vendor and load the stdlib. Fixes #789 (#792)
+* rocketchat: Look up #channel too (rocketchat). Fix #773 (#775)
+* slack: Ignore messagereplied and hidden messages (slack). Fixes #709 (#779)
+* telegram: Handle nil message (telegram). Fixes #777
+* irc: Use default nick if none specified (irc). Fixes #785
+* irc: Return when not connected and drop a message (irc). Fixes #786
+* irc: Revert fix for #722 (Support quits from irc correctly). Closes #781
+
+## Contributors
+This release couldn't exist without the following contributors:
+@42wim, @Helcaraxan, @dajohi
+
+# v1.14.1
+## Bugfix
+* slack: Fix crash double unlock (slack) (#771)
+
 # v1.14.0
 
 ## Breaking

ci/bintray.sh

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

contrib/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)
+}

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

@@ -0,0 +1,11 @@
+// +build !nomumble
+
+package bridgemap
+
+import (
+	bmumble "github.com/42wim/matterbridge/bridge/mumble"
+)
+
+func init() {
+	FullMap["mumble"] = bmumble.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

@@ -2,36 +2,9 @@ package bridgemap
 
 import (
 	"github.com/42wim/matterbridge/bridge"
-	"github.com/42wim/matterbridge/bridge/api"
-	"github.com/42wim/matterbridge/bridge/discord"
-	"github.com/42wim/matterbridge/bridge/gitter"
-	"github.com/42wim/matterbridge/bridge/irc"
-	"github.com/42wim/matterbridge/bridge/matrix"
-	"github.com/42wim/matterbridge/bridge/mattermost"
-	"github.com/42wim/matterbridge/bridge/rocketchat"
-	"github.com/42wim/matterbridge/bridge/slack"
-	"github.com/42wim/matterbridge/bridge/sshchat"
-	"github.com/42wim/matterbridge/bridge/steam"
-	"github.com/42wim/matterbridge/bridge/telegram"
-	"github.com/42wim/matterbridge/bridge/whatsapp"
-	"github.com/42wim/matterbridge/bridge/xmpp"
-	"github.com/42wim/matterbridge/bridge/zulip"
 )
 
-var FullMap = map[string]bridge.Factory{
-	"api":          api.New,
-	"discord":      bdiscord.New,
-	"gitter":       bgitter.New,
-	"irc":          birc.New,
-	"mattermost":   bmattermost.New,
-	"matrix":       bmatrix.New,
-	"rocketchat":   brocketchat.New,
-	"slack-legacy": bslack.NewLegacy,
-	"slack":        bslack.New,
-	"sshchat":      bsshchat.New,
-	"steam":        bsteam.New,
-	"telegram":     btelegram.New,
-	"whatsapp":     bwhatsapp.New,
-	"xmpp":         bxmpp.New,
-	"zulip":        bzulip.New,
-}
+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

@@ -1,6 +1,7 @@
 package gateway
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"regexp"
@@ -9,9 +10,11 @@ import (
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/d5/tengo/script"
+	"github.com/42wim/matterbridge/internal"
+	"github.com/d5/tengo/v2"
+	"github.com/d5/tengo/v2/stdlib"
 	lru "github.com/hashicorp/golang-lru"
-	"github.com/peterhellberg/emojilib"
+	"github.com/matterbridge/emoji"
 	"github.com/sirupsen/logrus"
 )
 
@@ -83,6 +86,7 @@ func (gw *Gateway) FindCanonicalMsgID(protocol string, mID string) string {
 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
@@ -102,6 +106,19 @@ func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
 	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
@@ -211,23 +228,6 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 		return channels
 	}
 
-	// irc quit is for the whole bridge, isn't a per channel quit.
-	// channel is empty when we quit
-	if msg.Event == config.EventJoinLeave && getProtocol(msg) == "irc" && msg.Channel == "" {
-		// if we only have one channel on this irc bridge it's got to be the sending one.
-		// don't send it back
-		if dest.Account == msg.Account && len(dest.Channels) == 1 && dest.Protocol == "irc" {
-			return channels
-		}
-		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
@@ -307,8 +307,6 @@ func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
 }
 
 func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) string {
-	br := gw.Bridges[msg.Account]
-	msg.Protocol = br.Protocol
 	if dest.GetBool("StripNick") {
 		re := regexp.MustCompile("[^a-zA-Z0-9]+")
 		msg.Username = re.ReplaceAllString(msg.Username, "")
@@ -316,6 +314,7 @@ func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) stri
 	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]
@@ -338,15 +337,21 @@ func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) stri
 			}
 			i++
 		}
-		nick = strings.Replace(nick, "{NOPINGNICK}", msg.Username[:i]+"​"+msg.Username[i:], -1)
+		nick = strings.ReplaceAll(nick, "{NOPINGNICK}", msg.Username[:i]+"\u200b"+msg.Username[i:])
 	}
 
-	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)
+	nick = strings.ReplaceAll(nick, "{BRIDGE}", br.Name)
+	nick = strings.ReplaceAll(nick, "{PROTOCOL}", br.Protocol)
+	nick = strings.ReplaceAll(nick, "{GATEWAY}", gw.Name)
+	nick = strings.ReplaceAll(nick, "{LABEL}", br.GetString("Label"))
+	nick = strings.ReplaceAll(nick, "{NICK}", msg.Username)
+	nick = strings.ReplaceAll(nick, "{USERID}", msg.UserID)
+	nick = strings.ReplaceAll(nick, "{CHANNEL}", msg.Channel)
+	tengoNick, err := gw.modifyUsernameTengo(msg, br)
+	if err != nil {
+		gw.logger.Errorf("modifyUsernameTengo error: %s", err)
+	}
+	nick = strings.ReplaceAll(nick, "{TENGO}", tengoNick)
 	return nick
 }
 
@@ -360,12 +365,28 @@ func (gw *Gateway) modifyAvatar(msg *config.Message, dest *bridge.Bridge) string
 }
 
 func (gw *Gateway) modifyMessage(msg *config.Message) {
-	if err := modifyMessageTengo(gw.BridgeValues().General.TengoModifyMessage, msg); err != nil {
+	if gw.BridgeValues().General.TengoModifyMessage != "" {
+		gw.logger.Warnf("General TengoModifyMessage=%s is deprecated and will be removed in v1.20.0, please move to Tengo InMessage=%s", gw.BridgeValues().General.TengoModifyMessage, gw.BridgeValues().General.TengoModifyMessage)
+	}
+
+	if err := modifyInMessageTengo(gw.BridgeValues().General.TengoModifyMessage, msg); err != nil {
 		gw.logger.Errorf("TengoModifyMessage failed: %s", err)
 	}
 
+	inMessage := gw.BridgeValues().Tengo.InMessage
+	if inMessage == "" {
+		inMessage = gw.BridgeValues().Tengo.Message
+		if inMessage != "" {
+			gw.logger.Warnf("Tengo Message=%s is deprecated and will be removed in v1.20.0, please move to Tengo InMessage=%s", inMessage, inMessage)
+		}
+	}
+
+	if err := modifyInMessageTengo(inMessage, msg); err != nil {
+		gw.logger.Errorf("Tengo.Message failed: %s", err)
+	}
+
 	// replace :emoji: to unicode
-	msg.Text = emojilib.Replace(msg.Text)
+	msg.Text = emoji.Sprint(msg.Text)
 
 	br := gw.Bridges[msg.Account]
 	// loop to replace messages
@@ -410,9 +431,15 @@ func (gw *Gateway) SendMessage(
 		}
 	}
 
+	// Only send irc notices to irc
+	if msg.Event == config.EventNoticeIRC && dest.Protocol != "irc" {
+		return "", nil
+	}
+
 	// Too noisy to log like other events
+	debugSendMessage := ""
 	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)
+		debugSendMessage = fmt.Sprintf("=> Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, rmsg.Channel, dest.Account, channel.Name)
 	}
 
 	msg.Channel = channel.Name
@@ -432,17 +459,34 @@ func (gw *Gateway) SendMessage(
 	}
 
 	// 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"
+	// this means that we didn't find it in the cache so set it to a "msg-parent-not-found" constant
 	if msg.ParentID == "" && rmsg.ParentID != "" {
-		msg.ParentID = "msg-parent-not-found"
+		msg.ParentID = config.ParentIDNotFound
 	}
 
+	drop, err := gw.modifyOutMessageTengo(rmsg, &msg, dest)
+	if err != nil {
+		gw.logger.Errorf("modifySendMessageTengo: %s", err)
+	}
+
+	if drop {
+		gw.logger.Debugf("=> Tengo dropping %#v from %s (%s) to %s (%s)", msg, msg.Account, rmsg.Channel, dest.Account, channel.Name)
+		return "", nil
+	}
+
+	if debugSendMessage != "" {
+		gw.logger.Debug(debugSendMessage)
+	}
 	// 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
 	}
 
+	defer func(t time.Time) {
+		gw.logger.Debugf("=> Send from %s (%s) to %s (%s) took %s", msg.Account, rmsg.Channel, dest.Account, channel.Name, time.Since(t))
+	}(time.Now())
+
 	mID, err := dest.Send(msg)
 	if err != nil {
 		return mID, err
@@ -494,7 +538,7 @@ func getProtocol(msg *config.Message) string {
 	return p[0]
 }
 
-func modifyMessageTengo(filename string, msg *config.Message) error {
+func modifyInMessageTengo(filename string, msg *config.Message) error {
 	if filename == "" {
 		return nil
 	}
@@ -502,9 +546,11 @@ func modifyMessageTengo(filename string, msg *config.Message) error {
 	if err != nil {
 		return err
 	}
-	s := script.New(res)
+	s := tengo.NewScript(res)
+	s.SetImports(stdlib.GetModuleMap(stdlib.AllModuleNames()...))
 	_ = s.Add("msgText", msg.Text)
 	_ = s.Add("msgUsername", msg.Username)
+	_ = s.Add("msgUserID", msg.UserID)
 	_ = s.Add("msgAccount", msg.Account)
 	_ = s.Add("msgChannel", msg.Channel)
 	c, err := s.Compile()
@@ -518,3 +564,90 @@ func modifyMessageTengo(filename string, msg *config.Message) error {
 	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("msgUserID", msg.UserID)
+	_ = 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) modifyOutMessageTengo(origmsg *config.Message, msg *config.Message, br *bridge.Bridge) (bool, error) {
+	filename := gw.BridgeValues().Tengo.OutMessage
+	var (
+		res  []byte
+		err  error
+		drop bool
+	)
+
+	if filename == "" {
+		res, err = internal.Asset("tengo/outmessage.tengo")
+		if err != nil {
+			return drop, err
+		}
+	} else {
+		res, err = ioutil.ReadFile(filename)
+		if err != nil {
+			return drop, 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)
+	_ = s.Add("msgUserID", msg.UserID)
+	_ = s.Add("msgDrop", drop)
+	c, err := s.Compile()
+	if err != nil {
+		return drop, err
+	}
+
+	if err := c.Run(); err != nil {
+		return drop, err
+	}
+
+	drop = c.Get("msgDrop").Bool()
+	msg.Text = c.Get("msgText").String()
+	msg.Username = c.Get("msgUsername").String()
+
+	return drop, nil
+}

gateway/gateway_test.go

@@ -15,10 +15,15 @@ import (
 
 var testconfig = []byte(`
 [irc.freenode]
+server=""
 [mattermost.test]
+server=""
 [gitter.42wim]
+server=""
 [discord.test]
+server=""
 [slack.test]
+server=""
 
 [[gateway]]
     name = "bridge1"
@@ -44,10 +49,15 @@ var testconfig = []byte(`
 
 var testconfig2 = []byte(`
 [irc.freenode]
+server=""
 [mattermost.test]
+server=""
 [gitter.42wim]
+server=""
 [discord.test]
+server=""
 [slack.test]
+server=""
 
 [[gateway]]
     name = "bridge1"
@@ -87,8 +97,11 @@ var testconfig2 = []byte(`
 
 var testconfig3 = []byte(`
 [irc.zzz]
+server=""
 [telegram.zzz]
+server=""
 [slack.zzz]
+server=""
 [[gateway]]
 name="bridge"
 enable=true
@@ -176,7 +189,6 @@ func TestNewRouter(t *testing.T) {
 	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))
@@ -521,7 +533,7 @@ func (s *ignoreTestSuite) TestIgnoreNicks() {
 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)
+		err := modifyInMessageTengo("bench.tengo", msg)
 		if err != nil {
 			return
 		}

gateway/handlers.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway/bridgemap"
 )
 
 // handleEventFailure handles failures and reconnects bridges.
@@ -168,7 +169,7 @@ 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" {
+		if dest.Protocol != "mattermost" && dest.Protocol != "telegram" && dest.Protocol != "xmpp" {
 			return true
 		}
 	case config.EventJoinLeave:
@@ -178,7 +179,7 @@ func (gw *Gateway) ignoreEvent(event string, dest *bridge.Bridge) bool {
 		}
 	case config.EventTopicChange:
 		// only relay topic change when used in some way on other side
-		if dest.GetBool("ShowTopicChange") && dest.GetBool("SyncTopic") {
+		if !dest.GetBool("ShowTopicChange") && !dest.GetBool("SyncTopic") {
 			return true
 		}
 	}
@@ -190,6 +191,14 @@ func (gw *Gateway) ignoreEvent(event string, dest *bridge.Bridge) bool {
 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

gateway/router.go

@@ -59,8 +59,14 @@ func NewRouter(rootLogger *logrus.Logger, cfg config.Config, bridgeMap map[strin
 // 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
 		}
@@ -125,7 +131,11 @@ func (r *Router) handleReceive() {
 		r.handleEventGetChannelMembers(&msg)
 		r.handleEventFailure(&msg)
 		r.handleEventRejoinChannels(&msg)
-		idx := 0
+
+		// 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
@@ -134,17 +144,26 @@ func (r *Router) handleReceive() {
 			}
 			msg.Timestamp = time.Now()
 			gw.modifyMessage(&msg)
-			if idx == 0 {
+			if !filesHandled {
 				gw.handleFiles(&msg)
+				filesHandled = true
 			}
 			for _, br := range gw.Bridges {
 				msgIDs = append(msgIDs, gw.handleMessage(&msg, br)...)
 			}
-			// only add the message ID if it doesn't already exists
-			if _, ok := gw.Messages.Get(msg.Protocol + " " + msg.ID); !ok && msg.ID != "" {
-				gw.Messages.Add(msg.Protocol+" "+msg.ID, msgIDs)
+
+			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 {
+					gw.Messages.Add(msg.Protocol+" "+msg.ID, msgIDs)
+				}
 			}
-			idx++
 		}
 	}
 }

go.mod

@@ -3,72 +3,62 @@ 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/BurntSushi/toml v0.0.0-20170318202913-d94612f9fc14 // indirect
-	github.com/Jeffail/gabs v1.1.1 // indirect
-	github.com/Philipp15b/go-steam v1.0.1-0.20180818081528-681bd9573329
-	github.com/bwmarrin/discordgo v0.19.0
-	github.com/d5/tengo v1.12.1
-	github.com/dfordsoft/golib v0.0.0-20180902042739-76ee6ab99bec
-	github.com/fsnotify/fsnotify v1.4.7
-	github.com/go-telegram-bot-api/telegram-bot-api v4.6.5-0.20181225215658-ec221ba9ea45+incompatible
-	github.com/google/gops v0.3.5
-	github.com/gopackage/ddp v0.0.0-20170117053602-652027933df4 // indirect
-	github.com/gopherjs/gopherjs v0.0.0-20180628210949-0892b62f0d9f // indirect
-	github.com/gorilla/schema v1.0.2
-	github.com/gorilla/websocket v1.4.0
-	github.com/hashicorp/golang-lru v0.5.0
-	github.com/hpcloud/tail v1.0.0 // indirect
-	github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7
-	github.com/jtolds/gls v4.2.1+incompatible // indirect
-	github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 // indirect
-	github.com/kr/pretty v0.1.0 // indirect
-	github.com/labstack/echo/v4 v4.0.0
-	github.com/lrstanley/girc v0.0.0-20190210212025-51b8e096d398
-	github.com/lusis/go-slackbot v0.0.0-20180109053408-401027ccfef5 // indirect
-	github.com/lusis/slack-test v0.0.0-20180109053238-3c758769bfa6 // indirect
-	github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20190210153444-cc9d05784d5d
-	github.com/matterbridge/go-whatsapp v0.0.1-0.20190301204034-f2f1b29d441b
-	github.com/matterbridge/go-xmpp v0.0.0-20180529212104-cd19799fba91
-	github.com/matterbridge/gomatrix v0.0.0-20190102230110-6f9631ca6dea
-	github.com/matterbridge/gozulipbot v0.0.0-20190212232658-7aa251978a18
-	github.com/matterbridge/logrus-prefixed-formatter v0.0.0-20180806162718-01618749af61
-	github.com/matterbridge/mautrix-whatsapp v0.0.0-20190301210046-3539cf52ed6e
-	github.com/mattermost/mattermost-server v5.5.0+incompatible
+	github.com/Philipp15b/go-steam v1.0.1-0.20200727090957-6ae9b3c0a560
+	github.com/Rhymen/go-whatsapp v0.1.2-0.20201226125722-8029c28f5c5a
+	github.com/RocketChat/Rocket.Chat.Go.SDK v0.0.0-20200922220614-e4a51dfb52e4 // indirect
+	github.com/d5/tengo/v2 v2.6.2
+	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-20201113031856-722100d81a8e
+	github.com/google/gops v0.3.14
+	github.com/gorilla/schema v1.2.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.17
+	github.com/lrstanley/girc v0.0.0-20190801035559-4fc93959e1a7
+	github.com/matrix-org/gomatrix v0.0.0-20200827122206-7dd5e2a05bcd
+	github.com/matterbridge/Rocket.Chat.Go.SDK v0.0.0-20201206215757-c1d86d75b9f8
+	github.com/matterbridge/discordgo v0.22.1
+	github.com/matterbridge/emoji v2.1.1-0.20191117213217-af507f6b02db+incompatible
+	github.com/matterbridge/go-xmpp v0.0.0-20200418225040-c8a3a57b4050
+	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.30.1
+	github.com/mattn/godown v0.0.1
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/missdeer/golib v1.0.4
+	github.com/mitchellh/mapstructure v1.3.3 // indirect
 	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/nicksnyder/go-i18n v1.4.0 // indirect
-	github.com/nlopes/slack v0.5.0
-	github.com/onsi/ginkgo v1.6.0 // indirect
-	github.com/onsi/gomega v1.4.1 // indirect
-	github.com/paulrosania/go-charset v0.0.0-20151028000031-621bb39fcc83
-	github.com/pborman/uuid v0.0.0-20160216163710-c55201b03606 // indirect
-	github.com/peterhellberg/emojilib v0.0.0-20190124112554-c18758d55320
-	github.com/pkg/errors v0.8.0 // indirect
+	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/russross/blackfriday v1.6.0
 	github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca
-	github.com/shazow/ssh-chat v0.0.0-20190125184227-81d7e1686296
-	github.com/sirupsen/logrus v1.3.0
-	github.com/smartystreets/assertions v0.0.0-20180803164922-886ec427f6b9 // indirect
-	github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a // indirect
-	github.com/spf13/viper v1.3.1
-	github.com/stretchr/testify v1.3.0
-	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
+	github.com/shazow/ssh-chat v1.10.1
+	github.com/sirupsen/logrus v1.7.0
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e // indirect
+	github.com/slack-go/slack v0.7.4
+	github.com/spf13/afero v1.3.4 // indirect
+	github.com/spf13/cast v1.3.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/viper v1.7.1
+	github.com/stretchr/testify v1.6.1
+	github.com/vincent-petithory/dataurl v0.0.0-20191104211930-d1553a71de50
+	github.com/writeas/go-strip-markdown v2.0.1+incompatible
 	github.com/x-cray/logrus-prefixed-formatter v0.5.2 // indirect
-	github.com/zfjagann/golang-ring v0.0.0-20190106091943-a88bb6aef447
-	gitlab.com/golang-commonmark/html v0.0.0-20180917080848-cfaf75183c4a // indirect
-	gitlab.com/golang-commonmark/linkify v0.0.0-20180917065525-c22b7bdb1179 // indirect
-	gitlab.com/golang-commonmark/markdown v0.0.0-20181102083822-772775880e1f
-	gitlab.com/golang-commonmark/mdurl v0.0.0-20180912090424-e5bce34c34f2 // indirect
-	gitlab.com/golang-commonmark/puny v0.0.0-20180912090636-2cd490539afe // indirect
-	gitlab.com/opennota/wd v0.0.0-20180912061657-c5d65f63c638 // indirect
-	go.uber.org/atomic v1.3.2 // indirect
-	go.uber.org/multierr v1.1.0 // indirect
-	go.uber.org/zap v1.9.1 // indirect
-	golang.org/x/image v0.0.0-20190220214146-31aff87c08e9
-	gopkg.in/fsnotify.v1 v1.4.7 // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
-	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
+	github.com/yaegashi/msgraph.go v0.1.4
+	github.com/zfjagann/golang-ring v0.0.0-20190304061218-d34796e0a6c2
+	golang.org/x/image v0.0.0-20201208152932-35266b937fa6
+	golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5
+	gomod.garykim.dev/nc-talk v0.1.7
+	gopkg.in/olahol/melody.v1 v1.0.0-20170518105555-d52139073376
+	layeh.com/gumble v0.0.0-20200818122324-146f9205029b
 )
+
+replace github.com/Rhymen/go-whatsapp => github.com/tulir/go-whatsapp v0.3.16
+
+go 1.15

internal/bindata.go

@@ -0,0 +1,288 @@
+// Code generated by go-bindata. DO NOT EDIT.
+// sources:
+// tengo/outmessage.tengo
+
+package internal
+
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data []byte, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(bytes.NewBuffer(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+
+type asset struct {
+	bytes []byte
+	info  fileInfoEx
+}
+
+type fileInfoEx interface {
+	os.FileInfo
+	MD5Checksum() string
+}
+
+type bindataFileInfo struct {
+	name        string
+	size        int64
+	mode        os.FileMode
+	modTime     time.Time
+	md5checksum string
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) MD5Checksum() string {
+	return fi.md5checksum
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _bindataTengoOutmessagetengo = []byte(
+	"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x91\x3d\x8f\xda\x40\x10\x86\xfb\xfd\x15\x13\x37\xb1\x2d\x07\xe7\xa3" +
+	"\xb3\x64\x59\x11\x45\x94\x2e\x8a\x92\x0a\xd0\xb1\xac\x07\x33\xd2\x7a\xc7\x1a\x8f\x31\x88\xe3\xbf\x9f\xcc\x01\x47" +
+	"\x7f\xc5\x75\xef\xae\x9e\x9d\x77\x1f\x4d\x9e\x9a\xbd\x15\xb2\x1b\x8f\x3d\xd8\xbd\x25\x3f\x45\x30\x82\xb6\xfe\xc2" +
+	"\xc1\x1f\x0b\x43\xe1\xa7\x73\x3c\x04\xcd\x80\xc2\x1f\x61\x65\xc7\x7e\xca\xf3\x9d\x0d\x01\x2f\xf1\x97\x55\x1c\xed" +
+	"\xd1\xf0\xa0\x77\x98\x07\x7d\xa3\x79\xd0\x3b\xce\x83\xde\xf8\xd7\x9e\x51\x48\xb1\x30\x6d\xdf\xfc\xc3\x83\x66\xd0" +
+	"\xf6\xcd\xff\x1e\x25\xd8\x16\x4d\x9a\x1b\xa3\x78\x50\x28\x4a\xa0\xb6\x63\xd1\x38\x9a\xce\x51\x62\x4c\x9e\x43\xaf" +
+	"\x42\x1d\x90\x38\x70\xec\x59\xfa\xe9\x8e\xb6\x30\xe2\x67\x41\x08\xac\xd0\x63\xa8\x29\x34\xa0\x0c\x36\x5c\xc0\x8d" +
+	"\x50\xdd\x20\x8c\x78\x7d\xac\x3b\x84\xdf\x7f\xe7\xb7\x01\xb4\x7d\xd0\x84\xb2\x84\x88\xc4\x45\x70\x32\x00\x00\x82" +
+	"\xd3\x3f\xa6\xfe\x99\xe0\x93\xe3\xb6\x23\x8f\xf1\x7a\x79\xf8\xfa\x23\xae\x8a\x65\x7d\xfa\x96\x7d\x3f\xc7\x55\x91" +
+	"\x5d\x63\x52\x25\xd5\xf3\x62\x51\xb8\xa0\xe2\x8b\xd5\x6a\x9d\x5c\xc6\x5c\x4d\x4b\xc1\x99\x60\xe7\xad\xc3\xf8\x26" +
+	"\x1f\x45\x89\x39\x9b\xf7\x6b\xe4\x29\x6d\x1f\x57\x00\x9f\x3e\xc6\x24\xcd\xcd\x4b\x00\x00\x00\xff\xff\x40\xb8\x54" +
+	"\xb8\x64\x02\x00\x00")
+
+func bindataTengoOutmessagetengoBytes() ([]byte, error) {
+	return bindataRead(
+		_bindataTengoOutmessagetengo,
+		"tengo/outmessage.tengo",
+	)
+}
+
+
+
+func bindataTengoOutmessagetengo() (*asset, error) {
+	bytes, err := bindataTengoOutmessagetengoBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{
+		name: "tengo/outmessage.tengo",
+		size: 612,
+		md5checksum: "",
+		mode: os.FileMode(420),
+		modTime: time.Unix(1555622139, 0),
+	}
+
+	a := &asset{bytes: bytes, info: info}
+
+	return a, nil
+}
+
+
+//
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+//
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, &os.PathError{Op: "open", Path: name, Err: os.ErrNotExist}
+}
+
+//
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+// nolint: deadcode
+//
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+//
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or could not be loaded.
+//
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, &os.PathError{Op: "open", Path: name, Err: os.ErrNotExist}
+}
+
+//
+// AssetNames returns the names of the assets.
+// nolint: deadcode
+//
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+//
+// _bindata is a table, holding each asset generator, mapped to its name.
+//
+var _bindata = map[string]func() (*asset, error){
+	"tengo/outmessage.tengo": bindataTengoOutmessagetengo,
+}
+
+//
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+//
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, &os.PathError{
+					Op: "open",
+					Path: name,
+					Err: os.ErrNotExist,
+				}
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, &os.PathError{
+			Op: "open",
+			Path: name,
+			Err: os.ErrNotExist,
+		}
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+
+var _bintree = &bintree{Func: nil, Children: map[string]*bintree{
+	"tengo": {Func: nil, Children: map[string]*bintree{
+		"outmessage.tengo": {Func: bindataTengoOutmessagetengo, Children: map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}

internal/tengo/outmessage.tengo

@@ -0,0 +1,25 @@
+/*
+variables available 
+read-only:
+inAccount, inProtocol, inChannel, inGateway
+outAccount, outProtocol, outChannel, outGateway
+
+read-write:
+msgText, msgUsername
+*/
+
+text := import("text")
+
+// start - strip irc colors 
+// if we're not sending to an irc bridge we strip the IRC colors
+if inProtocol == "irc" && outProtocol != "irc" {
+    re := text.re_compile(`\x03(?:\d{1,2}(?:,\d{1,2})?)?|[[:cntrl:]]`)
+    msgText=re.replace(msgText,"")
+}
+// end - strip irc colors
+
+// strip custom emoji
+if inProtocol == "discord" {
+    re := text.re_compile(`<a?(:.*?:)[0-9]+>`)
+    msgText=re.replace(msgText,"$1")
+}

matterbridge.go

@@ -4,6 +4,7 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"runtime"
 	"strings"
 
 	"github.com/42wim/matterbridge/bridge/config"
@@ -15,7 +16,7 @@ import (
 )
 
 var (
-	version = "1.14.0"
+	version = "1.21.1-dev"
 	githash string
 
 	flagConfig  = flag.String("conf", "matterbridge.toml", "config file")
@@ -50,6 +51,15 @@ func main() {
 	cfg := config.NewConfig(rootLogger, *flagConfig)
 	cfg.BridgeValues().General.Debug = *flagDebug
 
+	// if logging to a file, ensure it is closed when the program terminates
+	// nolint:errcheck
+	defer func() {
+		if f, ok := rootLogger.Out.(*os.File); ok {
+			f.Sync()
+			f.Close()
+		}
+	}()
+
 	r, err := gateway.NewRouter(rootLogger, cfg, bridgemap.FullMap)
 	if err != nil {
 		logger.Fatalf("Starting gateway failed: %s", err)
@@ -67,17 +77,31 @@ func setupLogger() *logrus.Logger {
 		Formatter: &prefixed.TextFormatter{
 			PrefixPadding: 13,
 			DisableColors: true,
-			FullTimestamp: true,
 		},
 		Level: logrus.InfoLevel,
 	}
 	if *flagDebug || os.Getenv("DEBUG") == "1" {
+		logger.SetReportCaller(true)
 		logger.Formatter = &prefixed.TextFormatter{
-			PrefixPadding:   13,
-			DisableColors:   true,
-			FullTimestamp:   false,
-			ForceFormatting: true,
+			PrefixPadding: 13,
+			DisableColors: true,
+			FullTimestamp: false,
+
+			CallerFormatter: func(function, file string) string {
+				return fmt.Sprintf(" [%s:%s]", function, file)
+			},
+			CallerPrettyfier: func(f *runtime.Frame) (string, string) {
+				sp := strings.SplitAfter(f.File, "/matterbridge/")
+				filename := f.File
+				if len(sp) > 1 {
+					filename = sp[1]
+				}
+				s := strings.Split(f.Function, ".")
+				funcName := s[len(s)-1]
+				return funcName, fmt.Sprintf("%s:%d", filename, f.Line)
+			},
 		}
+
 		logger.Level = logrus.DebugLevel
 		logger.WithFields(logrus.Fields{"prefix": "main"}).Info("Enabling debug logging.")
 	}

matterclient/channels.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"strings"
 
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 // GetChannels returns all channels we're members off
@@ -36,6 +36,16 @@ func (m *MMClient) GetChannelHeader(channelId string) string { //nolint:golint
 	return ""
 }
 
+func getNormalisedName(channel *model.Channel) string {
+	if channel.Type == model.CHANNEL_GROUP {
+		// (deprecated in favor of ReplaceAll in go 1.12)
+		res := strings.Replace(channel.DisplayName, ", ", "-", -1) //nolint: gocritic
+		res = strings.Replace(res, " ", "_", -1)                   //nolint: gocritic
+		return res
+	}
+	return channel.Name
+}
+
 func (m *MMClient) GetChannelId(name string, teamId string) string { //nolint:golint
 	m.RLock()
 	defer m.RUnlock()
@@ -45,14 +55,9 @@ func (m *MMClient) GetChannelId(name string, teamId string) string { //nolint:go
 
 	for _, t := range m.OtherTeams {
 		for _, channel := range append(t.Channels, t.MoreChannels...) {
-			if channel.Type == model.CHANNEL_GROUP {
-				res := strings.Replace(channel.DisplayName, ", ", "-", -1)
-				res = strings.Replace(res, " ", "_", -1)
-				if res == name {
-					return channel.Id
-				}
+			if getNormalisedName(channel) == name {
+				return channel.Id
 			}
-
 		}
 	}
 	return ""
@@ -62,7 +67,7 @@ func (m *MMClient) getChannelIdTeam(name string, teamId string) string { //nolin
 	for _, t := range m.OtherTeams {
 		if t.Id == teamId {
 			for _, channel := range append(t.Channels, t.MoreChannels...) {
-				if channel.Name == name {
+				if getNormalisedName(channel) == name {
 					return channel.Id
 				}
 			}
@@ -80,12 +85,7 @@ func (m *MMClient) GetChannelName(channelId string) string { //nolint:golint
 		}
 		for _, channel := range append(t.Channels, t.MoreChannels...) {
 			if channel.Id == channelId {
-				if channel.Type == model.CHANNEL_GROUP {
-					res := strings.Replace(channel.DisplayName, ", ", "-", -1)
-					res = strings.Replace(res, " ", "_", -1)
-					return res
-				}
-				return channel.Name
+				return getNormalisedName(channel)
 			}
 		}
 	}
@@ -166,23 +166,42 @@ func (m *MMClient) JoinChannel(channelId string) error { //nolint:golint
 	return nil
 }
 
+func (m *MMClient) UpdateChannelsTeam(teamID string) error {
+	mmchannels, resp := m.Client.GetChannelsForTeamForUser(teamID, m.User.Id, false, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
+	}
+	for idx, t := range m.OtherTeams {
+		if t.Id == teamID {
+			m.Lock()
+			m.OtherTeams[idx].Channels = mmchannels
+			m.Unlock()
+		}
+	}
+
+	mmchannels, resp = m.Client.GetPublicChannelsForTeam(teamID, 0, 5000, "")
+	if resp.Error != nil {
+		return errors.New(resp.Error.DetailedError)
+	}
+	for idx, t := range m.OtherTeams {
+		if t.Id == teamID {
+			m.Lock()
+			m.OtherTeams[idx].MoreChannels = mmchannels
+			m.Unlock()
+		}
+	}
+	return nil
+}
+
 func (m *MMClient) UpdateChannels() error {
-	mmchannels, resp := m.Client.GetChannelsForTeamForUser(m.Team.Id, m.User.Id, "")
-	if resp.Error != nil {
-		return errors.New(resp.Error.DetailedError)
+	if err := m.UpdateChannelsTeam(m.Team.Id); err != nil {
+		return err
 	}
-	m.Lock()
-	m.Team.Channels = mmchannels
-	m.Unlock()
-
-	mmchannels, resp = m.Client.GetPublicChannelsForTeam(m.Team.Id, 0, 5000, "")
-	if resp.Error != nil {
-		return errors.New(resp.Error.DetailedError)
+	for _, t := range m.OtherTeams {
+		if err := m.UpdateChannelsTeam(t.Id); err != nil {
+			return err
+		}
 	}
-
-	m.Lock()
-	m.Team.MoreChannels = mmchannels
-	m.Unlock()
 	return nil
 }
 

matterclient/helpers.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/gorilla/websocket"
 	"github.com/jpillora/backoff"
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 func (m *MMClient) doLogin(firstConnection bool, b *backoff.Backoff) error {
@@ -132,18 +132,29 @@ func (m *MMClient) initUser() error {
 		return resp.Error
 	}
 	for _, team := range teams {
-		mmusers, resp := m.Client.GetUsersInTeam(team.Id, 0, 50000, "")
+		idx := 0
+		max := 200
+		usermap := make(map[string]*model.User)
+		mmusers, resp := m.Client.GetUsersInTeam(team.Id, idx, max, "")
 		if resp.Error != nil {
 			return errors.New(resp.Error.DetailedError)
 		}
-		usermap := make(map[string]*model.User)
-		for _, user := range mmusers {
-			usermap[user.Id] = user
+		for len(mmusers) > 0 {
+			for _, user := range mmusers {
+				usermap[user.Id] = user
+			}
+			mmusers, resp = m.Client.GetUsersInTeam(team.Id, idx, max, "")
+			if resp.Error != nil {
+				return errors.New(resp.Error.DetailedError)
+			}
+			idx++
+			time.Sleep(time.Millisecond * 200)
 		}
+		m.logger.Infof("found %d users in team %s", len(usermap), team.Name)
 
 		t := &Team{Team: team, Users: usermap, Id: team.Id}
 
-		mmchannels, resp := m.Client.GetChannelsForTeamForUser(team.Id, m.User.Id, "")
+		mmchannels, resp := m.Client.GetChannelsForTeamForUser(team.Id, m.User.Id, false, "")
 		if resp.Error != nil {
 			return resp.Error
 		}
@@ -175,15 +186,19 @@ func (m *MMClient) serverAlive(firstConnection bool, b *backoff.Backoff) error {
 		if resp.Error != nil {
 			return fmt.Errorf("%#v", resp.Error.Error())
 		}
-		if firstConnection && !supportedVersion(resp.ServerVersion) {
+		if firstConnection && !m.SkipVersionCheck && !supportedVersion(resp.ServerVersion) {
 			return fmt.Errorf("unsupported mattermost version: %s", resp.ServerVersion)
 		}
-		m.ServerVersion = resp.ServerVersion
-		if m.ServerVersion == "" {
-			m.logger.Debugf("Server not up yet, reconnecting in %s", d)
-			time.Sleep(d)
+		if !m.SkipVersionCheck {
+			m.ServerVersion = resp.ServerVersion
+			if m.ServerVersion == "" {
+				m.logger.Debugf("Server not up yet, reconnecting in %s", d)
+				time.Sleep(d)
+			} else {
+				m.logger.Infof("Found version %s", m.ServerVersion)
+				return nil
+			}
 		} else {
-			m.logger.Infof("Found version %s", m.ServerVersion)
 			return nil
 		}
 	}

matterclient/matterclient.go

@@ -11,19 +11,20 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/jpillora/backoff"
 	prefixed "github.com/matterbridge/logrus-prefixed-formatter"
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/sirupsen/logrus"
 )
 
 type Credentials struct {
-	Login         string
-	Team          string
-	Pass          string
-	Token         string
-	CookieToken   bool
-	Server        string
-	NoTLS         bool
-	SkipTLSVerify bool
+	Login            string
+	Team             string
+	Pass             string
+	Token            string
+	CookieToken      bool
+	Server           string
+	NoTLS            bool
+	SkipTLSVerify    bool
+	SkipVersionCheck bool
 }
 
 type Message struct {
@@ -68,6 +69,7 @@ type MMClient struct {
 	logger     *logrus.Entry
 	rootLogger *logrus.Logger
 	lruCache   *lru.Cache
+	allevents  bool
 }
 
 // New will instantiate a new Matterclient with the specified login details without connecting.
@@ -118,6 +120,10 @@ func (m *MMClient) SetLogLevel(level string) {
 	}
 }
 
+func (m *MMClient) EnableAllEvents() {
+	m.allevents = true
+}
+
 // Login tries to connect the client with the loging details with which it was initialized.
 func (m *MMClient) Login() error {
 	// check if this is a first connect or a reconnection
@@ -216,9 +222,21 @@ func (m *MMClient) WsReceiver() {
 			if msg.Post != nil {
 				if msg.Text != "" || len(msg.Post.FileIds) > 0 || msg.Post.Type == "slack_attachment" {
 					m.MessageChan <- msg
+					continue
 				}
 			}
-			continue
+			if m.allevents {
+				m.MessageChan <- msg
+				continue
+			}
+			switch msg.Raw.Event {
+			case model.WEBSOCKET_EVENT_USER_ADDED,
+				model.WEBSOCKET_EVENT_USER_REMOVED,
+				model.WEBSOCKET_EVENT_CHANNEL_CREATED,
+				model.WEBSOCKET_EVENT_CHANNEL_DELETED:
+				m.MessageChan <- msg
+				continue
+			}
 		}
 
 		var response model.WebSocketResponse

matterclient/messages.go

@@ -3,7 +3,7 @@ package matterclient
 import (
 	"strings"
 
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 func (m *MMClient) parseActionPost(rmsg *Message) {
@@ -83,7 +83,7 @@ func (m *MMClient) DeleteMessage(postId string) error { //nolint:golint
 }
 
 func (m *MMClient) EditMessage(postId string, text string) (string, error) { //nolint:golint
-	post := &model.Post{Message: text}
+	post := &model.Post{Message: text, Id: postId}
 	res, resp := m.Client.UpdatePost(postId, post)
 	if resp.Error != nil {
 		return "", resp.Error

matterclient/users.go

@@ -2,8 +2,9 @@ package matterclient
 
 import (
 	"errors"
+	"time"
 
-	"github.com/mattermost/mattermost-server/model"
+	"github.com/mattermost/mattermost-server/v5/model"
 )
 
 func (m *MMClient) GetNickName(userId string) string { //nolint:golint
@@ -99,15 +100,25 @@ func (m *MMClient) GetUsers() map[string]*model.User {
 }
 
 func (m *MMClient) UpdateUsers() error {
-	mmusers, resp := m.Client.GetUsers(0, 50000, "")
+	idx := 0
+	max := 200
+	mmusers, resp := m.Client.GetUsers(idx, max, "")
 	if resp.Error != nil {
 		return errors.New(resp.Error.DetailedError)
 	}
-	m.Lock()
-	for _, user := range mmusers {
-		m.Users[user.Id] = user
+	for len(mmusers) > 0 {
+		m.Lock()
+		for _, user := range mmusers {
+			m.Users[user.Id] = user
+		}
+		m.Unlock()
+		mmusers, resp = m.Client.GetUsers(idx, max, "")
+		time.Sleep(time.Millisecond * 300)
+		if resp.Error != nil {
+			return errors.New(resp.Error.DetailedError)
+		}
+		idx++
 	}
-	m.Unlock()
 	return nil
 }
 

matterhook/matterhook.go

@@ -14,7 +14,7 @@ import (
 	"time"
 
 	"github.com/gorilla/schema"
-	"github.com/nlopes/slack"
+	"github.com/slack-go/slack"
 )
 
 // OMessage for mattermost incoming webhook. (send to mattermost)