Remove debug print-out

Clean-up: remove test/debug code
Add initial support for stream management
2025-11-07 18:53:44 -08:00 · 2019-07-31 18:54:49 +02:00 · 2019-07-31 18:51:16 +02:00 · 2019-07-31 18:47:30 +02:00
67 changed files with 713 additions and 2463 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,28 +0,0 @@
-# Fluux XMPP Changelog
-
-## v0.3.0
-
-### Changes
-
- Update requirements to go1.13
- Add a websocket transport
- Add Client.SendIQ method
- Add IQ result routes to the Router
- Fix SIGSEGV in xmpp_component (#126)
- Add tests for Component and code style fixes
-
-## v0.2.0
-
-### Changes
-
- XMPP Over Websocket support
- Add support for getting IQ responses to client IQ queries (synchronously or asynchronously, passing an handler
-  function).
- Implement X-OAUTH2 authentication method. You can read more details here:
-  [Understanding ejabberd OAuth Support & Roadmap: Step 4](https://blog.process-one.net/understanding-ejabberd-oauth-support-roadmap/)
- Fix issues in the stanza builder when trying to add text inside and XMPP node.
- Fix issues with unescaped % characters in XMPP payload.
-
-### Code migration guide
-
-TODO
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-FROM golang:1.13
+FROM golang:1.12
 WORKDIR /xmpp
 RUN curl -o codecov.sh -s https://codecov.io/bash && chmod +x codecov.sh
 COPY . ./
--- a/README.md
+++ b/README.md
@@ -34,8 +34,8 @@ Here is an example code to configure a client to allow connecting to a server wi
 config := xmpp.Config{
 	Address:      "localhost:5222",
 	Jid:          "test@localhost",
-	Credential:   xmpp.Password("Test"),
-	TLSConfig:    tls.Config{InsecureSkipVerify: true},
+	Password:     "test",
+	TLSConfig:     tls.Config{InsecureSkipVerify: true},
 }
 ```

@@ -52,9 +52,7 @@ config := xmpp.Config{
  - [XEP-0355: Namespace Delegation](https://xmpp.org/extensions/xep-0355.html)
  - [XEP-0356: Privileged Entity](https://xmpp.org/extensions/xep-0356.html)

-## Package overview
-
-### Stanza subpackage
+## Stanza subpackage

 XMPP stanzas are basic and extensible XML elements. Stanzas (or sometimes special stanzas called 'nonzas') are used to 
 leverage the XMPP protocol features. During a session, a client (or a component) and a server will be exchanging stanzas
@@ -75,14 +73,6 @@ implement your own extensions directly in your own application.
 To learn more about the stanza package, you can read more in the
 [stanza package documentation](https://github.com/FluuxIO/go-xmpp/blob/master/stanza/README.md).

-### Router
-
-TODO
-
-### Getting IQ response from server
-
-TODO
-
 ## Examples

 We have several [examples](https://github.com/FluuxIO/go-xmpp/tree/master/_examples) to help you get started using
@@ -104,11 +94,9 @@ import (

 func main() {
 	config := xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "localhost:5222",
-		},
+		Address:      "localhost:5222",
 		Jid:          "test@localhost",
-	    Credential:   xmpp.Password("Test"),
+		Password:     "test",
 		StreamLogger: os.Stdout,
 		Insecure:     true,
 	}
--- a/_examples/delegation/delegation.go
+++ b/_examples/delegation/delegation.go
@@ -11,12 +11,9 @@ import (

 func main() {
 	opts := xmpp.ComponentOptions{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "localhost:9999",
-			Domain:  "service.localhost",
-		},
-		Domain: "service.localhost",
-		Secret: "mypass",
+		Domain:  "service.localhost",
+		Secret:  "mypass",
+		Address: "localhost:9999",

 		// TODO: Move that part to a component discovery handler
 		Name:     "Test Component",
--- a/_examples/go.mod
+++ b/_examples/go.mod
@@ -1,6 +1,6 @@
 module gosrc.io/xmpp/_examples

-go 1.13
+go 1.12

 require (
 	github.com/processone/mpg123 v1.0.0
--- a/_examples/go.sum
+++ b/_examples/go.sum
@@ -1,107 +1,6 @@
-github.com/agnivade/wasmbrowsertest v0.3.1/go.mod h1:zQt6ZTdl338xxRaMW395qccVE2eQm0SjC/SDz0mPWQI=
-github.com/chromedp/cdproto v0.0.0-20190614062957-d6d2f92b486d/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190621002710-8cbd498dd7a0/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190812224334-39ef923dcb8d/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/cdproto v0.0.0-20190926234355-1b4886c6fad6/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/chromedp v0.3.1-0.20190619195644-fd957a4d2901/go.mod h1:mJdvfrVn594N9tfiPecUidF6W5jPRKHymqHfzbobPsM=
-github.com/chromedp/chromedp v0.4.0/go.mod h1:DC3QUn4mJ24dwjcaGQLoZrhm4X/uPHZ6spDbS2uFhm4=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/go-interpreter/wagon v0.5.1-0.20190713202023-55a163980b6c/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
-github.com/go-interpreter/wagon v0.6.0/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190908185732-236ed259b199/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
-github.com/knq/sysutil v0.0.0-20181215143952-f05b59f0f307/go.mod h1:BjPj+aVjl9FW/cCGiF3nGh5v+9Gd3VCgBQbod/GlMaQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mailru/easyjson v0.0.0-20190403194419-1ea4449da983/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190620125010-da37f6c1e481/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/processone/mpg123 v1.0.0/go.mod h1:X/FeL+h8vD1bYsG9tIWV3M2c4qNTZOficyvPVBP08go=
 github.com/processone/soundcloud v1.0.0/go.mod h1:kDLeWpkRtN3C8kIReQdxoiRi92P9xR6yW6qLOJnNWfY=
-github.com/sirupsen/logrus v1.0.5/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/twitchyliquid64/golang-asm v0.0.0-20190126203739-365674df15fc/go.mod h1:NoCfSFWosfqMqmmD7hApkirIK9ozpHjxRnRxs1l413A=
-go.coder.com/go-tools v0.0.0-20190317003359-0c6a35b74a16/go.mod h1:iKV5yK9t+J5nG9O3uF6KYdPEz3dyfMyB15MN1rbQ8Qw=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190110200230-915654e7eabc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190306220234-b354f8bf4d9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190618155005-516e3c20635f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190927073244-c990c680b611/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522 h1:bhOzK9QyoD0ogCnFro1m2mz41+Ib0oOhfJnBp5MR4K4=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gotest.tools v2.1.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
-gotest.tools/gotestsum v0.3.5/go.mod h1:Mnf3e5FUzXbkCfynWBGOwLssY7gTQgCHObK9tMpAriY=
-mvdan.cc/sh v2.6.4+incompatible/go.mod h1:IeeQbZq+x2SUGBensq/jge5lLQbS3XT2ktyp3wrt4x8=
-nhooyr.io/websocket v1.6.5 h1:8TzpkldRfefda5JST+CnOH135bzVPz5uzfn/AF+gVKg=
-nhooyr.io/websocket v1.6.5/go.mod h1:F259lAzPRAH0htX2y3ehpJe09ih1aSHN7udWki1defY=
--- a/_examples/muc_bot/README.md
+++ b/_examples/muc_bot/README.md
@@ -1,3 +0,0 @@
-# XMPP Multi-User (MUC) chat bot example
-
-This code shows how to build a simple basic XMPP Multi-User chat bot using Fluux Go XMPP library.
--- a/_examples/xmpp_component/xmpp_component.go
+++ b/_examples/xmpp_component/xmpp_component.go
@@ -10,12 +10,9 @@ import (

 func main() {
 	opts := xmpp.ComponentOptions{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "localhost:8888",
-			Domain:  "service2.localhost",
-		},
 		Domain:   "service2.localhost",
 		Secret:   "mypass",
+		Address:  "localhost:8888",
 		Name:     "Test Component",
 		Category: "gateway",
 		Type:     "service",
@@ -58,7 +55,7 @@ func handleMessage(_ xmpp.Sender, p stanza.Packet) {
 func discoInfo(c xmpp.Sender, p stanza.Packet, opts xmpp.ComponentOptions) {
 	// Type conversion & sanity checks
 	iq, ok := p.(stanza.IQ)
-	if !ok || iq.Type != stanza.IQTypeGet {
+	if !ok || iq.Type != "get" {
 		return
 	}

@@ -73,7 +70,7 @@ func discoInfo(c xmpp.Sender, p stanza.Packet, opts xmpp.ComponentOptions) {
 func discoItems(c xmpp.Sender, p stanza.Packet) {
 	// Type conversion & sanity checks
 	iq, ok := p.(stanza.IQ)
-	if !ok || iq.Type != stanza.IQTypeGet {
+	if !ok || iq.Type != "get" {
 		return
 	}

--- a/_examples/xmpp_echo/xmpp_echo.go
+++ b/_examples/xmpp_echo/xmpp_echo.go
@@ -15,11 +15,9 @@ import (

 func main() {
 	config := xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "localhost:5222",
-		},
+		Address:      "localhost:5222",
 		Jid:          "test@localhost",
-		Credential:   xmpp.Password("test"),
+		Password:     "test",
 		StreamLogger: os.Stdout,
 		Insecure:     true,
 		// TLSConfig: tls.Config{InsecureSkipVerify: true},
@@ -50,3 +48,6 @@ func handleMessage(s xmpp.Sender, p stanza.Packet) {
 	reply := stanza.Message{Attrs: stanza.Attrs{To: msg.From}, Body: msg.Body}
 	_ = s.Send(reply)
 }
+
+// TODO create default command line client to send message or to send an arbitrary XMPP sequence from a file,
+//   (using templates ?)
--- a/_examples/xmpp_jukebox/xmpp_jukebox.go
+++ b/_examples/xmpp_jukebox/xmpp_jukebox.go
@@ -32,11 +32,9 @@ func main() {

 	// 2. Prepare XMPP client
 	config := xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: *address,
-		},
-		Jid:        *jid,
-		Credential: xmpp.Password(*password),
+		Address:  *address,
+		Jid:      *jid,
+		Password: *password,
 		// StreamLogger: os.Stdout,
 		Insecure: true,
 	}
@@ -106,7 +104,7 @@ func handleIQ(s xmpp.Sender, p stanza.Packet, player *mpg123.Player) {

 func sendUserTune(s xmpp.Sender, artist string, title string) {
 	tune := stanza.Tune{Artist: artist, Title: title}
-	iq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeSet, Id: "usertune-1", Lang: "en"})
+	iq := stanza.NewIQ(stanza.Attrs{Type: "set", Id: "usertune-1", Lang: "en"})
 	payload := stanza.PubSub{Publish: &stanza.Publish{Node: "http://jabber.org/protocol/tune", Item: stanza.Item{Tune: &tune}}}
 	iq.Payload = &payload
 	_ = s.Send(iq)
--- a/_examples/xmpp_oauth2/xmpp_oauth2.go
+++ b/_examples/xmpp_oauth2/xmpp_oauth2.go
@@ -1,50 +0,0 @@
-/*
-xmpp_oauth2 is a demo client that connect on an XMPP server using OAuth2 and prints received messages.
-*/
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-
-	"gosrc.io/xmpp"
-	"gosrc.io/xmpp/stanza"
-)
-
-func main() {
-	config := xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "localhost:5222",
-			// TLSConfig: tls.Config{InsecureSkipVerify: true},
-		},
-		Jid:          "test@localhost",
-		Credential:   xmpp.OAuthToken("OdAIsBlY83SLBaqQoClAn7vrZSHxixT8"),
-		StreamLogger: os.Stdout,
-		// Insecure:     true,
-	}
-
-	router := xmpp.NewRouter()
-	router.HandleFunc("message", handleMessage)
-
-	client, err := xmpp.NewClient(config, router)
-	if err != nil {
-		log.Fatalf("%+v", err)
-	}
-
-	// If you pass the client to a connection manager, it will handle the reconnect policy
-	// for you automatically.
-	cm := xmpp.NewStreamManager(client, nil)
-	log.Fatal(cm.Run())
-}
-
-func handleMessage(s xmpp.Sender, p stanza.Packet) {
-	msg, ok := p.(stanza.Message)
-	if !ok {
-		_, _ = fmt.Fprintf(os.Stdout, "Ignoring packet: %T\n", p)
-		return
-	}
-
-	_, _ = fmt.Fprintf(os.Stdout, "Body = %s - from = %s\n", msg.Body, msg.From)
-}
--- a/_examples/xmpp_websocket/xmpp_websocket.go
+++ b/_examples/xmpp_websocket/xmpp_websocket.go
@@ -1,48 +0,0 @@
-/*
-xmpp_websocket is a demo client that connect on an XMPP server using websocket and prints received messages.ß
-*/
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-
-	"gosrc.io/xmpp"
-	"gosrc.io/xmpp/stanza"
-)
-
-func main() {
-	config := xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: "wss://localhost:5443/ws",
-		},
-		Jid:          "test@localhost",
-		Credential:   xmpp.Password("test"),
-		StreamLogger: os.Stdout,
-	}
-
-	router := xmpp.NewRouter()
-	router.HandleFunc("message", handleMessage)
-
-	client, err := xmpp.NewClient(config, router)
-	if err != nil {
-		log.Fatalf("%+v", err)
-	}
-
-	// If you pass the client to a connection manager, it will handle the reconnect policy
-	// for you automatically.
-	cm := xmpp.NewStreamManager(client, nil)
-	log.Fatal(cm.Run())
-}
-
-func handleMessage(s xmpp.Sender, p stanza.Packet) {
-	msg, ok := p.(stanza.Message)
-	if !ok {
-		_, _ = fmt.Fprintf(os.Stdout, "Ignoring packet: %T\n", p)
-		return
-	}
-
-	_, _ = fmt.Fprintf(os.Stdout, "Body = %s - from = %s\n", msg.Body, msg.From)
-}
--- a/auth.go
+++ b/auth.go
@@ -10,60 +10,29 @@ import (
 	"gosrc.io/xmpp/stanza"
 )

-// Credential is used to pass the type of secret that will be used to connect to XMPP server.
-// It can be either a password or an OAuth 2 bearer token.
-type Credential struct {
-	secret     string
-	mechanisms []string
-}
-
-func Password(pwd string) Credential {
-	credential := Credential{
-		secret:     pwd,
-		mechanisms: []string{"PLAIN"},
-	}
-	return credential
-}
-
-func OAuthToken(token string) Credential {
-	credential := Credential{
-		secret:     token,
-		mechanisms: []string{"X-OAUTH2"},
-	}
-	return credential
-}
-
-// ============================================================================
-// Authentication flow for SASL mechanisms
-
-func authSASL(socket io.ReadWriter, decoder *xml.Decoder, f stanza.StreamFeatures, user string, credential Credential) (err error) {
-	var matchingMech string
-	for _, mech := range credential.mechanisms {
-		if isSupportedMech(mech, f.Mechanisms.Mechanism) {
-			matchingMech = mech
+func authSASL(socket io.ReadWriter, decoder *xml.Decoder, f stanza.StreamFeatures, user string, password string) (err error) {
+	// TODO: Implement other type of SASL Authentication
+	havePlain := false
+	for _, m := range f.Mechanisms.Mechanism {
+		if m == "PLAIN" {
+			havePlain = true
 			break
 		}
 	}
-
-	switch matchingMech {
-	case "PLAIN", "X-OAUTH2":
-		// TODO: Implement other type of SASL mechanisms
-		return authPlain(socket, decoder, matchingMech, user, credential.secret)
-	default:
-		err := fmt.Errorf("no matching authentication (%v) supported by server: %v", credential.mechanisms, f.Mechanisms.Mechanism)
+	if !havePlain {
+		err := fmt.Errorf("PLAIN authentication is not supported by server: %v", f.Mechanisms.Mechanism)
 		return NewConnError(err, true)
 	}
+
+	return authPlain(socket, decoder, user, password)
 }

 // Plain authentication: send base64-encoded \x00 user \x00 password
-func authPlain(socket io.ReadWriter, decoder *xml.Decoder, mech string, user string, secret string) error {
-	raw := "\x00" + user + "\x00" + secret
+func authPlain(socket io.ReadWriter, decoder *xml.Decoder, user string, password string) error {
+	raw := "\x00" + user + "\x00" + password
 	enc := make([]byte, base64.StdEncoding.EncodedLen(len(raw)))
 	base64.StdEncoding.Encode(enc, []byte(raw))
-	_, err := fmt.Fprintf(socket, "<auth xmlns='%s' mechanism='%s'>%s</auth>", stanza.NSSASL, mech, enc)
-	if err != nil {
-		return err
-	}
+	fmt.Fprintf(socket, "<auth xmlns='%s' mechanism='PLAIN'>%s</auth>", stanza.NSSASL, enc)

 	// Next message should be either success or failure.
 	val, err := stanza.NextPacket(decoder)
@@ -82,13 +51,3 @@ func authPlain(socket io.ReadWriter, decoder *xml.Decoder, mech string, user str
 	}
 	return err
 }
-
-// isSupportedMech returns true if the mechanism is supported in the provided list.
-func isSupportedMech(mech string, mechanisms []string) bool {
-	for _, m := range mechanisms {
-		if mech == m {
-			return true
-		}
-	}
-	return false
-}
--- a/cert_checker.go
+++ b/cert_checker.go
@@ -51,7 +51,7 @@ func (c *ServerCheck) Check() error {
 	decoder := xml.NewDecoder(tcpconn)

 	// Send stream open tag
-	if _, err = fmt.Fprintf(tcpconn, clientStreamOpen, c.domain); err != nil {
+	if _, err = fmt.Fprintf(tcpconn, xmppStreamOpen, c.domain, stanza.NSClient, stanza.NSStream); err != nil {
 		return err
 	}

@@ -79,10 +79,7 @@ func (c *ServerCheck) Check() error {
 	}

 	if _, ok := f.DoesStartTLS(); ok {
-		_, err = fmt.Fprintf(tcpconn, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")
-		if err != nil {
-			return err
-		}
+		fmt.Fprintf(tcpconn, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")

 		var k stanza.TLSProceed
 		if err = decoder.DecodeElement(&k, nil); err != nil {
--- a/client.go
+++ b/client.go
@@ -1,11 +1,9 @@
 package xmpp

 import (
-	"context"
 	"encoding/xml"
 	"errors"
 	"fmt"
-	"io"
 	"net"
 	"time"

@@ -25,7 +23,6 @@ const (
 	StateConnected
 	StateSessionEstablished
 	StateStreamError
-	StatePermanentError
 )

 // Event is a structure use to convey event changes related to client state. This
@@ -50,7 +47,7 @@ type SMState struct {

 // EventHandler is use to pass events about state of the connection to
 // client implementation.
-type EventHandler func(Event) error
+type EventHandler func(Event)

 type EventManager struct {
 	// Store current state
@@ -84,16 +81,15 @@ func (em EventManager) streamError(error, desc string) {
 // Client
 // ============================================================================

-var ErrCanOnlySendGetOrSetIq = errors.New("SendIQ can only send get and set IQ stanzas")
-
 // Client is the main structure used to connect as a client on an XMPP
 // server.
 type Client struct {
 	// Store user defined options and states
 	config Config
 	// Session gather data that can be accessed by users of this library
-	Session   *Session
-	transport Transport
+	Session *Session
+	// TCP level connection / can be replaced by a TLS session after starttls
+	conn net.Conn
 	// Router is used to dispatch packets
 	router *Router
 	// Track and broadcast connection state
@@ -114,8 +110,8 @@ func NewClient(config Config, r *Router) (c *Client, err error) {
 		return nil, NewConnError(err, true)
 	}

-	if config.Credential.secret == "" {
-		err = errors.New("missing credential")
+	if config.Password == "" {
+		err = errors.New("missing password")
 		return nil, NewConnError(err, true)
 	}

@@ -137,6 +133,8 @@ func NewClient(config Config, r *Router) (c *Client, err error) {
 			}
 		}
 	}
+	config.Address = ensurePort(config.Address, 5222)
+
 	c = new(Client)
 	c.config = config
 	c.router = r
@@ -145,15 +143,6 @@ func NewClient(config Config, r *Router) (c *Client, err error) {
 		c.config.ConnectTimeout = 15 // 15 second as default
 	}

-	if config.TransportConfiguration.Domain == "" {
-		config.TransportConfiguration.Domain = config.parsedJid.Domain
-	}
-	c.transport = NewClientTransport(config.TransportConfiguration)
-
-	if config.StreamLogger != nil {
-		c.transport.LogTraffic(config.StreamLogger)
-	}
-
 	return
 }

@@ -169,44 +158,38 @@ func (c *Client) Connect() error {
 func (c *Client) Resume(state SMState) error {
 	var err error

-	streamId, err := c.transport.Connect()
+	c.conn, err = net.DialTimeout("tcp", c.config.Address, time.Duration(c.config.ConnectTimeout)*time.Second)
 	if err != nil {
 		return err
 	}
 	c.updateState(StateConnected)

 	// Client is ok, we now open XMPP session
-	if c.Session, err = NewSession(c.transport, c.config, state); err != nil {
-		c.transport.Close()
+	if c.conn, c.Session, err = NewSession(c.conn, c.config, state); err != nil {
 		return err
 	}
-	c.Session.StreamId = streamId
 	c.updateState(StateSessionEstablished)

 	// Start the keepalive go routine
 	keepaliveQuit := make(chan struct{})
-	go keepalive(c.transport, keepaliveQuit)
+	go keepalive(c.conn, keepaliveQuit)
 	// Start the receiver go routine
 	state = c.Session.SMState
-	// Leaving this channel here for later. Not used atm. We should return this instead of an error because right
-	// now the returned error is lost in limbo.
-	errChan := make(chan error)
-	go c.recv(state, keepaliveQuit, errChan)
+	go c.recv(state, keepaliveQuit)

 	// We're connected and can now receive and send messages.
 	//fmt.Fprintf(client.conn, "<presence xml:lang='en'><show>%s</show><status>%s</status></presence>", "chat", "Online")
 	// TODO: Do we always want to send initial presence automatically ?
 	// Do we need an option to avoid that or do we rely on client to send the presence itself ?
-	_, err = fmt.Fprintf(c.transport, "<presence/>")
+	fmt.Fprintf(c.Session.streamLogger, "<presence/>")

 	return err
 }

 func (c *Client) Disconnect() {
+	_ = c.SendRaw("</stream:stream>")
 	// TODO: Add a way to wait for stream close acknowledgement from the server for clean disconnect
-	if c.transport != nil {
-		_ = c.transport.Close()
-	}
+	_ = c.conn.Close()
 }

 func (c *Client) SetHandler(handler EventHandler) {
@@ -215,7 +198,7 @@ func (c *Client) SetHandler(handler EventHandler) {

 // Send marshals XMPP stanza and sends it to the server.
 func (c *Client) Send(packet stanza.Packet) error {
-	conn := c.transport
+	conn := c.conn
 	if conn == nil {
 		return errors.New("client is not connected")
 	}
@@ -225,26 +208,7 @@ func (c *Client) Send(packet stanza.Packet) error {
 		return errors.New("cannot marshal packet " + err.Error())
 	}

-	return c.sendWithWriter(c.transport, data)
-}
-
-// SendIQ sends an IQ set or get stanza to the server. If a result is received
-// the provided handler function will automatically be called.
-//
-// The provided context should have a timeout to prevent the client from waiting
-// forever for an IQ result. For example:
-//
-//   ctx, _ := context.WithTimeout(context.Background(), 30 * time.Second)
-//   result := <- client.SendIQ(ctx, iq)
-//
-func (c *Client) SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, error) {
-	if iq.Attrs.Type != stanza.IQTypeSet && iq.Attrs.Type != stanza.IQTypeGet {
-		return nil, ErrCanOnlySendGetOrSetIq
-	}
-	if err := c.Send(iq); err != nil {
-		return nil, err
-	}
-	return c.router.NewIQResultRoute(ctx, iq.Attrs.Id), nil
+	return c.sendWithLogger(string(data))
 }

 // SendRaw sends an XMPP stanza as a string to the server.
@@ -252,17 +216,17 @@ func (c *Client) SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, erro
 // disconnect the client. It is up to the user of this method to
 // carefully craft the XML content to produce valid XMPP.
 func (c *Client) SendRaw(packet string) error {
-	conn := c.transport
+	conn := c.conn
 	if conn == nil {
 		return errors.New("client is not connected")
 	}

-	return c.sendWithWriter(c.transport, []byte(packet))
+	return c.sendWithLogger(packet)
 }

-func (c *Client) sendWithWriter(writer io.Writer, packet []byte) error {
+func (c *Client) sendWithLogger(packet string) error {
 	var err error
-	_, err = writer.Write(packet)
+	_, err = fmt.Fprintf(c.Session.streamLogger, packet)
 	return err
 }

@@ -270,14 +234,13 @@ func (c *Client) sendWithWriter(writer io.Writer, packet []byte) error {
 // Go routines

 // Loop: Receive data from server
-func (c *Client) recv(state SMState, keepaliveQuit chan<- struct{}, errChan chan<- error) {
+func (c *Client) recv(state SMState, keepaliveQuit chan<- struct{}) (err error) {
 	for {
-		val, err := stanza.NextPacket(c.transport.GetDecoder())
+		val, err := stanza.NextPacket(c.Session.decoder)
 		if err != nil {
-			errChan <- err
 			close(keepaliveQuit)
 			c.disconnected(state)
-			return
+			return err
 		}

 		// Handle stream errors
@@ -286,42 +249,35 @@ func (c *Client) recv(state SMState, keepaliveQuit chan<- struct{}, errChan chan
 			c.router.route(c, val)
 			close(keepaliveQuit)
 			c.streamError(packet.Error.Local, packet.Text)
-			errChan <- errors.New("stream error: " + packet.Error.Local)
-			return
+			return errors.New("stream error: " + packet.Error.Local)
 		// Process Stream management nonzas
 		case stanza.SMRequest:
 			answer := stanza.SMAnswer{XMLName: xml.Name{
 				Space: stanza.NSStreamManagement,
 				Local: "a",
 			}, H: state.Inbound}
-			err = c.Send(answer)
-			if err != nil {
-				errChan <- err
-				return
-			}
+			c.Send(answer)
 		default:
 			state.Inbound++
 		}
-		// Do normal route processing in a go-routine so we can immediately
-		// start receiving other stanzas. This also allows route handlers to
-		// send and receive more stanzas.
-		go c.router.route(c, val)
+
+		c.router.route(c, val)
 	}
 }

 // Loop: send whitespace keepalive to server
 // This is use to keep the connection open, but also to detect connection loss
 // and trigger proper client connection shutdown.
-func keepalive(transport Transport, quit <-chan struct{}) {
+func keepalive(conn net.Conn, quit <-chan struct{}) {
 	// TODO: Make keepalive interval configurable
 	ticker := time.NewTicker(30 * time.Second)
 	for {
 		select {
 		case <-ticker.C:
-			if err := transport.Ping(); err != nil {
-				// When keepalive fails, we force close the transport. In all cases, the recv will also fail.
+			if n, err := fmt.Fprintf(conn, "\n"); err != nil || n != 1 {
+				// When keep alive fails, we force close the connection. In all cases, the recv will also fail.
 				ticker.Stop()
-				_ = transport.Close()
+				_ = conn.Close()
 				return
 			}
 		case <-quit:
--- a/client_internal_test.go
+++ b/client_internal_test.go
@@ -1,19 +0,0 @@
-package xmpp
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestClient_Send(t *testing.T) {
-	buffer := bytes.NewBufferString("")
-	client := Client{}
-	data := []byte("https://da.wikipedia.org/wiki/J%C3%A6vnd%C3%B8gn")
-	if err := client.sendWithWriter(buffer, data); err != nil {
-		t.Errorf("Writing failed: %v", err)
-	}
-
-	if buffer.String() != string(data) {
-		t.Errorf("Incorrect value sent to buffer: '%s'", buffer.String())
-	}
-}
--- a/client_test.go
+++ b/client_test.go
@@ -25,13 +25,7 @@ func TestClient_Connect(t *testing.T) {
 	mock.Start(t, testXMPPAddress, handlerConnectSuccess)

 	// Test / Check result
-	config := Config{
-		TransportConfiguration: TransportConfiguration{
-			Address: testXMPPAddress,
-		},
-		Jid:        "test@localhost",
-		Credential: Password("test"),
-		Insecure:   true}
+	config := Config{Address: testXMPPAddress, Jid: "test@localhost", Password: "test", Insecure: true}

 	var client *Client
 	var err error
@@ -53,13 +47,7 @@ func TestClient_NoInsecure(t *testing.T) {
 	mock.Start(t, testXMPPAddress, handlerAbortTLS)

 	// Test / Check result
-	config := Config{
-		TransportConfiguration: TransportConfiguration{
-			Address: testXMPPAddress,
-		},
-		Jid:        "test@localhost",
-		Credential: Password("test"),
-	}
+	config := Config{Address: testXMPPAddress, Jid: "test@localhost", Password: "test"}

 	var client *Client
 	var err error
@@ -83,13 +71,7 @@ func TestClient_FeaturesTracking(t *testing.T) {
 	mock.Start(t, testXMPPAddress, handlerAbortTLS)

 	// Test / Check result
-	config := Config{
-		TransportConfiguration: TransportConfiguration{
-			Address: testXMPPAddress,
-		},
-		Jid:        "test@localhost",
-		Credential: Password("test"),
-	}
+	config := Config{Address: testXMPPAddress, Jid: "test@localhost", Password: "test"}

 	var client *Client
 	var err error
@@ -112,14 +94,7 @@ func TestClient_RFC3921Session(t *testing.T) {
 	mock.Start(t, testXMPPAddress, handlerConnectWithSession)

 	// Test / Check result
-	config := Config{
-		TransportConfiguration: TransportConfiguration{
-			Address: testXMPPAddress,
-		},
-		Jid:        "test@localhost",
-		Credential: Password("test"),
-		Insecure:   true,
-	}
+	config := Config{Address: testXMPPAddress, Jid: "test@localhost", Password: "test", Insecure: true}

 	var client *Client
 	var err error
--- a/cmd/fluuxmpp/README.md
+++ b/cmd/fluuxmpp/README.md
@@ -1,198 +0,0 @@
-# fluuxmpp
-
-fluuxIO's XMPP command-line tool
-
-## Installation
-
-To install `fluuxmpp` in your Go path:
-
-```
-$ go get -u gosrc.io/xmpp/cmd/fluuxmpp
-```
-
-## Usage
-
-```
-$ fluuxmpp --help
-fluuxIO's xmpp comandline tool
-
-Usage:
-  fluuxmpp [command]
-
-Available Commands:
-  check       is a command-line to check if you XMPP TLS certificate is valid and warn you before it expires
-  help        Help about any command
-  send        is a command-line tool to send to send XMPP messages to users
-
-Flags:
-  -h, --help   help for fluuxmpp
-
-Use "fluuxmpp [command] --help" for more information about a command.
-```
-
-### check tls
-
-```
-$ fluuxmpp check --help
-is a command-line to check if you XMPP TLS certificate is valid and warn you before it expires
-
-Usage:
-  fluuxmpp check <host[:port]> [flags]
-
-Examples:
-fluuxmpp check chat.sum7.eu:5222 --domain meckerspace.de
-
-Flags:
-  -d, --domain string   domain if host handle multiple domains
-  -h, --help            help for check
-```
-
-### sending messages
-
-```
-$ fluuxmpp send --help
-is a command-line tool to send to send XMPP messages to users
-
-Usage:
-  fluuxmpp send <recipient,> [message] [flags]
-
-Examples:
-fluuxmpp send to@chat.sum7.eu "Hello World!"
-
-Flags:
-      --addr string       host[:port]
-      --config string     config file (default is ~/.config/fluuxmpp.yml)
-  -h, --help              help for send
-      --jid string        using jid (required)
-  -m, --muc               recipient is a muc (join it before sending messages)
-      --password string   using password for your jid (required)
-```
-
-
-## Examples
-
-### check tls
-
-If you server is on standard port and XMPP domains matches the hostname you can simply use:
-
-```
-$ fluuxmpp check chat.sum7.eu
- info All checks passed
-   ⇢  address="chat.sum7.eu" domain=""
-   ⇢  main.go:43 main.runCheck
-   ⇢  2019-07-16T22:01:39.765+02:00
-```
-
-You can also pass the port and the XMPP domain if different from the server hostname:
-
-```
-$ fluuxmpp check chat.sum7.eu:5222 --domain meckerspace.de
- info All checks passed
-   ⇢  address="chat.sum7.eu:5222" domain="meckerspace.de"
-   ⇢  main.go:43 main.runCheck
-   ⇢  2019-07-16T22:01:33.270+02:00
-```
-
-Error code will be non-zero in case of error. You can thus use it directly with your usual 
-monitoring scripts.
-
-
-### sending messages
-
-Message from arguments:
-```bash
-$ fluuxmpp send to@example.org "Hello World!"
- info client connected
-   ⇢  cmd.go:56 main.glob..func1.1
-   ⇢  2019-07-17T23:42:43.310+02:00
- info send message
-   ⇢  muc=false text="Hello World!" to="to@example.org"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:42:43.310+02:00
-```
-
-Message from STDIN:
-```bash
-$  journalctl -f | fluuxmpp send to@example.org -
- info client connected
-   ⇢  cmd.go:56 main.glob..func1.1
-   ⇢  2019-07-17T23:40:03.177+02:00
- info send message
-   ⇢  muc=false text="-- Logs begin at Mon 2019-07-08 22:16:54 CEST. --" to="to@example.org"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:40:03.178+02:00
- info send message
-   ⇢  muc=false text="Jul 17 23:36:46 RECHNERNAME systemd[755]: Started Fetch mails." to="to@example.org"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:40:03.178+02:00
-^C
-```
-
-
-Multiple recipients:
-```bash
-$ fluuxmpp send to1@example.org,to2@example.org "Multiple recipient"
- info client connected
-   ⇢  cmd.go:56 main.glob..func1.1
-   ⇢  2019-07-17T23:47:57.650+02:00
- info send message
-   ⇢  muc=false text="Multiple recipient" to="to1@example.org"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:47:57.651+02:00
- info send message
-   ⇢  muc=false text="Multiple recipient" to="to2@example.org"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:47:57.652+02:00
-```
-
-Send to MUC:
-```bash
-journalctl -f | fluuxmpp send testit@conference.chat.sum7.eu - --muc
- info client connected
-   ⇢  cmd.go:56 main.glob..func1.1
-   ⇢  2019-07-17T23:52:56.269+02:00
- info send message
-   ⇢  muc=true text="-- Logs begin at Mon 2019-07-08 22:16:54 CEST. --" to="testit@conference.chat.sum7.eu"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:52:56.270+02:00
- info send message
-   ⇢  muc=true text="Jul 17 23:48:58 RECHNERNAME systemd[755]: mail.service: Succeeded." to="testit@conference.chat.sum7.eu"
-   ⇢  send.go:31 main.send
-   ⇢  2019-07-17T23:52:56.277+02:00
-^C
-```
-
-## Authentification
-
-### Configuration file
-
-In `/etc/`, `~/.config` and `.` (here).
-You could create the file name `fluuxmpp` with you favorite file extension (e.g. `toml`, `yml`).
-
-e.g. ~/.config/fluuxmpp.toml
-```toml
-jid      = "bot@example.org"
-password = "secret"
-
-addr     = "example.com:5222"
-```
-
-### Environment variables
-
-```bash
-export FLUXXMPP_JID='bot@example.org';
-export FLUXXMPP_PASSWORD='secret';
-
-export FLUXXMPP_ADDR='example.com:5222';
-
-fluuxmpp send to@example.org "Hello Welt";
-```
-
-### Parameters
-
-Warning: This should not be used for production systems, as all users on the system
-can read the running processes, and their parameters (and thus the password).
-
-```bash
-fluuxmpp send to@example.org "Hello World!" --jid bot@example.org --password secret --addr example.com:5222;
-```
--- a/cmd/fluuxmpp/doc.go
+++ b/cmd/fluuxmpp/doc.go
@@ -1,5 +0,0 @@
-/*
-
-fluuxmpp: fluuxIO's xmpp comandline tool
-*/
-package main
--- a/cmd/fluuxmpp/main.go
+++ b/cmd/fluuxmpp/main.go
@@ -1,19 +0,0 @@
-package main
-
-import (
-	"github.com/bdlm/log"
-	"github.com/spf13/cobra"
-)
-
-// cmdRoot represents the base command when called without any subcommands
-var cmdRoot = &cobra.Command{
-	Use:   "fluuxmpp",
-	Short: "fluuxIO's xmpp comandline tool",
-}
-
-func main() {
-	log.AddHook(&hook{})
-	if err := cmdRoot.Execute(); err != nil {
-		log.Fatal(err)
-	}
-}
--- a/cmd/go.mod
+++ b/cmd/go.mod
@@ -1,6 +1,6 @@
 module gosrc.io/xmpp/cmd

-go 1.13
+go 1.12

 require (
 	github.com/bdlm/log v0.1.19
--- a/cmd/go.sum
+++ b/cmd/go.sum
@@ -2,7 +2,6 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/agnivade/wasmbrowsertest v0.3.1/go.mod h1:zQt6ZTdl338xxRaMW395qccVE2eQm0SjC/SDz0mPWQI=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
@@ -13,12 +12,6 @@ github.com/bdlm/std v0.0.0-20180922040903-fd3b596111c7/go.mod h1:E4vIYZDcEPVbE/D
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/chromedp/cdproto v0.0.0-20190614062957-d6d2f92b486d/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190621002710-8cbd498dd7a0/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190812224334-39ef923dcb8d/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/cdproto v0.0.0-20190926234355-1b4886c6fad6/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/chromedp v0.3.1-0.20190619195644-fd957a4d2901/go.mod h1:mJdvfrVn594N9tfiPecUidF6W5jPRKHymqHfzbobPsM=
-github.com/chromedp/chromedp v0.4.0/go.mod h1:DC3QUn4mJ24dwjcaGQLoZrhm4X/uPHZ6spDbS2uFhm4=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
@@ -27,26 +20,17 @@ github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3Ee
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-interpreter/wagon v0.5.1-0.20190713202023-55a163980b6c/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
-github.com/go-interpreter/wagon v0.6.0/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -54,31 +38,23 @@ github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4er
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190908185732-236ed259b199/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/knq/sysutil v0.0.0-20181215143952-f05b59f0f307/go.mod h1:BjPj+aVjl9FW/cCGiF3nGh5v+9Gd3VCgBQbod/GlMaQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -87,29 +63,15 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mailru/easyjson v0.0.0-20190403194419-1ea4449da983/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190620125010-da37f6c1e481/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
@@ -123,9 +85,7 @@ github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7z
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
-github.com/sirupsen/logrus v1.0.5/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
@@ -136,97 +96,64 @@ github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s=
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
-github.com/twitchyliquid64/golang-asm v0.0.0-20190126203739-365674df15fc/go.mod h1:NoCfSFWosfqMqmmD7hApkirIK9ozpHjxRnRxs1l413A=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
-go.coder.com/go-tools v0.0.0-20190317003359-0c6a35b74a16/go.mod h1:iKV5yK9t+J5nG9O3uF6KYdPEz3dyfMyB15MN1rbQ8Qw=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190306220234-b354f8bf4d9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190618155005-516e3c20635f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190927073244-c990c680b611/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522 h1:bhOzK9QyoD0ogCnFro1m2mz41+Ib0oOhfJnBp5MR4K4=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gotest.tools v2.1.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
-gotest.tools/gotestsum v0.3.5/go.mod h1:Mnf3e5FUzXbkCfynWBGOwLssY7gTQgCHObK9tMpAriY=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-mvdan.cc/sh v2.6.4+incompatible/go.mod h1:IeeQbZq+x2SUGBensq/jge5lLQbS3XT2ktyp3wrt4x8=
-nhooyr.io/websocket v1.6.5/go.mod h1:F259lAzPRAH0htX2y3ehpJe09ih1aSHN7udWki1defY=
--- a/cmd/sendxmpp/README.md
+++ b/cmd/sendxmpp/README.md
@@ -0,0 +1,131 @@
+# sendXMPP
+
+sendxmpp is a tool to send messages from command-line.
+
+## Installation
+
+To install `sendxmpp` in your Go path:
+
+```
+$ go get -u gosrc.io/xmpp/cmd/sendxmpp
+```
+
+## Usage
+
+```
+$ sendxmpp --help
+Usage:
+  sendxmpp <recipient,> [message] [flags]
+
+Examples:
+sendxmpp to@chat.sum7.eu "Hello World!"
+
+Flags:
+      --addr string       host[:port]
+      --config string     config file (default is ~/.config/fluxxmpp.yml)
+  -h, --help              help for sendxmpp
+      --jid string        using jid (required)
+  -m, --muc               recipient is a muc (join it before sending messages)
+      --password string   using password for your jid (required)
+```
+
+
+## Examples
+
+Message from arguments:
+```bash
+$ sendxmpp to@example.org "Hello World!"
+ info client connected
+   ⇢  cmd.go:56 main.glob..func1.1
+   ⇢  2019-07-17T23:42:43.310+02:00
+ info send message
+   ⇢  muc=false text="Hello World!" to="to@example.org"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:42:43.310+02:00
+```
+
+Message from STDIN:
+```bash
+$  journalctl -f | sendxmpp to@example.org -
+ info client connected
+   ⇢  cmd.go:56 main.glob..func1.1
+   ⇢  2019-07-17T23:40:03.177+02:00
+ info send message
+   ⇢  muc=false text="-- Logs begin at Mon 2019-07-08 22:16:54 CEST. --" to="to@example.org"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:40:03.178+02:00
+ info send message
+   ⇢  muc=false text="Jul 17 23:36:46 RECHNERNAME systemd[755]: Started Fetch mails." to="to@example.org"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:40:03.178+02:00
+^C
+```
+
+
+Multiple recipients:
+```bash
+$ sendxmpp to1@example.org,to2@example.org "Multiple recipient"
+ info client connected
+   ⇢  cmd.go:56 main.glob..func1.1
+   ⇢  2019-07-17T23:47:57.650+02:00
+ info send message
+   ⇢  muc=false text="Multiple recipient" to="to1@example.org"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:47:57.651+02:00
+ info send message
+   ⇢  muc=false text="Multiple recipient" to="to2@example.org"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:47:57.652+02:00
+```
+
+Send to MUC:
+```bash
+journalctl -f | sendxmpp testit@conference.chat.sum7.eu - --muc
+ info client connected
+   ⇢  cmd.go:56 main.glob..func1.1
+   ⇢  2019-07-17T23:52:56.269+02:00
+ info send message
+   ⇢  muc=true text="-- Logs begin at Mon 2019-07-08 22:16:54 CEST. --" to="testit@conference.chat.sum7.eu"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:52:56.270+02:00
+ info send message
+   ⇢  muc=true text="Jul 17 23:48:58 RECHNERNAME systemd[755]: mail.service: Succeeded." to="testit@conference.chat.sum7.eu"
+   ⇢  send.go:31 main.send
+   ⇢  2019-07-17T23:52:56.277+02:00
+^C
+```
+
+### Authentification
+
+#### Configuration file
+
+In `/etc/`, `~/.config` and `.` (here).
+You could create the file name `fluxxmpp` with you favorite file extenion (e.g. `toml`, `yml`).
+
+e.g. ~/.config/fluxxmpp.toml
+```toml
+jid      = "bot@example.org"
+password = "secret"
+
+addr     = "example.com:5222"
+```
+
+#### Environment variables
+
+```bash
+export FLUXXMPP_JID='bot@example.org';
+export FLUXXMPP_PASSWORD='secret';
+
+export FLUXXMPP_ADDR='example.com:5222';
+
+sendxmpp to@example.org "Hello Welt";
+```
+
+#### Parameters
+
+Warning: This should not be used for production systems, as all users on the system
+can read the running processes, and their parameters (and thus the password).
+
+```bash
+sendxmpp to@example.org "Hello World!" --jid bot@example.org --password secret --addr example.com:5222;
+```
--- a/cmd/sendxmpp/TODO.md
+++ b/cmd/sendxmpp/TODO.md
@@ -1,18 +1,11 @@
 # TODO

-## check
-### Features
-
- Use a config file to define the checks to perform as client on an XMPP server.
-
-## send
-
-### Issues
+## Issues

 - Remove global variable (like mucToleave)
 - Does not report error when trying to connect to a non open port (for example localhost with no server running).

-### Features
+## Features

 - configuration
  - allow unencrypted
--- a/cmd/fluuxmpp/send.go
+++ b/cmd/fluuxmpp/send.go
@@ -18,10 +18,9 @@ var configFile = ""
 // FIXME: Remove global variables
 var isMUCRecipient = false

-var cmdSend = &cobra.Command{
-	Use:     "send <recipient,> [message]",
-	Short:   "is a command-line tool to send to send XMPP messages to users",
-	Example: `fluuxmpp send to@chat.sum7.eu "Hello World!"`,
+var cmd = &cobra.Command{
+	Use:     "sendxmpp <recipient,> [message]",
+	Example: `sendxmpp to@chat.sum7.eu "Hello World!"`,
 	Args:    cobra.ExactArgs(2),
 	Run:     sendxmpp,
 }
@@ -32,11 +31,9 @@ func sendxmpp(cmd *cobra.Command, args []string) {

 	var err error
 	client, err := xmpp.NewClient(xmpp.Config{
-		TransportConfiguration: xmpp.TransportConfiguration{
-			Address: viper.GetString("addr"),
-		},
-		Jid:        viper.GetString("jid"),
-		Credential: xmpp.Password(viper.GetString("password")),
+		Jid:      viper.GetString("jid"),
+		Address:  viper.GetString("addr"),
+		Password: viper.GetString("password"),
 	}, xmpp.NewRouter())

 	if err != nil {
@@ -98,30 +95,28 @@ func sendxmpp(cmd *cobra.Command, args []string) {
 }

 func init() {
-	cmdRoot.AddCommand(cmdSend)
+	cobra.OnInitialize(initConfig)
+	cmd.PersistentFlags().StringVar(&configFile, "config", "", "config file (default is ~/.config/fluxxmpp.yml)")

-	cobra.OnInitialize(initConfigFile)
-	cmdSend.PersistentFlags().StringVar(&configFile, "config", "", "config file (default is ~/.config/fluuxmpp.yml)")
+	cmd.Flags().StringP("jid", "", "", "using jid (required)")
+	viper.BindPFlag("jid", cmd.Flags().Lookup("jid"))

-	cmdSend.Flags().StringP("jid", "", "", "using jid (required)")
-	viper.BindPFlag("jid", cmdSend.Flags().Lookup("jid"))
+	cmd.Flags().StringP("password", "", "", "using password for your jid (required)")
+	viper.BindPFlag("password", cmd.Flags().Lookup("password"))

-	cmdSend.Flags().StringP("password", "", "", "using password for your jid (required)")
-	viper.BindPFlag("password", cmdSend.Flags().Lookup("password"))
+	cmd.Flags().StringP("addr", "", "", "host[:port]")
+	viper.BindPFlag("addr", cmd.Flags().Lookup("addr"))

-	cmdSend.Flags().StringP("addr", "", "", "host[:port]")
-	viper.BindPFlag("addr", cmdSend.Flags().Lookup("addr"))
-
-	cmdSend.Flags().BoolVarP(&isMUCRecipient, "muc", "m", false, "recipient is a muc (join it before sending messages)")
+	cmd.Flags().BoolVarP(&isMUCRecipient, "muc", "m", false, "recipient is a muc (join it before sending messages)")
 }

 // initConfig reads in config file and ENV variables if set.
-func initConfigFile() {
+func initConfig() {
 	if configFile != "" {
 		viper.SetConfigFile(configFile)
 	}

-	viper.SetConfigName("fluuxmpp")
+	viper.SetConfigName("fluxxmpp")
 	viper.AddConfigPath("/etc/")
 	viper.AddConfigPath("$HOME/.config")
 	viper.AddConfigPath(".")
--- a/cmd/sendxmpp/doc.go
+++ b/cmd/sendxmpp/doc.go
@@ -0,0 +1,6 @@
+/*
+
+sendxmpp is a command-line tool to send to send XMPP messages to users
+
+*/
+package main
--- a/cmd/sendxmpp/log.go
+++ b/cmd/sendxmpp/log.go
--- a/cmd/sendxmpp/main.go
+++ b/cmd/sendxmpp/main.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/bdlm/log"
+)
+
+func main() {
+	log.AddHook(&hook{})
+	if err := cmd.Execute(); err != nil {
+		log.Fatal(err)
+	}
+}
--- a/cmd/fluuxmpp/xmppmuc.go
+++ b/cmd/fluuxmpp/xmppmuc.go
--- a/cmd/fluuxmpp/xmppsend.go
+++ b/cmd/fluuxmpp/xmppsend.go
--- a/cmd/xmpp-check/README.md
+++ b/cmd/xmpp-check/README.md
@@ -0,0 +1,49 @@
+# XMPP Check
+
+XMPP check is a tool to check TLS certificate on a remote server.
+
+## Installation
+
+To install `xmpp-check` in your Go path:
+
+```
+$ go get -u gosrc.io/xmpp/cmd/xmpp-check
+```
+
+## Usage
+
+```
+$ xmpp-check --help
+Usage:
+  xmpp-check <host[:port]> [flags]
+
+Examples:
+xmpp-check chat.sum7.eu:5222 --domain meckerspace.de
+
+Flags:
+  -d, --domain string   domain if host handle multiple domains
+  -h, --help            help for xmpp-check
+```
+
+If you server is on standard port and XMPP domains matches the hostname you can simply use:
+
+```
+$ xmpp-check chat.sum7.eu
+ info All checks passed
+   ⇢  address="chat.sum7.eu" domain=""
+   ⇢  main.go:43 main.runCheck
+   ⇢  2019-07-16T22:01:39.765+02:00
+```
+
+You can also pass the port and the XMPP domain if different from the server hostname:
+
+```
+$ xmpp-check chat.sum7.eu:5222 --domain meckerspace.de
+ info All checks passed
+   ⇢  address="chat.sum7.eu:5222" domain="meckerspace.de"
+   ⇢  main.go:43 main.runCheck
+   ⇢  2019-07-16T22:01:33.270+02:00
+```
+
+Error code will be non-zero in case of error. You can thus use it directly with your usual 
+monitoring scripts.
--- a/cmd/xmpp-check/TODO.md
+++ b/cmd/xmpp-check/TODO.md
@@ -0,0 +1,3 @@
+# TODO
+
+- Use a config file to define the checks to perform as client on an XMPP server.
--- a/cmd/xmpp-check/doc.go
+++ b/cmd/xmpp-check/doc.go
@@ -0,0 +1,6 @@
+/*
+
+xmpp-check is a command-line to check if you XMPP TLS certificate is valid and warn you before it expires.
+
+*/
+package main
--- a/cmd/xmpp-check/log.go
+++ b/cmd/xmpp-check/log.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"os"
+
+	"github.com/bdlm/log"
+	stdLogger "github.com/bdlm/std/logger"
+)
+
+type hook struct{}
+
+func (h *hook) Fire(entry *log.Entry) error {
+	switch entry.Level {
+	case log.PanicLevel:
+		entry.Logger.Out = os.Stderr
+	case log.FatalLevel:
+		entry.Logger.Out = os.Stderr
+	case log.ErrorLevel:
+		entry.Logger.Out = os.Stderr
+	case log.WarnLevel:
+		entry.Logger.Out = os.Stdout
+	case log.InfoLevel:
+		entry.Logger.Out = os.Stdout
+	case log.DebugLevel:
+		entry.Logger.Out = os.Stdout
+	default:
+	}
+
+	return nil
+}
+
+func (h *hook) Levels() []stdLogger.Level {
+	return log.AllLevels
+}
--- a/cmd/xmpp-check/main.go
+++ b/cmd/xmpp-check/main.go
@@ -6,11 +6,15 @@ import (
 	"gosrc.io/xmpp"
 )

+func main() {
+	log.AddHook(&hook{})
+	cmd.Execute()
+}
+
 var domain = ""
-var cmdCheck = &cobra.Command{
-	Use:     "check <host[:port]>",
-	Short:   "is a command-line to check if you XMPP TLS certificate is valid and warn you before it expires",
-	Example: "fluuxmpp check chat.sum7.eu:5222 --domain meckerspace.de",
+var cmd = &cobra.Command{
+	Use:     "xmpp-check <host[:port]>",
+	Example: "xmpp-check chat.sum7.eu:5222 --domain meckerspace.de",
 	Args:    cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		runCheck(args[0], domain)
@@ -18,8 +22,7 @@ var cmdCheck = &cobra.Command{
 }

 func init() {
-	cmdRoot.AddCommand(cmdCheck)
-	cmdCheck.Flags().StringVarP(&domain, "domain", "d", "", "domain if host handle multiple domains")
+	cmd.Flags().StringVarP(&domain, "domain", "d", "", "domain if host handle multiple domains")
 }

 func runCheck(address, domain string) {
--- a/component.go
+++ b/component.go
@@ -1,19 +1,21 @@
 package xmpp

 import (
-	"context"
 	"crypto/sha1"
 	"encoding/hex"
 	"encoding/xml"
 	"errors"
 	"fmt"
-	"gosrc.io/xmpp/stanza"
 	"io"
+	"net"
+	"time"
+
+	"gosrc.io/xmpp/stanza"
 )

-type ComponentOptions struct {
-	TransportConfiguration
+const componentStreamOpen = "<?xml version='1.0'?><stream:stream to='%s' xmlns='%s' xmlns:stream='%s'>"

+type ComponentOptions struct {
 	// =================================
 	// Component Connection Info

@@ -21,6 +23,9 @@ type ComponentOptions struct {
 	Domain string
 	// Secret is the "password" used by the XMPP server to secure component access
 	Secret string
+	// Address is the XMPP Host and port to connect to. Host is of
+	// the form 'serverhost:port' i.e "localhost:8888"
+	Address string

 	// =================================
 	// Component discovery
@@ -45,10 +50,12 @@ type Component struct {
 	ComponentOptions
 	router *Router

-	transport Transport
+	// TCP level connection
+	conn net.Conn

 	// read / write
 	socketProxy io.ReadWriter // TODO
+	decoder     *xml.Decoder
 }

 func NewComponent(opts ComponentOptions, r *Router) (*Component, error) {
@@ -59,68 +66,56 @@ func NewComponent(opts ComponentOptions, r *Router) (*Component, error) {
 // Connect triggers component connection to XMPP server component port.
 // TODO: Failed handshake should be a permanent error
 func (c *Component) Connect() error {
-	var state SMState
-	return c.Resume(state)
-}
-
-func (c *Component) Resume(sm SMState) error {
+	var conn net.Conn
 	var err error
-	var streamId string
-	if c.ComponentOptions.TransportConfiguration.Domain == "" {
-		c.ComponentOptions.TransportConfiguration.Domain = c.ComponentOptions.Domain
+	if conn, err = net.DialTimeout("tcp", c.Address, time.Duration(5)*time.Second); err != nil {
+		return err
 	}
-	c.transport, err = NewComponentTransport(c.ComponentOptions.TransportConfiguration)
+	c.conn = conn
+
+	// 1. Send stream open tag
+	if _, err := fmt.Fprintf(conn, componentStreamOpen, c.Domain, stanza.NSComponent, stanza.NSStream); err != nil {
+		return errors.New("cannot send stream open " + err.Error())
+	}
+	c.decoder = xml.NewDecoder(conn)
+
+	// 2. Initialize xml decoder and extract streamID from reply
+	streamId, err := stanza.InitStream(c.decoder)
 	if err != nil {
-		c.updateState(StatePermanentError)
-
-		return NewConnError(err, true)
+		return errors.New("cannot init decoder " + err.Error())
 	}

-	if streamId, err = c.transport.Connect(); err != nil {
-		c.updateState(StatePermanentError)
-
-		return NewConnError(err, true)
-	}
-	c.updateState(StateConnected)
-
-	// Authentication
-	if _, err := fmt.Fprintf(c.transport, "<handshake>%s</handshake>", c.handshake(streamId)); err != nil {
-		c.updateState(StateStreamError)
-
-		return NewConnError(errors.New("cannot send handshake "+err.Error()), false)
+	// 3. Authentication
+	if _, err := fmt.Fprintf(conn, "<handshake>%s</handshake>", c.handshake(streamId)); err != nil {
+		return errors.New("cannot send handshake " + err.Error())
 	}

-	// Check server response for authentication
-	val, err := stanza.NextPacket(c.transport.GetDecoder())
+	// 4. Check server response for authentication
+	val, err := stanza.NextPacket(c.decoder)
 	if err != nil {
-		c.updateState(StatePermanentError)
-		return NewConnError(err, true)
+		return err
 	}

 	switch v := val.(type) {
 	case stanza.StreamError:
-		c.streamError("conflict", "no auth loop")
-		return NewConnError(errors.New("handshake failed "+v.Error.Local), true)
+		return errors.New("handshake failed " + v.Error.Local)
 	case stanza.Handshake:
 		// Start the receiver go routine
-		c.updateState(StateSessionEstablished)
-		// Leaving this channel here for later. Not used atm. We should return this instead of an error because right
-		// now the returned error is lost in limbo.
-		errChan := make(chan error)
-		go c.recv(errChan) // Sends to errChan
-		return err         // Should be empty at this point
+		go c.recv()
+		return nil
 	default:
-		c.updateState(StatePermanentError)
-		return NewConnError(errors.New("expecting handshake result, got "+v.Name()), true)
+		return errors.New("expecting handshake result, got " + v.Name())
 	}
-	return err
+}
+
+func (c *Component) Resume() error {
+	return errors.New("components do not support stream management")
 }

 func (c *Component) Disconnect() {
+	_ = c.SendRaw("</stream:stream>")
 	// TODO: Add a way to wait for stream close acknowledgement from the server for clean disconnect
-	if c.transport != nil {
-		_ = c.transport.Close()
-	}
+	_ = c.conn.Close()
 }

 func (c *Component) SetHandler(handler EventHandler) {
@@ -128,22 +123,20 @@ func (c *Component) SetHandler(handler EventHandler) {
 }

 // Receiver Go routine receiver
-func (c *Component) recv(errChan chan<- error) {
-
+func (c *Component) recv() (err error) {
 	for {
-		val, err := stanza.NextPacket(c.transport.GetDecoder())
+		val, err := stanza.NextPacket(c.decoder)
 		if err != nil {
 			c.updateState(StateDisconnected)
-			errChan <- err
-			return
+			return err
 		}
+
 		// Handle stream errors
 		switch p := val.(type) {
 		case stanza.StreamError:
 			c.router.route(c, val)
 			c.streamError(p.Error.Local, p.Text)
-			errChan <- errors.New("stream error: " + p.Error.Local)
-			return
+			return errors.New("stream error: " + p.Error.Local)
 		}
 		c.router.route(c, val)
 	}
@@ -151,8 +144,8 @@ func (c *Component) recv(errChan chan<- error) {

 // Send marshalls XMPP stanza and sends it to the server.
 func (c *Component) Send(packet stanza.Packet) error {
-	transport := c.transport
-	if transport == nil {
+	conn := c.conn
+	if conn == nil {
 		return errors.New("component is not connected")
 	}

@@ -161,43 +154,24 @@ func (c *Component) Send(packet stanza.Packet) error {
 		return errors.New("cannot marshal packet " + err.Error())
 	}

-	if _, err := fmt.Fprintf(transport, string(data)); err != nil {
+	if _, err := fmt.Fprintf(conn, string(data)); err != nil {
 		return errors.New("cannot send packet " + err.Error())
 	}
 	return nil
 }

-// SendIQ sends an IQ set or get stanza to the server. If a result is received
-// the provided handler function will automatically be called.
-//
-// The provided context should have a timeout to prevent the client from waiting
-// forever for an IQ result. For example:
-//
-//   ctx, _ := context.WithTimeout(context.Background(), 30 * time.Second)
-//   result := <- client.SendIQ(ctx, iq)
-//
-func (c *Component) SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, error) {
-	if iq.Attrs.Type != stanza.IQTypeSet && iq.Attrs.Type != stanza.IQTypeGet {
-		return nil, ErrCanOnlySendGetOrSetIq
-	}
-	if err := c.Send(iq); err != nil {
-		return nil, err
-	}
-	return c.router.NewIQResultRoute(ctx, iq.Attrs.Id), nil
-}
-
 // SendRaw sends an XMPP stanza as a string to the server.
 // It can be invalid XML or XMPP content. In that case, the server will
 // disconnect the component. It is up to the user of this method to
 // carefully craft the XML content to produce valid XMPP.
 func (c *Component) SendRaw(packet string) error {
-	transport := c.transport
-	if transport == nil {
+	conn := c.conn
+	if conn == nil {
 		return errors.New("component is not connected")
 	}

 	var err error
-	_, err = fmt.Fprintf(transport, packet)
+	_, err = fmt.Fprintf(c.conn, packet)
 	return err
 }

--- a/component_test.go
+++ b/component_test.go
@@ -1,33 +1,7 @@
 package xmpp

 import (
-	"context"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"gosrc.io/xmpp/stanza"
-	"net"
-	"strings"
 	"testing"
-	"time"
-)
-
-// Tests are ran in parallel, so each test creating a server must use a different port so we do not get any
-// conflict. Using iota for this should do the trick.
-const (
-	testComponentDomain  = "localhost"
-	defaultServerName    = "testServer"
-	defaultStreamID      = "91bd0bba-012f-4d92-bb17-5fc41e6fe545"
-	defaultComponentName = "Test Component"
-
-	// Default port is not standard XMPP port to avoid interfering
-	// with local running XMPP server
-	testHandshakePort = iota + 15222
-	testDecoderPort
-	testSendIqPort
-	testSendRawPort
-	testDisconnectPort
-	testSManDisconnectPort
 )

 func TestHandshake(t *testing.T) {
@@ -46,409 +20,6 @@ func TestHandshake(t *testing.T) {
 	}
 }

-// Tests connection process with a handshake exchange
-// Tests multiple session IDs. All connections should generate a unique stream ID
 func TestGenerateHandshake(t *testing.T) {
-	// Using this array with a channel to make a queue of values to test
-	// These are stream IDs that will be used to test the connection process, mixing them with the "secret" to generate
-	// some handshake value
-	var uuidsArray = [5]string{
-		"cc9b3249-9582-4780-825f-4311b42f9b0e",
-		"bba8be3c-d98e-4e26-b9bb-9ed34578a503",
-		"dae72822-80e8-496b-b763-ab685f53a188",
-		"a45d6c06-de49-4bb0-935b-1a2201b71028",
-		"7dc6924f-0eca-4237-9898-18654b8d891e",
-	}
-
-	// Channel to pass stream IDs as a queue
-	var uchan = make(chan string, len(uuidsArray))
-	// Populate test channel
-	for _, elt := range uuidsArray {
-		uchan <- elt
-	}
-
-	// Performs a Component connection with a handshake. It expects to have an ID sent its way through the "uchan"
-	// channel of this file. Otherwise it will hang for ever.
-	h := func(t *testing.T, c net.Conn) {
-		decoder := xml.NewDecoder(c)
-		checkOpenStreamHandshakeID(t, c, decoder, <-uchan)
-		readHandshakeComponent(t, decoder)
-		fmt.Fprintln(c, "<handshake/>") // That's all the server needs to return (see xep-0114)
-		return
-	}
-
-	// Init mock server
-	testComponentAddess := fmt.Sprintf("%s:%d", testComponentDomain, testHandshakePort)
-	mock := ServerMock{}
-	mock.Start(t, testComponentAddess, h)
-
-	// Init component
-	opts := ComponentOptions{
-		TransportConfiguration: TransportConfiguration{
-			Address: testComponentAddess,
-			Domain:  "localhost",
-		},
-		Domain:   testComponentDomain,
-		Secret:   "mypass",
-		Name:     "Test Component",
-		Category: "gateway",
-		Type:     "service",
-	}
-	router := NewRouter()
-	c, err := NewComponent(opts, router)
-	if err != nil {
-		t.Errorf("%+v", err)
-	}
-	c.transport, err = NewComponentTransport(c.ComponentOptions.TransportConfiguration)
-	if err != nil {
-		t.Errorf("%+v", err)
-	}
-
-	// Try connecting, and storing the resulting streamID in a map.
-	m := make(map[string]bool)
-	for _, _ = range uuidsArray {
-		streamId, _ := c.transport.Connect()
-		m[c.handshake(streamId)] = true
-	}
-	if len(uuidsArray) != len(m) {
-		t.Errorf("Handshake does not produce a unique id. Expected: %d unique ids, got: %d", len(uuidsArray), len(m))
-	}
-}
-
-// Test that NewStreamManager can accept a Component.
-//
-// This validates that Component conforms to StreamClient interface.
-func TestStreamManager(t *testing.T) {
-	NewStreamManager(&Component{}, nil)
-}
-
-// Tests that the decoder is properly initialized when connecting a component to a server.
-// The decoder is expected to be built after a valid connection
-// Based on the xmpp_component example.
-func TestDecoder(t *testing.T) {
-	c, _ := mockConnection(t, testDecoderPort, handlerForComponentHandshakeDefaultID)
-	if c.transport.GetDecoder() == nil {
-		t.Errorf("Failed to initialize decoder. Decoder is nil.")
-	}
-}
-
-// Tests sending an IQ to the server, and getting the response
-func TestSendIq(t *testing.T) {
-	//Connecting to a mock server, initialized with given port and handler function
-	c, m := mockConnection(t, testSendIqPort, handlerForComponentIQSend)
-
-	ctx, _ := context.WithTimeout(context.Background(), 30*time.Second)
-	iqReq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, From: "test1@localhost/mremond-mbp", To: defaultServerName, Id: defaultStreamID, Lang: "en"})
-	disco := iqReq.DiscoInfo()
-	iqReq.Payload = disco
-
-	var res chan stanza.IQ
-	res, _ = c.SendIQ(ctx, iqReq)
-
-	select {
-	case <-res:
-	case <-time.After(100 * time.Millisecond):
-		t.Errorf("Failed to receive response, to sent IQ, from mock server")
-	}
-
-	m.Stop()
-}
-
-// Tests sending raw xml to the mock server.
-// TODO : check the server response client side ?
-// Right now, the server response is not checked and an err is passed in a channel if the test is supposed to err.
-// In this test, we use IQs
-func TestSendRaw(t *testing.T) {
-	// Error channel for the handler
-	errChan := make(chan error)
-	// Handler for the mock server
-	h := func(t *testing.T, c net.Conn) {
-		// Completes the connection by exchanging handshakes
-		handlerForComponentHandshakeDefaultID(t, c)
-		receiveRawIq(t, c, errChan)
-		return
-	}
-
-	type testCase struct {
-		req       string
-		shouldErr bool
-	}
-	testRequests := make(map[string]testCase)
-	// Sending a correct IQ of type get. Not supposed to err
-	testRequests["Correct IQ"] = testCase{
-		req:       `<iq type="get" id="91bd0bba-012f-4d92-bb17-5fc41e6fe545" from="test1@localhost/mremond-mbp" to="testServer" lang="en"><query xmlns="http://jabber.org/protocol/disco#info"></query></iq>`,
-		shouldErr: false,
-	}
-	// Sending an IQ with a missing ID. Should err
-	testRequests["IQ with missing ID"] = testCase{
-		req:       `<iq type="get" from="test1@localhost/mremond-mbp" to="testServer" lang="en"><query xmlns="http://jabber.org/protocol/disco#info"></query></iq>`,
-		shouldErr: true,
-	}
-
-	// Tests for all the IQs
-	for name, tcase := range testRequests {
-		t.Run(name, func(st *testing.T) {
-			//Connecting to a mock server, initialized with given port and handler function
-			c, m := mockConnection(t, testSendRawPort, h)
-
-			// Sending raw xml from test case
-			err := c.SendRaw(tcase.req)
-			if err != nil {
-				t.Errorf("Error sending Raw string")
-			}
-			// Just wait a little so the message has time to arrive
-			select {
-			case <-time.After(100 * time.Millisecond):
-			case err = <-errChan:
-				if err == nil && tcase.shouldErr {
-					t.Errorf("Failed to get closing stream err")
-				}
-			}
-			c.transport.Close()
-			m.Stop()
-		})
-	}
-}
-
-// Tests the Disconnect method for Components
-func TestDisconnect(t *testing.T) {
-	c, m := mockConnection(t, testDisconnectPort, handlerForComponentHandshakeDefaultID)
-	err := c.transport.Ping()
-	if err != nil {
-		t.Errorf("Could not ping but not disconnected yet")
-	}
-	c.Disconnect()
-	err = c.transport.Ping()
-	if err == nil {
-		t.Errorf("Did not disconnect properly")
-	}
-	m.Stop()
-}
-
-// Tests that a streamManager successfully disconnects when a handshake fails between the component and the server.
-func TestStreamManagerDisconnect(t *testing.T) {
-	// Init mock server
-	testComponentAddress := fmt.Sprintf("%s:%d", testComponentDomain, testSManDisconnectPort)
-	mock := ServerMock{}
-	// Handler fails the handshake, which is currently the only option to disconnect completely when using a streamManager
-	// a failed handshake being a permanent error, except for a "conflict"
-	mock.Start(t, testComponentAddress, handlerComponentFailedHandshakeDefaultID)
-
-	//==================================
-	// Create Component to connect to it
-	c := makeBasicComponent(defaultComponentName, testComponentAddress, t)
-
-	//========================================
-	// Connect the new Component to the server
-	cm := NewStreamManager(c, nil)
-	errChan := make(chan error)
-	runSMan := func(errChan chan error) {
-		errChan <- cm.Run()
-	}
-
-	go runSMan(errChan)
-	select {
-	case <-errChan:
-	case <-time.After(100 * time.Millisecond):
-		t.Errorf("The component and server seem to still be connected while they should not.")
-	}
-	mock.Stop()
-}
-
-//=============================================================================
-// Basic XMPP Server Mock Handlers.
-// Performs a Component connection with a handshake. It uses a default ID defined in this file as a constant.
-// Used in the mock server as a Handler
-func handlerForComponentHandshakeDefaultID(t *testing.T, c net.Conn) {
-	decoder := xml.NewDecoder(c)
-	checkOpenStreamHandshakeDefaultID(t, c, decoder)
-	readHandshakeComponent(t, decoder)
-	fmt.Fprintln(c, "<handshake/>") // That's all the server needs to return (see xep-0114)
-	return
-}
-
-// Performs a Component connection with a handshake. It uses a default ID defined in this file as a constant.
-// This handler is supposed to fail by sending a "message" stanza instead of a <handshake/> stanza to finalize the handshake.
-func handlerComponentFailedHandshakeDefaultID(t *testing.T, c net.Conn) {
-	decoder := xml.NewDecoder(c)
-	checkOpenStreamHandshakeDefaultID(t, c, decoder)
-	readHandshakeComponent(t, decoder)
-
-	// Send a message, instead of a "<handshake/>" tag, to fail the handshake process dans disconnect the client.
-	me := stanza.Message{
-		Attrs: stanza.Attrs{Type: stanza.MessageTypeChat, From: defaultServerName, To: defaultComponentName, Lang: "en"},
-		Body:  "Fail my handshake.",
-	}
-	s, _ := xml.Marshal(me)
-	fmt.Fprintln(c, string(s))
-
-	return
-}
-
-// Reads from the connection with the Component. Expects a handshake request, and returns the <handshake/> tag.
-func readHandshakeComponent(t *testing.T, decoder *xml.Decoder) {
-	se, err := stanza.NextStart(decoder)
-	if err != nil {
-		t.Errorf("cannot read auth: %s", err)
-		return
-	}
-	nv := &stanza.Handshake{}
-	// Decode element into pointer storage
-	if err = decoder.DecodeElement(nv, &se); err != nil {
-		t.Errorf("cannot decode handshake: %s", err)
-		return
-	}
-	if len(strings.TrimSpace(nv.Value)) == 0 {
-		t.Errorf("did not receive handshake ID")
-	}
-}
-
-func checkOpenStreamHandshakeDefaultID(t *testing.T, c net.Conn, decoder *xml.Decoder) {
-	checkOpenStreamHandshakeID(t, c, decoder, defaultStreamID)
-}
-
-// Used for ID and handshake related tests
-func checkOpenStreamHandshakeID(t *testing.T, c net.Conn, decoder *xml.Decoder, streamID string) {
-	c.SetDeadline(time.Now().Add(defaultTimeout))
-	defer c.SetDeadline(time.Time{})
-
-	for { // TODO clean up. That for loop is not elegant and I prefer bounded recursion.
-		token, err := decoder.Token()
-		if err != nil {
-			t.Errorf("cannot read next token: %s", err)
-		}
-
-		switch elem := token.(type) {
-		// Wait for first startElement
-		case xml.StartElement:
-			if elem.Name.Space != stanza.NSStream || elem.Name.Local != "stream" {
-				err = errors.New("xmpp: expected <stream> but got <" + elem.Name.Local + "> in " + elem.Name.Space)
-				return
-			}
-			if _, err := fmt.Fprintf(c, serverStreamOpen, "localhost", streamID, stanza.NSComponent, stanza.NSStream); err != nil {
-				t.Errorf("cannot write server stream open: %s", err)
-			}
-			return
-		}
-	}
-}
-
-//=============================================================================
-// Sends IQ response to Component request.
-// No parsing of the request here. We just check that it's valid, and send the default response.
-func handlerForComponentIQSend(t *testing.T, c net.Conn) {
-	// Completes the connection by exchanging handshakes
-	handlerForComponentHandshakeDefaultID(t, c)
-
-	// Decoder to parse the request
-	decoder := xml.NewDecoder(c)
-
-	iqReq, err := receiveIq(t, c, decoder)
-	if err != nil {
-		t.Errorf("Error receiving the IQ stanza : %v", err)
-	} else if !iqReq.IsValid() {
-		t.Errorf("server received an IQ stanza : %v", iqReq)
-	}
-
-	// Crafting response
-	iqResp := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeResult, From: iqReq.To, To: iqReq.From, Id: iqReq.Id, Lang: "en"})
-	disco := iqResp.DiscoInfo()
-	disco.AddFeatures("vcard-temp",
-		`http://jabber.org/protocol/address`)
-
-	disco.AddIdentity("Multicast", "service", "multicast")
-	iqResp.Payload = disco
-
-	// Sending response to the Component
-	mResp, err := xml.Marshal(iqResp)
-	_, err = fmt.Fprintln(c, string(mResp))
-	if err != nil {
-		t.Errorf("Could not send response stanza : %s", err)
-	}
-	return
-}
-
-// Reads next request coming from the Component. Expecting it to be an IQ request
-func receiveIq(t *testing.T, c net.Conn, decoder *xml.Decoder) (stanza.IQ, error) {
-	c.SetDeadline(time.Now().Add(defaultTimeout))
-	defer c.SetDeadline(time.Time{})
-	var iqStz stanza.IQ
-	err := decoder.Decode(&iqStz)
-	if err != nil {
-		t.Errorf("cannot read the received IQ stanza: %s", err)
-	}
-	if !iqStz.IsValid() {
-		t.Errorf("received IQ stanza is invalid : %s", err)
-	}
-	return iqStz, nil
-}
-
-func receiveRawIq(t *testing.T, c net.Conn, errChan chan error) {
-	c.SetDeadline(time.Now().Add(defaultTimeout))
-	defer c.SetDeadline(time.Time{})
-	decoder := xml.NewDecoder(c)
-	var iq stanza.IQ
-	err := decoder.Decode(&iq)
-	if err != nil || !iq.IsValid() {
-		s := stanza.StreamError{
-			XMLName: xml.Name{Local: "stream:error"},
-			Error:   xml.Name{Local: "xml-not-well-formed"},
-			Text:    `XML was not well-formed`,
-		}
-		raw, _ := xml.Marshal(s)
-		fmt.Fprintln(c, string(raw))
-		fmt.Fprintln(c, `</stream:stream>`) // TODO : check this client side
-		errChan <- fmt.Errorf("invalid xml")
-		return
-	}
-	errChan <- nil
-	return
-}
-
-//===============================
-// Init mock server and connection
-// Creating a mock server and connecting a Component to it. Initialized with given port and handler function
-// The Component and mock are both returned
-func mockConnection(t *testing.T, port int, handler func(t *testing.T, c net.Conn)) (*Component, *ServerMock) {
-	// Init mock server
-	testComponentAddress := fmt.Sprintf("%s:%d", testComponentDomain, port)
-	mock := ServerMock{}
-	mock.Start(t, testComponentAddress, handler)
-
-	//==================================
-	// Create Component to connect to it
-	c := makeBasicComponent(defaultComponentName, testComponentAddress, t)
-
-	//========================================
-	// Connect the new Component to the server
-	err := c.Connect()
-	if err != nil {
-		t.Errorf("%+v", err)
-	}
-
-	return c, &mock
-}
-
-func makeBasicComponent(name string, mockServerAddr string, t *testing.T) *Component {
-	opts := ComponentOptions{
-		TransportConfiguration: TransportConfiguration{
-			Address: mockServerAddr,
-			Domain:  "localhost",
-		},
-		Domain:   testComponentDomain,
-		Secret:   "mypass",
-		Name:     name,
-		Category: "gateway",
-		Type:     "service",
-	}
-	router := NewRouter()
-	c, err := NewComponent(opts, router)
-	if err != nil {
-		t.Errorf("%+v", err)
-	}
-	c.transport, err = NewComponentTransport(c.ComponentOptions.TransportConfiguration)
-	if err != nil {
-		t.Errorf("%+v", err)
-	}
-	return c
+	// TODO
 }
--- a/config.go
+++ b/config.go
@@ -1,21 +1,24 @@
 package xmpp

 import (
+	"crypto/tls"
+	"io"
 	"os"
 )

-// Config & TransportConfiguration must not be modified after having been passed to NewClient. Any
-// changes made after connecting are ignored.
 type Config struct {
-	TransportConfiguration
-
+	Address        string
 	Jid            string
 	parsedJid      *Jid // For easier manipulation
-	Credential     Credential
+	Password       string
 	StreamLogger   *os.File // Used for debugging
 	Lang           string   // TODO: should default to 'en'
 	ConnectTimeout int      // Client timeout in seconds. Default to 15
+	// tls.Config must not be modified after having been passed to NewClient. The
+	// Client connect method may override the tls.Config.ServerName if it was not set.
+	TLSConfig *tls.Config
 	// Insecure can be set to true to allow to open a session without TLS. If TLS
 	// is supported on the server, we will still try to use it.
-	Insecure bool
+	Insecure      bool
+	CharsetReader func(charset string, input io.Reader) (io.Reader, error) // passed to xml decoder
 }
--- a/go.mod
+++ b/go.mod
@@ -1,10 +1,8 @@
 module gosrc.io/xmpp

-go 1.13
+go 1.12

 require (
-	github.com/google/go-cmp v0.3.1
-	github.com/google/uuid v1.1.1
-	golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7
-	nhooyr.io/websocket v1.6.5
+	github.com/google/go-cmp v0.3.0
+	golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522
 )
--- a/go.sum
+++ b/go.sum
@@ -1,106 +1,4 @@
-github.com/agnivade/wasmbrowsertest v0.3.1/go.mod h1:zQt6ZTdl338xxRaMW395qccVE2eQm0SjC/SDz0mPWQI=
-github.com/chromedp/cdproto v0.0.0-20190614062957-d6d2f92b486d/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190621002710-8cbd498dd7a0/go.mod h1:S8mB5wY3vV+vRIzf39xDXsw3XKYewW9X6rW2aEmkrSw=
-github.com/chromedp/cdproto v0.0.0-20190812224334-39ef923dcb8d/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/cdproto v0.0.0-20190926234355-1b4886c6fad6/go.mod h1:0YChpVzuLJC5CPr+x3xkHN6Z8KOSXjNbL7qV8Wc4GW0=
-github.com/chromedp/chromedp v0.3.1-0.20190619195644-fd957a4d2901/go.mod h1:mJdvfrVn594N9tfiPecUidF6W5jPRKHymqHfzbobPsM=
-github.com/chromedp/chromedp v0.4.0/go.mod h1:DC3QUn4mJ24dwjcaGQLoZrhm4X/uPHZ6spDbS2uFhm4=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
-github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/go-interpreter/wagon v0.5.1-0.20190713202023-55a163980b6c/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
-github.com/go-interpreter/wagon v0.6.0/go.mod h1:5+b/MBYkclRZngKF5s6qrgWxSLgE9F5dFdO1hAueZLc=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190908185732-236ed259b199/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
-github.com/knq/sysutil v0.0.0-20181215143952-f05b59f0f307/go.mod h1:BjPj+aVjl9FW/cCGiF3nGh5v+9Gd3VCgBQbod/GlMaQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mailru/easyjson v0.0.0-20190403194419-1ea4449da983/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190620125010-da37f6c1e481/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.0.5/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/twitchyliquid64/golang-asm v0.0.0-20190126203739-365674df15fc/go.mod h1:NoCfSFWosfqMqmmD7hApkirIK9ozpHjxRnRxs1l413A=
-go.coder.com/go-tools v0.0.0-20190317003359-0c6a35b74a16/go.mod h1:iKV5yK9t+J5nG9O3uF6KYdPEz3dyfMyB15MN1rbQ8Qw=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190306220234-b354f8bf4d9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190618155005-516e3c20635f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190927073244-c990c680b611/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522 h1:bhOzK9QyoD0ogCnFro1m2mz41+Ib0oOhfJnBp5MR4K4=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gotest.tools v2.1.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
-gotest.tools/gotestsum v0.3.5/go.mod h1:Mnf3e5FUzXbkCfynWBGOwLssY7gTQgCHObK9tMpAriY=
-mvdan.cc/sh v2.6.4+incompatible/go.mod h1:IeeQbZq+x2SUGBensq/jge5lLQbS3XT2ktyp3wrt4x8=
-nhooyr.io/websocket v1.6.5 h1:8TzpkldRfefda5JST+CnOH135bzVPz5uzfn/AF+gVKg=
-nhooyr.io/websocket v1.6.5/go.mod h1:F259lAzPRAH0htX2y3ehpJe09ih1aSHN7udWki1defY=
--- a/network.go
+++ b/network.go
@@ -23,7 +23,7 @@ func ensurePort(addr string, port int) string {
 		// This is IPV4 without port
 		return addr + ":" + strconv.Itoa(port)
 	case 1:
-		// This is IPV6 with port
+		// This is IPV$ with port
 		return addr
 	default:
 		// This is IPV6 without port, as you need to use bracket with port in IPV6
--- a/network_test.go
+++ b/network_test.go
@@ -1,10 +1,12 @@
 package xmpp

 import (
-	"strings"
 	"testing"
 )

+type params struct {
+}
+
 func TestParseAddr(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -31,36 +33,3 @@ func TestParseAddr(t *testing.T) {
 		})
 	}
 }
-
-func TestEnsurePort(t *testing.T) {
-	testAddresses := []string{
-		"1ca3:6c07:ee3a:89ca:e065:9a70:71d:daad",
-		"1ca3:6c07:ee3a:89ca:e065:9a70:71d:daad:5252",
-		"[::1]",
-		"127.0.0.1:5555",
-		"127.0.0.1",
-		"[::1]:5555",
-	}
-
-	for _, oldAddr := range testAddresses {
-		t.Run(oldAddr, func(st *testing.T) {
-			newAddr := ensurePort(oldAddr, 5222)
-
-			if len(newAddr) < len(oldAddr) {
-				st.Errorf("incorrect Result: transformed address is shorter than input : %v (old) > %v (new)", newAddr, oldAddr)
-			}
-			// If IPv6, the new address needs brackets to specify a port, like so : [2001:db8:85a3:0:0:8a2e:370:7334]:5222
-			if strings.Count(newAddr, "[") < strings.Count(oldAddr, "[") ||
-				strings.Count(newAddr, "]") < strings.Count(oldAddr, "]") {
-
-				st.Errorf("incorrect Result. Transformed address seems to not have correct brakets : %v => %v", oldAddr, newAddr)
-			}
-
-			// Check if we messed up the colons, or didn't properly add a port
-			if strings.Count(newAddr, ":") < strings.Count(oldAddr, ":") {
-				st.Errorf("incorrect Result: transformed address doesn't seem to have a port %v (=> %v, no port ?)", oldAddr, newAddr)
-			}
-		})
-	}
-
-}
--- a/router.go
+++ b/router.go
@@ -1,10 +1,8 @@
 package xmpp

 import (
-	"context"
 	"encoding/xml"
 	"strings"
-	"sync"

 	"gosrc.io/xmpp/stanza"
 )
@@ -27,35 +25,16 @@ TODO: Automatically reply to IQ that do not match any route, to comply to XMPP s
 type Router struct {
 	// Routes to be matched, in order.
 	routes []*Route
-
-	IQResultRoutes    map[string]*IQResultRoute
-	IQResultRouteLock sync.RWMutex
 }

 // NewRouter returns a new router instance.
 func NewRouter() *Router {
-	return &Router{
-		IQResultRoutes: make(map[string]*IQResultRoute),
-	}
+	return &Router{}
 }

 // route is called by the XMPP client to dispatch stanza received using the set up routes.
 // It is also used by test, but is not supposed to be used directly by users of the library.
 func (r *Router) route(s Sender, p stanza.Packet) {
-	iq, isIq := p.(stanza.IQ)
-	if isIq {
-		r.IQResultRouteLock.RLock()
-		route, ok := r.IQResultRoutes[iq.Id]
-		r.IQResultRouteLock.RUnlock()
-		if ok {
-			r.IQResultRouteLock.Lock()
-			delete(r.IQResultRoutes, iq.Id)
-			r.IQResultRouteLock.Unlock()
-			route.result <- iq
-			close(route.result)
-			return
-		}
-	}

 	var match RouteMatch
 	if r.Match(p, &match) {
@@ -63,10 +42,11 @@ func (r *Router) route(s Sender, p stanza.Packet) {
 		match.Handler.HandlePacket(s, p)
 		return
 	}
-
 	// If there is no match and we receive an iq set or get, we need to send a reply
-	if isIq && (iq.Type == stanza.IQTypeGet || iq.Type == stanza.IQTypeSet) {
-		iqNotImplemented(s, iq)
+	if iq, ok := p.(stanza.IQ); ok {
+		if iq.Type == stanza.IQTypeGet || iq.Type == stanza.IQTypeSet {
+			iqNotImplemented(s, iq)
+		}
 	}
 }

@@ -88,27 +68,6 @@ func (r *Router) NewRoute() *Route {
 	return route
 }

-// NewIQResultRoute register a route that will catch an IQ result stanza with
-// the given Id. The route will only match ones, after which it will automatically
-// be unregistered
-func (r *Router) NewIQResultRoute(ctx context.Context, id string) chan stanza.IQ {
-	route := NewIQResultRoute(ctx)
-	r.IQResultRouteLock.Lock()
-	r.IQResultRoutes[id] = route
-	r.IQResultRouteLock.Unlock()
-
-	// Start a go function to make sure the route is unregistered when the context
-	// is done.
-	go func() {
-		<-route.context.Done()
-		r.IQResultRouteLock.Lock()
-		delete(r.IQResultRoutes, id)
-		r.IQResultRouteLock.Unlock()
-	}()
-
-	return route.result
-}
-
 func (r *Router) Match(p stanza.Packet, match *RouteMatch) bool {
 	for _, route := range r.routes {
 		if route.Match(p, match) {
@@ -130,44 +89,8 @@ func (r *Router) HandleFunc(name string, f func(s Sender, p stanza.Packet)) *Rou
 	return r.NewRoute().Packet(name).HandlerFunc(f)
 }

-// ============================================================================
-
-// TimeoutHandlerFunc is a function type for handling IQ result timeouts.
-type TimeoutHandlerFunc func(err error)
-
-// IQResultRoute is a temporary route to match IQ result stanzas
-type IQResultRoute struct {
-	context context.Context
-	result  chan stanza.IQ
-}
-
-// NewIQResultRoute creates a new IQResultRoute instance
-func NewIQResultRoute(ctx context.Context) *IQResultRoute {
-	return &IQResultRoute{
-		context: ctx,
-		result:  make(chan stanza.IQ),
-	}
-}
-
-// ============================================================================
-// IQ result handler
-
-// IQResultHandler is a utility interface for IQ result handlers
-type IQResultHandler interface {
-	HandleIQ(ctx context.Context, s Sender, iq stanza.IQ)
-}
-
-// IQResultHandlerFunc is an adapter to allow using functions as IQ result handlers.
-type IQResultHandlerFunc func(ctx context.Context, s Sender, iq stanza.IQ)
-
-// HandleIQ is a proxy function to implement IQResultHandler using a function.
-func (f IQResultHandlerFunc) HandleIQ(ctx context.Context, s Sender, iq stanza.IQ) {
-	f(ctx, s, iq)
-}
-
 // ============================================================================
 // Route
-
 type Handler interface {
 	HandlePacket(s Sender, p stanza.Packet)
 }
@@ -175,7 +98,7 @@ type Handler interface {
 type Route struct {
 	handler Handler
 	// Matchers are used to "specialize" routes and focus on specific packet features
-	matchers []Matcher
+	matchers []matcher
 }

 func (r *Route) Handler(handler Handler) *Route {
@@ -199,8 +122,8 @@ func (r *Route) HandlerFunc(f HandlerFunc) *Route {
 	return r.Handler(f)
 }

-// AddMatcher adds a matcher to the route
-func (r *Route) AddMatcher(m Matcher) *Route {
+// addMatcher adds a matcher to the route
+func (r *Route) addMatcher(m matcher) *Route {
 	r.matchers = append(r.matchers, m)
 	return r
 }
@@ -247,7 +170,7 @@ func (n nameMatcher) Match(p stanza.Packet, match *RouteMatch) bool {
 // It matches on the Local part of the xml.Name
 func (r *Route) Packet(name string) *Route {
 	name = strings.ToLower(name)
-	return r.AddMatcher(nameMatcher(name))
+	return r.addMatcher(nameMatcher(name))
 }

 // -------------------------
@@ -281,7 +204,7 @@ func (r *Route) StanzaType(types ...string) *Route {
 	for k, v := range types {
 		types[k] = strings.ToLower(v)
 	}
-	return r.AddMatcher(nsTypeMatcher(types))
+	return r.addMatcher(nsTypeMatcher(types))
 }

 // -------------------------
@@ -306,15 +229,14 @@ func (r *Route) IQNamespaces(namespaces ...string) *Route {
 	for k, v := range namespaces {
 		namespaces[k] = strings.ToLower(v)
 	}
-	return r.AddMatcher(nsIQMatcher(namespaces))
+	return r.addMatcher(nsIQMatcher(namespaces))
 }

 // ============================================================================
 // Matchers

-// Matchers are used to "specialize" routes and focus on specific packet features.
-// You can register attach them to a route via the AddMatcher method.
-type Matcher interface {
+// Matchers are used to "specialize" routes and focus on specific packet features
+type matcher interface {
 	Match(stanza.Packet, *RouteMatch) bool
 }

--- a/router_test.go
+++ b/router_test.go
@@ -2,10 +2,8 @@ package xmpp

 import (
 	"bytes"
-	"context"
 	"encoding/xml"
 	"testing"
-	"time"

 	"gosrc.io/xmpp/stanza"
 )
@@ -13,47 +11,6 @@ import (
 // ============================================================================
 // Test route & matchers

-func TestIQResultRoutes(t *testing.T) {
-	t.Parallel()
-	router := NewRouter()
-	conn := NewSenderMock()
-
-	if router.IQResultRoutes == nil {
-		t.Fatal("NewRouter does not initialize isResultRoutes")
-	}
-
-	// Check if the IQ handler was called
-	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
-	defer cancel()
-	iq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeResult, Id: "1234"})
-	res := router.NewIQResultRoute(ctx, "1234")
-	go router.route(conn, iq)
-	select {
-	case <-ctx.Done():
-		t.Fatal("IQ result was not matched")
-	case <-res:
-		// Success
-	}
-
-	// The match must only happen once, so the id should no longer be in IQResultRoutes
-	if _, ok := router.IQResultRoutes[iq.Attrs.Id]; ok {
-		t.Fatal("IQ ID was not removed from the route map")
-	}
-
-	// Check other IQ does not matcah
-	ctx, cancel = context.WithTimeout(context.Background(), time.Millisecond*100)
-	defer cancel()
-	iq.Attrs.Id = "4321"
-	res = router.NewIQResultRoute(ctx, "1234")
-	go router.route(conn, iq)
-	select {
-	case <-ctx.Done():
-		// Success
-	case <-res:
-		t.Fatal("IQ result with wrong ID was matched")
-	}
-}
-
 func TestNameMatcher(t *testing.T) {
 	router := NewRouter()
 	router.HandleFunc("message", func(s Sender, p stanza.Packet) {
@@ -146,7 +103,7 @@ func TestTypeMatcher(t *testing.T) {

 	// We do not match on other types
 	conn = NewSenderMock()
-	iqVersion := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, From: "service.localhost", To: "test@localhost", Id: "1"})
+	iqVersion := stanza.NewIQ(stanza.Attrs{Type: "get", From: "service.localhost", To: "test@localhost", Id: "1"})
 	iqVersion.Payload = &stanza.DiscoInfo{
 		XMLName: xml.Name{
 			Space: "jabber:iq:version",
@@ -163,27 +120,27 @@ func TestCompositeMatcher(t *testing.T) {
 	router := NewRouter()
 	router.NewRoute().
 		IQNamespaces("jabber:iq:version").
-		StanzaType(string(stanza.IQTypeGet)).
+		StanzaType("get").
 		HandlerFunc(func(s Sender, p stanza.Packet) {
 			_ = s.SendRaw(successFlag)
 		})

 	// Data set
-	getVersionIq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, From: "service.localhost", To: "test@localhost", Id: "1"})
+	getVersionIq := stanza.NewIQ(stanza.Attrs{Type: "get", From: "service.localhost", To: "test@localhost", Id: "1"})
 	getVersionIq.Payload = &stanza.Version{
 		XMLName: xml.Name{
 			Space: "jabber:iq:version",
 			Local: "query",
 		}}

-	setVersionIq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeSet, From: "service.localhost", To: "test@localhost", Id: "1"})
+	setVersionIq := stanza.NewIQ(stanza.Attrs{Type: "set", From: "service.localhost", To: "test@localhost", Id: "1"})
 	setVersionIq.Payload = &stanza.Version{
 		XMLName: xml.Name{
 			Space: "jabber:iq:version",
 			Local: "query",
 		}}

-	GetDiscoIq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, From: "service.localhost", To: "test@localhost", Id: "1"})
+	GetDiscoIq := stanza.NewIQ(stanza.Attrs{Type: "get", From: "service.localhost", To: "test@localhost", Id: "1"})
 	GetDiscoIq.Payload = &stanza.DiscoInfo{
 		XMLName: xml.Name{
 			Space: "http://jabber.org/protocol/disco#info",
@@ -238,7 +195,7 @@ func TestCatchallMatcher(t *testing.T) {
 	}

 	conn = NewSenderMock()
-	iqVersion := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, From: "service.localhost", To: "test@localhost", Id: "1"})
+	iqVersion := stanza.NewIQ(stanza.Attrs{Type: "get", From: "service.localhost", To: "test@localhost", Id: "1"})
 	iqVersion.Payload = &stanza.DiscoInfo{
 		XMLName: xml.Name{
 			Space: "jabber:iq:version",
@@ -254,8 +211,7 @@ func TestCatchallMatcher(t *testing.T) {
 // ============================================================================
 // SenderMock

-const successFlag = "matched"
-const cancelledFlag = "cancelled"
+var successFlag = "matched"

 type SenderMock struct {
 	buffer *bytes.Buffer
@@ -274,15 +230,6 @@ func (s SenderMock) Send(packet stanza.Packet) error {
 	return nil
 }

-func (s SenderMock) SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, error) {
-	out, err := xml.Marshal(iq)
-	if err != nil {
-		return nil, err
-	}
-	s.buffer.Write(out)
-	return nil, nil
-}
-
 func (s SenderMock) SendRaw(str string) error {
 	s.buffer.WriteString(str)
 	return nil
--- a/session.go
+++ b/session.go
@@ -1,12 +1,18 @@
 package xmpp

 import (
+	"crypto/tls"
+	"encoding/xml"
 	"errors"
 	"fmt"
+	"io"
+	"net"

 	"gosrc.io/xmpp/stanza"
 )

+const xmppStreamOpen = "<?xml version='1.0'?><stream:stream to='%s' xmlns='%s' xmlns:stream='%s' version='1.0'>"
+
 type Session struct {
 	// Session info
 	BindJid      string // Jabber ID as provided by XMPP server
@@ -17,42 +23,42 @@ type Session struct {
 	lastPacketId int

 	// read / write
-	transport Transport
+	streamLogger io.ReadWriter
+	decoder      *xml.Decoder

 	// error management
 	err error
 }

-func NewSession(transport Transport, o Config, state SMState) (*Session, error) {
+func NewSession(conn net.Conn, o Config, state SMState) (net.Conn, *Session, error) {
 	s := new(Session)
-	s.transport = transport
 	s.SMState = state
-	s.init(o)
+	s.init(conn, o)
+
+	// starttls
+	var tlsConn net.Conn
+	tlsConn = s.startTlsIfSupported(conn, o.parsedJid.Domain, o)

 	if s.err != nil {
-		return nil, NewConnError(s.err, true)
+		return nil, nil, NewConnError(s.err, true)
 	}

-	if !transport.IsSecure() {
-		s.startTlsIfSupported(o)
-	}
-
-	if !transport.IsSecure() && !o.Insecure {
+	if !s.TlsEnabled && !o.Insecure {
 		err := fmt.Errorf("failed to negotiate TLS session : %s", s.err)
-		return nil, NewConnError(err, true)
+		return nil, nil, NewConnError(err, true)
 	}

 	if s.TlsEnabled {
-		s.reset(o)
+		s.reset(conn, tlsConn, o)
 	}

 	// auth
 	s.auth(o)
-	s.reset(o)
+	s.reset(tlsConn, tlsConn, o)

 	// attempt resumption
 	if s.resume(o) {
-		return s, s.err
+		return tlsConn, s, s.err
 	}

 	// otherwise, bind resource and 'start' XMPP session
@@ -62,7 +68,7 @@ func NewSession(transport Transport, o Config, state SMState) (*Session, error)
 	// Enable stream management if supported
 	s.EnableStreamManagement(o)

-	return s, s.err
+	return tlsConn, s, s.err
 }

 func (s *Session) PacketId() string {
@@ -70,59 +76,91 @@ func (s *Session) PacketId() string {
 	return fmt.Sprintf("%x", s.lastPacketId)
 }

-func (s *Session) init(o Config) {
+func (s *Session) init(conn net.Conn, o Config) {
+	s.setStreamLogger(nil, conn, o)
 	s.Features = s.open(o.parsedJid.Domain)
 }

-func (s *Session) reset(o Config) {
-	if s.StreamId, s.err = s.transport.StartStream(); s.err != nil {
+func (s *Session) reset(conn net.Conn, newConn net.Conn, o Config) {
+	if s.err != nil {
 		return
 	}

+	s.setStreamLogger(conn, newConn, o)
 	s.Features = s.open(o.parsedJid.Domain)
 }

+func (s *Session) setStreamLogger(conn net.Conn, newConn net.Conn, o Config) {
+	if newConn != conn {
+		s.streamLogger = newStreamLogger(newConn, o.StreamLogger)
+	}
+	s.decoder = xml.NewDecoder(s.streamLogger)
+	s.decoder.CharsetReader = o.CharsetReader
+}
+
 func (s *Session) open(domain string) (f stanza.StreamFeatures) {
+	// Send stream open tag
+	if _, s.err = fmt.Fprintf(s.streamLogger, xmppStreamOpen, domain, stanza.NSClient, stanza.NSStream); s.err != nil {
+		return
+	}
+
+	// Set xml decoder and extract streamID from reply
+	s.StreamId, s.err = stanza.InitStream(s.decoder) // TODO refactor / rename
+	if s.err != nil {
+		return
+	}
+
 	// extract stream features
-	if s.err = s.transport.GetDecoder().Decode(&f); s.err != nil {
+	if s.err = s.decoder.Decode(&f); s.err != nil {
 		s.err = errors.New("stream open decode features: " + s.err.Error())
 	}
 	return
 }

-func (s *Session) startTlsIfSupported(o Config) {
+func (s *Session) startTlsIfSupported(conn net.Conn, domain string, o Config) net.Conn {
 	if s.err != nil {
-		return
-	}
-
-	if !s.transport.DoesStartTLS() {
-		if !o.Insecure {
-			s.err = errors.New("Transport does not support starttls")
-		}
-		return
+		return conn
 	}

 	if _, ok := s.Features.DoesStartTLS(); ok {
-		fmt.Fprintf(s.transport, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")
+		fmt.Fprintf(s.streamLogger, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")

 		var k stanza.TLSProceed
-		if s.err = s.transport.GetDecoder().DecodeElement(&k, nil); s.err != nil {
+		if s.err = s.decoder.DecodeElement(&k, nil); s.err != nil {
 			s.err = errors.New("expecting starttls proceed: " + s.err.Error())
-			return
+			return conn
 		}

-		s.err = s.transport.StartTLS()
+		if o.TLSConfig == nil {
+			o.TLSConfig = &tls.Config{}
+		}
+
+		if o.TLSConfig.ServerName == "" {
+			o.TLSConfig.ServerName = domain
+		}
+		tlsConn := tls.Client(conn, o.TLSConfig)
+		// We convert existing connection to TLS
+		if s.err = tlsConn.Handshake(); s.err != nil {
+			return tlsConn
+		}
+
+		if !o.TLSConfig.InsecureSkipVerify {
+			s.err = tlsConn.VerifyHostname(domain)
+		}

 		if s.err == nil {
 			s.TlsEnabled = true
 		}
-		return
+		return tlsConn
 	}

 	// If we do not allow cleartext connections, make it explicit that server do not support starttls
 	if !o.Insecure {
 		s.err = errors.New("XMPP server does not advertise support for starttls")
 	}
+
+	// starttls is not supported => we do not upgrade the connection:
+	return conn
 }

 func (s *Session) auth(o Config) {
@@ -130,7 +168,7 @@ func (s *Session) auth(o Config) {
 		return
 	}

-	s.err = authSASL(s.transport, s.transport.GetDecoder(), s.Features, o.parsedJid.Node, o.Credential)
+	s.err = authSASL(s.streamLogger, s.decoder, s.Features, o.parsedJid.Node, o.Password)
 }

 // Attempt to resume session using stream management
@@ -142,11 +180,11 @@ func (s *Session) resume(o Config) bool {
 		return false
 	}

-	fmt.Fprintf(s.transport, "<resume xmlns='%s' h='%d' previd='%s'/>",
+	fmt.Fprintf(s.streamLogger, "<resume xmlns='%s' h='%d' previd='%s'/>",
 		stanza.NSStreamManagement, s.SMState.Inbound, s.SMState.Id)

 	var packet stanza.Packet
-	packet, s.err = stanza.NextPacket(s.transport.GetDecoder())
+	packet, s.err = stanza.NextPacket(s.decoder)
 	if s.err == nil {
 		switch p := packet.(type) {
 		case stanza.SMResumed:
@@ -173,14 +211,14 @@ func (s *Session) bind(o Config) {
 	// Send IQ message asking to bind to the local user name.
 	var resource = o.parsedJid.Resource
 	if resource != "" {
-		fmt.Fprintf(s.transport, "<iq type='set' id='%s'><bind xmlns='%s'><resource>%s</resource></bind></iq>",
+		fmt.Fprintf(s.streamLogger, "<iq type='set' id='%s'><bind xmlns='%s'><resource>%s</resource></bind></iq>",
 			s.PacketId(), stanza.NSBind, resource)
 	} else {
-		fmt.Fprintf(s.transport, "<iq type='set' id='%s'><bind xmlns='%s'/></iq>", s.PacketId(), stanza.NSBind)
+		fmt.Fprintf(s.streamLogger, "<iq type='set' id='%s'><bind xmlns='%s'/></iq>", s.PacketId(), stanza.NSBind)
 	}

 	var iq stanza.IQ
-	if s.err = s.transport.GetDecoder().Decode(&iq); s.err != nil {
+	if s.err = s.decoder.Decode(&iq); s.err != nil {
 		s.err = errors.New("error decoding iq bind result: " + s.err.Error())
 		return
 	}
@@ -205,8 +243,8 @@ func (s *Session) rfc3921Session(o Config) {
 	var iq stanza.IQ
 	// We only negotiate session binding if it is mandatory, we skip it when optional.
 	if !s.Features.Session.IsOptional() {
-		fmt.Fprintf(s.transport, "<iq type='set' id='%s'><session xmlns='%s'/></iq>", s.PacketId(), stanza.NSSession)
-		if s.err = s.transport.GetDecoder().Decode(&iq); s.err != nil {
+		fmt.Fprintf(s.streamLogger, "<iq type='set' id='%s'><session xmlns='%s'/></iq>", s.PacketId(), stanza.NSSession)
+		if s.err = s.decoder.Decode(&iq); s.err != nil {
 			s.err = errors.New("expecting iq result after session open: " + s.err.Error())
 			return
 		}
@@ -222,10 +260,10 @@ func (s *Session) EnableStreamManagement(o Config) {
 		return
 	}

-	fmt.Fprintf(s.transport, "<enable xmlns='%s' resume='true'/>", stanza.NSStreamManagement)
+	fmt.Fprintf(s.streamLogger, "<enable xmlns='%s' resume='true'/>", stanza.NSStreamManagement)

 	var packet stanza.Packet
-	packet, s.err = stanza.NextPacket(s.transport.GetDecoder())
+	packet, s.err = stanza.NextPacket(s.decoder)
 	if s.err == nil {
 		switch p := packet.(type) {
 		case stanza.SMEnabled:
--- a/stanza/component.go
+++ b/stanza/component.go
@@ -12,7 +12,7 @@ import (
 type Handshake struct {
 	XMLName xml.Name `xml:"jabber:component:accept handshake"`
 	// TODO Add handshake value with test for proper serialization
-	Value string `xml:",innerxml"`
+	// Value string     `xml:",innerxml"`
 }

 func (Handshake) Name() string {
--- a/stanza/error.go
+++ b/stanza/error.go
@@ -54,7 +54,7 @@ func (x *Err) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {

 			textName := xml.Name{Space: "urn:ietf:params:xml:ns:xmpp-stanzas", Local: "text"}
 			if elt.XMLName == textName {
-				x.Text = elt.Content
+				x.Text = string(elt.Content)
 			} else if elt.XMLName.Space == "urn:ietf:params:xml:ns:xmpp-stanzas" {
 				x.Reason = elt.XMLName.Local
 			}
@@ -94,32 +94,16 @@ func (x Err) MarshalXML(e *xml.Encoder, start xml.StartElement) (err error) {
 	// Reason
 	if x.Reason != "" {
 		reason := xml.Name{Space: "urn:ietf:params:xml:ns:xmpp-stanzas", Local: x.Reason}
-		err = e.EncodeToken(xml.StartElement{Name: reason})
-		if err != nil {
-			return err
-		}
-		err = e.EncodeToken(xml.EndElement{Name: reason})
-		if err != nil {
-			return err
-		}
-
+		e.EncodeToken(xml.StartElement{Name: reason})
+		e.EncodeToken(xml.EndElement{Name: reason})
 	}

 	// Text
 	if x.Text != "" {
 		text := xml.Name{Space: "urn:ietf:params:xml:ns:xmpp-stanzas", Local: "text"}
-		err = e.EncodeToken(xml.StartElement{Name: text})
-		if err != nil {
-			return err
-		}
-		err = e.EncodeToken(xml.CharData(x.Text))
-		if err != nil {
-			return err
-		}
-		err = e.EncodeToken(xml.EndElement{Name: text})
-		if err != nil {
-			return err
-		}
+		e.EncodeToken(xml.StartElement{Name: text})
+		e.EncodeToken(xml.CharData(x.Text))
+		e.EncodeToken(xml.EndElement{Name: text})
 	}

 	return e.EncodeToken(xml.EndElement{Name: start.Name})
--- a/stanza/error_test.go
+++ b/stanza/error_test.go
@@ -1,31 +0,0 @@
-package stanza
-
-import (
-	"encoding/xml"
-	"testing"
-)
-
-func TestErr_UnmarshalXML(t *testing.T) {
-	packet := `
- <iq from='pubsub.example.com'
-       id='kj4vz31m'
-       to='romeo@example.net/foo'
-       type='error'>
-  <error type='wait'>
-    <resource-constraint
-        xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
-    <text xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>System overloaded, please retry</text>
-  </error>
- </iq>`
-
-	parsedIQ := IQ{}
-	data := []byte(packet)
-	if err := xml.Unmarshal(data, &parsedIQ); err != nil {
-		t.Errorf("Unmarshal(%s) returned error", data)
-	}
-
-	xmppError := parsedIQ.Error
-	if xmppError.Text != "System overloaded, please retry" {
-		t.Errorf("Could not extract error text: '%s'", xmppError.Text)
-	}
-}
--- a/stanza/iot_test.go
+++ b/stanza/iot_test.go
@@ -21,6 +21,6 @@ func TestControlSet(t *testing.T) {
 	}

 	if cs, ok := parsedIQ.Payload.(*ControlSet); !ok {
-		t.Errorf("Payload is not an iot control set: %v", cs)
+		t.Errorf("Paylod is not an iot control set: %v", cs)
 	}
 }
--- a/stanza/iq.go
+++ b/stanza/iq.go
@@ -2,9 +2,6 @@ package stanza

 import (
 	"encoding/xml"
-	"strings"
-
-	"github.com/google/uuid"
 )

 /*
@@ -24,8 +21,8 @@ type IQ struct { // Info/Query
 	//    child element, which specifies the semantics of the particular
 	//    request."
 	Payload IQPayload `xml:",omitempty"`
-	Error   *Err      `xml:"error,omitempty"`
-	// Any is used to decode unknown payload as a generic structure
+	Error   Err       `xml:"error,omitempty"`
+	// Any is used to decode unknown payload as a generique structure
 	Any *Node `xml:",any"`
 }

@@ -34,12 +31,8 @@ type IQPayload interface {
 }

 func NewIQ(a Attrs) IQ {
+	// TODO generate IQ ID if not set
 	// TODO ensure that type is set, as it is required
-	if a.Id == "" {
-		if id, err := uuid.NewRandom(); err == nil {
-			a.Id = id.String()
-		}
-	}
 	return IQ{
 		XMLName: xml.Name{Local: "iq"},
 		Attrs:   a,
@@ -53,7 +46,7 @@ func (iq IQ) MakeError(xerror Err) IQ {
 	iq.Type = "error"
 	iq.From = to
 	iq.To = from
-	iq.Error = &xerror
+	iq.Error = xerror

 	return iq
 }
@@ -107,7 +100,7 @@ func (iq *IQ) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
 				if err != nil {
 					return err
 				}
-				iq.Error = &xmppError
+				iq.Error = xmppError
 				continue
 			}
 			if iqExt := TypeRegistry.GetIQExtension(tt.Name); iqExt != nil {
@@ -133,39 +126,3 @@ func (iq *IQ) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
 		}
 	}
 }
-
-// Following RFC-3920 for IQs
-func (iq *IQ) IsValid() bool {
-	// ID is required
-	if len(strings.TrimSpace(iq.Id)) == 0 {
-		return false
-	}
-
-	// Type is required
-	if iq.Type.IsEmpty() {
-		return false
-	}
-
-	// Type get and set must contain one and only one child element that specifies the semantics
-	if iq.Type == IQTypeGet || iq.Type == IQTypeSet {
-		if iq.Payload == nil && iq.Any == nil {
-			return false
-		}
-	}
-
-	// A result must include zero or one child element
-	if iq.Type == IQTypeResult {
-		if iq.Payload != nil && iq.Any != nil {
-			return false
-		}
-	}
-
-	//Error type must contain an "error" child element
-	if iq.Type == IQTypeError {
-		if iq.Error == nil {
-			return false
-		}
-	}
-
-	return true
-}
--- a/stanza/iq_test.go
+++ b/stanza/iq_test.go
@@ -34,24 +34,6 @@ func TestUnmarshalIqs(t *testing.T) {
 	}
 }

-func TestGenerateIqId(t *testing.T) {
-	t.Parallel()
-	iq := stanza.NewIQ(stanza.Attrs{Id: "1"})
-	if iq.Id != "1" {
-		t.Errorf("NewIQ replaced id with %s", iq.Id)
-	}
-
-	iq = stanza.NewIQ(stanza.Attrs{})
-	if iq.Id == "" {
-		t.Error("NewIQ did not generate an Id")
-	}
-
-	otherIq := stanza.NewIQ(stanza.Attrs{})
-	if iq.Id == otherIq.Id {
-		t.Errorf("NewIQ generated two identical ids: %s", iq.Id)
-	}
-}
-
 func TestGenerateIq(t *testing.T) {
 	iq := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeResult, From: "admin@localhost", To: "test@localhost", Id: "1"})
 	payload := stanza.DiscoInfo{
@@ -187,38 +169,3 @@ func TestUnknownPayload(t *testing.T) {
 		t.Errorf("could not extract namespace: '%s'", parsedIQ.Any.XMLName.Space)
 	}
 }
-
-func TestIsValid(t *testing.T) {
-	type testCase struct {
-		iq        string
-		shouldErr bool
-	}
-	testIQs := make(map[string]testCase)
-	testIQs["Valid IQ"] = testCase{
-		`<iq type="get" to="service.localhost" id="1" >
- 			<query xmlns="unknown:ns"/>
-		</iq>`,
-		false,
-	}
-	testIQs["Invalid IQ"] = testCase{
-		`<iq type="get" to="service.localhost">
- 			<query xmlns="unknown:ns"/>
-		</iq>`,
-		true,
-	}
-
-	for name, tcase := range testIQs {
-		t.Run(name, func(st *testing.T) {
-			parsedIQ := stanza.IQ{}
-			err := xml.Unmarshal([]byte(tcase.iq), &parsedIQ)
-			if err != nil {
-				t.Errorf("Unmarshal error: %#v (%s)", err, tcase.iq)
-				return
-			}
-			if !parsedIQ.IsValid() && !tcase.shouldErr {
-				t.Errorf("failed iq validation for : %s", tcase.iq)
-			}
-		})
-	}
-
-}
--- a/stanza/node.go
+++ b/stanza/node.go
@@ -10,7 +10,7 @@ import "encoding/xml"
 type Node struct {
 	XMLName xml.Name
 	Attrs   []xml.Attr `xml:"-"`
-	Content string     `xml:",cdata"`
+	Content string     `xml:",innerxml"`
 	Nodes   []Node     `xml:",any"`
 }

@@ -46,18 +46,6 @@ func (n Node) MarshalXML(e *xml.Encoder, start xml.StartElement) (err error) {
 	start.Name = n.XMLName

 	err = e.EncodeToken(start)
-	if err != nil {
-		return err
-	}
-	err = e.EncodeElement(n.Nodes, xml.StartElement{Name: n.XMLName})
-	if err != nil {
-		return err
-	}
-	if n.Content != "" {
-		err = e.EncodeToken(xml.CharData(n.Content))
-		if err != nil {
-			return err
-		}
-	}
+	e.EncodeElement(n.Nodes, xml.StartElement{Name: n.XMLName})
 	return e.EncodeToken(xml.EndElement{Name: start.Name})
 }
--- a/stanza/node_test.go
+++ b/stanza/node_test.go
@@ -1,30 +0,0 @@
-package stanza
-
-import (
-	"encoding/xml"
-	"testing"
-)
-
-func TestNode_Marshal(t *testing.T) {
-	jsonData := []byte("{\"key\":\"value\"}")
-
-	iqResp := NewIQ(Attrs{Type: "result", From: "admin@localhost", To: "test@localhost", Id: "1"})
-	iqResp.Any = &Node{
-		XMLName: xml.Name{Space: "myNS", Local: "space"},
-		Content: string(jsonData),
-	}
-
-	bytes, err := xml.Marshal(iqResp)
-	if err != nil {
-		t.Errorf("Could not marshal XML: %v", err)
-	}
-
-	parsedIQ := IQ{}
-	if err := xml.Unmarshal(bytes, &parsedIQ); err != nil {
-		t.Errorf("Unmarshal returned error: %v", err)
-	}
-
-	if parsedIQ.Any.Content != string(jsonData) {
-		t.Errorf("Cannot find generic any payload in parsedIQ: '%s'", parsedIQ.Any.Content)
-	}
-}
--- a/stanza/ns.go
+++ b/stanza/ns.go
@@ -6,7 +6,6 @@ const (
 	NSSASL      = "urn:ietf:params:xml:ns:xmpp-sasl"
 	NSBind      = "urn:ietf:params:xml:ns:xmpp-bind"
 	NSSession   = "urn:ietf:params:xml:ns:xmpp-session"
-	NSFraming   = "urn:ietf:params:xml:ns:xmpp-framing"
 	NSClient    = "jabber:client"
 	NSComponent = "jabber:component:accept"
 )
--- a/stanza/open.go
+++ b/stanza/open.go
@@ -1,13 +0,0 @@
-package stanza
-
-import "encoding/xml"
-
-// Open Packet
-// Reference: WebSocket connections must start with this element
-//            https://tools.ietf.org/html/rfc7395#section-3.4
-type WebsocketOpen struct {
-	XMLName xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-framing open"`
-	From    string   `xml:"from,attr"`
-	Id      string   `xml:"id,attr"`
-	Version string   `xml:"version,attr"`
-}
--- a/stanza/packet_enum.go
+++ b/stanza/packet_enum.go
@@ -1,7 +1,5 @@
 package stanza

-import "strings"
-
 type StanzaType string

 // RFC 6120: part of A.5 Client Namespace and A.6 Server Namespace
@@ -25,7 +23,3 @@ const (
 	PresenceTypeUnsubscribe  StanzaType = "unsubscribe"
 	PresenceTypeUnsubscribed StanzaType = "unsubscribed"
 )
-
-func (s StanzaType) IsEmpty() bool {
-	return len(strings.TrimSpace(string(s))) == 0
-}
--- a/stanza/parser.go
+++ b/stanza/parser.go
@@ -24,10 +24,8 @@ func InitStream(p *xml.Decoder) (sessionID string, err error) {

 		switch elem := t.(type) {
 		case xml.StartElement:
-			isStreamOpen := elem.Name.Space == NSStream && elem.Name.Local == "stream"
-			isFrameOpen := elem.Name.Space == NSFraming && elem.Name.Local == "open"
-			if !isStreamOpen && !isFrameOpen {
-				err = errors.New("xmpp: expected <stream> or <open> but got <" + elem.Name.Local + "> in " + elem.Name.Space)
+			if elem.Name.Space != NSStream || elem.Name.Local != "stream" {
+				err = errors.New("xmpp: expected <stream> but got <" + elem.Name.Local + "> in " + elem.Name.Space)
 				return sessionID, err
 			}

--- a/stanza/sasl_auth.go
+++ b/stanza/sasl_auth.go
@@ -107,6 +107,6 @@ func (s *StreamSession) IsOptional() bool {
 // Registry init

 func init() {
-	TypeRegistry.MapExtension(PKTIQ, xml.Name{Space: "urn:ietf:params:xml:ns:xmpp-bind", Local: "bind"}, Bind{})
-	TypeRegistry.MapExtension(PKTIQ, xml.Name{Space: "urn:ietf:params:xml:ns:xmpp-session", Local: "session"}, StreamSession{})
+	TypeRegistry.MapExtension(PKTIQ, xml.Name{"urn:ietf:params:xml:ns:xmpp-bind", "bind"}, Bind{})
+	TypeRegistry.MapExtension(PKTIQ, xml.Name{"urn:ietf:params:xml:ns:xmpp-session", "session"}, StreamSession{})
 }
--- a/stanza/stream.go
+++ b/stanza/stream.go
@@ -1,14 +1,167 @@
 package stanza

-import "encoding/xml"
+import (
+	"encoding/xml"
+)

-// Start of stream
-// Reference: XMPP Core stream open
-//            https://tools.ietf.org/html/rfc6120#section-4.2
-type Stream struct {
-	XMLName xml.Name `xml:"http://etherx.jabber.org/streams stream"`
-	From    string   `xml:"from,attr"`
-	To      string   `xml:"to,attr"`
-	Id      string   `xml:"id,attr"`
-	Version string   `xml:"version,attr"`
+// ============================================================================
+// StreamFeatures Packet
+// Reference: The active stream features are published on
+//            https://xmpp.org/registrar/stream-features.html
+// Note: That page misses draft and experimental XEP (i.e CSI, etc)
+
+type StreamFeatures struct {
+	XMLName xml.Name `xml:"http://etherx.jabber.org/streams features"`
+	// Server capabilities hash
+	Caps Caps
+	// Stream features
+	StartTLS         tlsStartTLS
+	Mechanisms       saslMechanisms
+	Bind             Bind
+	StreamManagement streamManagement
+	// Obsolete
+	Session StreamSession
+	// ProcessOne Stream Features
+	P1Push   p1Push
+	P1Rebind p1Rebind
+	p1Ack    p1Ack
+	Any      []xml.Name `xml:",any"`
+}
+
+func (StreamFeatures) Name() string {
+	return "stream:features"
+}
+
+type streamFeatureDecoder struct{}
+
+var streamFeatures streamFeatureDecoder
+
+func (streamFeatureDecoder) decode(p *xml.Decoder, se xml.StartElement) (StreamFeatures, error) {
+	var packet StreamFeatures
+	err := p.DecodeElement(&packet, &se)
+	return packet, err
+}
+
+// Capabilities
+// Reference: https://xmpp.org/extensions/xep-0115.html#stream
+//    "A server MAY include its entity capabilities in a stream feature element so that connecting clients
+//     and peer servers do not need to send service discovery requests each time they connect."
+// This is not a stream feature but a way to let client cache server disco info.
+type Caps struct {
+	XMLName xml.Name `xml:"http://jabber.org/protocol/caps c"`
+	Hash    string   `xml:"hash,attr"`
+	Node    string   `xml:"node,attr"`
+	Ver     string   `xml:"ver,attr"`
+	Ext     string   `xml:"ext,attr,omitempty"`
+}
+
+// ============================================================================
+// Supported Stream Features
+
+// StartTLS feature
+// Reference: RFC 6120 - https://tools.ietf.org/html/rfc6120#section-5.4
+type tlsStartTLS struct {
+	XMLName  xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-tls starttls"`
+	Required bool
+}
+
+// UnmarshalXML implements custom parsing startTLS required flag
+func (stls *tlsStartTLS) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	stls.XMLName = start.Name
+
+	// Check subelements to extract required field as boolean
+	for {
+		t, err := d.Token()
+		if err != nil {
+			return err
+		}
+
+		switch tt := t.(type) {
+
+		case xml.StartElement:
+			elt := new(Node)
+
+			err = d.DecodeElement(elt, &tt)
+			if err != nil {
+				return err
+			}
+
+			if elt.XMLName.Local == "required" {
+				stls.Required = true
+			}
+
+		case xml.EndElement:
+			if tt == start.End() {
+				return nil
+			}
+		}
+	}
+}
+
+func (sf *StreamFeatures) DoesStartTLS() (feature tlsStartTLS, isSupported bool) {
+	if sf.StartTLS.XMLName.Space+" "+sf.StartTLS.XMLName.Local == nsTLS+" starttls" {
+		return sf.StartTLS, true
+	}
+	return feature, false
+}
+
+// Mechanisms
+// Reference: RFC 6120 - https://tools.ietf.org/html/rfc6120#section-6.4.1
+type saslMechanisms struct {
+	XMLName   xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-sasl mechanisms"`
+	Mechanism []string `xml:"mechanism"`
+}
+
+// StreamManagement
+// Reference: XEP-0198 - https://xmpp.org/extensions/xep-0198.html#feature
+type streamManagement struct {
+	XMLName xml.Name `xml:"urn:xmpp:sm:3 sm"`
+}
+
+func (sf *StreamFeatures) DoesStreamManagement() (isSupported bool) {
+	if sf.StreamManagement.XMLName.Space+" "+sf.StreamManagement.XMLName.Local == "urn:xmpp:sm:3 sm" {
+		return true
+	}
+	return false
+}
+
+// P1 extensions
+// Reference: https://docs.ejabberd.im/developer/mobile/core-features/
+
+// p1:push support
+type p1Push struct {
+	XMLName xml.Name `xml:"p1:push push"`
+}
+
+// p1:rebind suppor
+type p1Rebind struct {
+	XMLName xml.Name `xml:"p1:rebind rebind"`
+}
+
+// p1:ack support
+type p1Ack struct {
+	XMLName xml.Name `xml:"p1:ack ack"`
+}
+
+// ============================================================================
+// StreamError Packet
+
+type StreamError struct {
+	XMLName xml.Name `xml:"http://etherx.jabber.org/streams error"`
+	Error   xml.Name `xml:",any"`
+	Text    string   `xml:"urn:ietf:params:xml:ns:xmpp-streams text"`
+}
+
+func (StreamError) Name() string {
+	return "stream:error"
+}
+
+type streamErrorDecoder struct{}
+
+var streamError streamErrorDecoder
+
+func (streamErrorDecoder) decode(p *xml.Decoder, se xml.StartElement) (StreamError, error) {
+	var packet StreamError
+	err := p.DecodeElement(&packet, &se)
+	return packet, err
 }
--- a/stanza/stream_features.go
+++ b/stanza/stream_features.go
@@ -1,167 +0,0 @@
-package stanza
-
-import (
-	"encoding/xml"
-)
-
-// ============================================================================
-// StreamFeatures Packet
-// Reference: The active stream features are published on
-//            https://xmpp.org/registrar/stream-features.html
-// Note: That page misses draft and experimental XEP (i.e CSI, etc)
-
-type StreamFeatures struct {
-	XMLName xml.Name `xml:"http://etherx.jabber.org/streams features"`
-	// Server capabilities hash
-	Caps Caps
-	// Stream features
-	StartTLS         TlsStartTLS
-	Mechanisms       saslMechanisms
-	Bind             Bind
-	StreamManagement streamManagement
-	// Obsolete
-	Session StreamSession
-	// ProcessOne Stream Features
-	P1Push   p1Push
-	P1Rebind p1Rebind
-	p1Ack    p1Ack
-	Any      []xml.Name `xml:",any"`
-}
-
-func (StreamFeatures) Name() string {
-	return "stream:features"
-}
-
-type streamFeatureDecoder struct{}
-
-var streamFeatures streamFeatureDecoder
-
-func (streamFeatureDecoder) decode(p *xml.Decoder, se xml.StartElement) (StreamFeatures, error) {
-	var packet StreamFeatures
-	err := p.DecodeElement(&packet, &se)
-	return packet, err
-}
-
-// Capabilities
-// Reference: https://xmpp.org/extensions/xep-0115.html#stream
-//    "A server MAY include its entity capabilities in a stream feature element so that connecting clients
-//     and peer servers do not need to send service discovery requests each time they connect."
-// This is not a stream feature but a way to let client cache server disco info.
-type Caps struct {
-	XMLName xml.Name `xml:"http://jabber.org/protocol/caps c"`
-	Hash    string   `xml:"hash,attr"`
-	Node    string   `xml:"node,attr"`
-	Ver     string   `xml:"ver,attr"`
-	Ext     string   `xml:"ext,attr,omitempty"`
-}
-
-// ============================================================================
-// Supported Stream Features
-
-// StartTLS feature
-// Reference: RFC 6120 - https://tools.ietf.org/html/rfc6120#section-5.4
-type TlsStartTLS struct {
-	XMLName  xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-tls starttls"`
-	Required bool
-}
-
-// UnmarshalXML implements custom parsing startTLS required flag
-func (stls *TlsStartTLS) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
-	stls.XMLName = start.Name
-
-	// Check subelements to extract required field as boolean
-	for {
-		t, err := d.Token()
-		if err != nil {
-			return err
-		}
-
-		switch tt := t.(type) {
-
-		case xml.StartElement:
-			elt := new(Node)
-
-			err = d.DecodeElement(elt, &tt)
-			if err != nil {
-				return err
-			}
-
-			if elt.XMLName.Local == "required" {
-				stls.Required = true
-			}
-
-		case xml.EndElement:
-			if tt == start.End() {
-				return nil
-			}
-		}
-	}
-}
-
-func (sf *StreamFeatures) DoesStartTLS() (feature TlsStartTLS, isSupported bool) {
-	if sf.StartTLS.XMLName.Space+" "+sf.StartTLS.XMLName.Local == nsTLS+" starttls" {
-		return sf.StartTLS, true
-	}
-	return feature, false
-}
-
-// Mechanisms
-// Reference: RFC 6120 - https://tools.ietf.org/html/rfc6120#section-6.4.1
-type saslMechanisms struct {
-	XMLName   xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-sasl mechanisms"`
-	Mechanism []string `xml:"mechanism"`
-}
-
-// StreamManagement
-// Reference: XEP-0198 - https://xmpp.org/extensions/xep-0198.html#feature
-type streamManagement struct {
-	XMLName xml.Name `xml:"urn:xmpp:sm:3 sm"`
-}
-
-func (sf *StreamFeatures) DoesStreamManagement() (isSupported bool) {
-	if sf.StreamManagement.XMLName.Space+" "+sf.StreamManagement.XMLName.Local == "urn:xmpp:sm:3 sm" {
-		return true
-	}
-	return false
-}
-
-// P1 extensions
-// Reference: https://docs.ejabberd.im/developer/mobile/core-features/
-
-// p1:push support
-type p1Push struct {
-	XMLName xml.Name `xml:"p1:push push"`
-}
-
-// p1:rebind suppor
-type p1Rebind struct {
-	XMLName xml.Name `xml:"p1:rebind rebind"`
-}
-
-// p1:ack support
-type p1Ack struct {
-	XMLName xml.Name `xml:"p1:ack ack"`
-}
-
-// ============================================================================
-// StreamError Packet
-
-type StreamError struct {
-	XMLName xml.Name `xml:"http://etherx.jabber.org/streams error"`
-	Error   xml.Name `xml:",any"`
-	Text    string   `xml:"urn:ietf:params:xml:ns:xmpp-streams text"`
-}
-
-func (StreamError) Name() string {
-	return "stream:error"
-}
-
-type streamErrorDecoder struct{}
-
-var streamError streamErrorDecoder
-
-func (streamErrorDecoder) decode(p *xml.Decoder, se xml.StartElement) (StreamError, error) {
-	var packet StreamError
-	err := p.DecodeElement(&packet, &se)
-	return packet, err
-}
--- a/stanza/stream_features_test.go
+++ b/stanza/stream_features_test.go
--- a/stream_logger.go
+++ b/stream_logger.go
@@ -2,16 +2,17 @@ package xmpp

 import (
 	"io"
+	"os"
 )

 // Mediated Read / Write on socket
 // Used if logFile from Config is not nil
 type streamLogger struct {
 	socket  io.ReadWriter // Actual connection
-	logFile io.Writer
+	logFile *os.File
 }

-func newStreamLogger(conn io.ReadWriter, logFile io.Writer) io.ReadWriter {
+func newStreamLogger(conn io.ReadWriter, logFile *os.File) io.ReadWriter {
 	if logFile == nil {
 		return conn
 	} else {
@@ -19,21 +20,21 @@ func newStreamLogger(conn io.ReadWriter, logFile io.Writer) io.ReadWriter {
 	}
 }

-func (sl *streamLogger) Read(p []byte) (n int, err error) {
-	n, err = sl.socket.Read(p)
+func (sp *streamLogger) Read(p []byte) (n int, err error) {
+	n, err = sp.socket.Read(p)
 	if n > 0 {
-		sl.logFile.Write([]byte("RECV:\n")) // Prefix
-		if n, err := sl.logFile.Write(p[:n]); err != nil {
+		sp.logFile.Write([]byte("RECV:\n")) // Prefix
+		if n, err := sp.logFile.Write(p[:n]); err != nil {
 			return n, err
 		}
-		sl.logFile.Write([]byte("\n\n")) // Separator
+		sp.logFile.Write([]byte("\n\n")) // Separator
 	}
 	return
 }

-func (sl *streamLogger) Write(p []byte) (n int, err error) {
-	sl.logFile.Write([]byte("SEND:\n")) // Prefix
-	for _, w := range []io.Writer{sl.socket, sl.logFile} {
+func (sp *streamLogger) Write(p []byte) (n int, err error) {
+	sp.logFile.Write([]byte("SEND:\n")) // Prefix
+	for _, w := range []io.Writer{sp.socket, sp.logFile} {
 		n, err = w.Write(p)
 		if err != nil {
 			return
@@ -43,7 +44,7 @@ func (sl *streamLogger) Write(p []byte) (n int, err error) {
 			return
 		}
 	}
-	sl.logFile.Write([]byte("\n\n")) // Separator
+	sp.logFile.Write([]byte("\n\n")) // Separator
 	return len(p), nil
 }

--- a/stream_manager.go
+++ b/stream_manager.go
@@ -1,7 +1,6 @@
 package xmpp

 import (
-	"context"
 	"errors"
 	"sync"
 	"time"
@@ -27,7 +26,6 @@ type StreamClient interface {
 	Connect() error
 	Resume(state SMState) error
 	Send(packet stanza.Packet) error
-	SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, error)
 	SendRaw(packet string) error
 	Disconnect()
 	SetHandler(handler EventHandler)
@@ -37,7 +35,6 @@ type StreamClient interface {
 // It is mostly use in callback to pass a limited subset of the stream client interface
 type Sender interface {
 	Send(packet stanza.Packet) error
-	SendIQ(ctx context.Context, iq stanza.IQ) (chan stanza.IQ, error)
 	SendRaw(packet string) error
 }

@@ -74,7 +71,7 @@ func (sm *StreamManager) Run() error {
 		return errors.New("missing stream client")
 	}

-	handler := func(e Event) error {
+	handler := func(e Event) {
 		switch e.State {
 		case StateConnected:
 			sm.Metrics.setConnectTime()
@@ -82,18 +79,14 @@ func (sm *StreamManager) Run() error {
 			sm.Metrics.setLoginTime()
 		case StateDisconnected:
 			// Reconnect on disconnection
-			return sm.resume(e.SMState)
+			sm.resume(e.SMState)
 		case StateStreamError:
 			sm.client.Disconnect()
 			// Only try reconnecting if we have not been kicked by another session to avoid connection loop.
-			// TODO: Make this conflict exception a permanent error
 			if e.StreamError != "conflict" {
-				return sm.connect()
+				sm.connect()
 			}
-		case StatePermanentError:
-			// Do not attempt to reconnect
 		}
-		return nil
 	}
 	sm.client.SetHandler(handler)

@@ -159,7 +152,7 @@ type Metrics struct {
 	ConnectTime time.Duration
 	// LoginTime returns the between client initiation of the TCP/IP
 	// connection to the server and the return of the login result.
-	// This includes ConnectTime, but also XMPP level protocol negotiation
+	// This includes ConnectTime, but also XMPP level protocol negociation
 	// like starttls.
 	LoginTime time.Duration
 }
--- a/test.sh
+++ b/test.sh
@@ -5,7 +5,7 @@ export GO111MODULE=on
 echo "" > coverage.txt

 for d in $(go list ./... | grep -v vendor); do
-    go test -race -coverprofile=profile.out -covermode=atomic "${d}"
+    go test -race -coverprofile=profile.out -covermode=atomic ${d}
    if [ -f profile.out ]; then
        cat profile.out >> coverage.txt
        rm profile.out
--- a/transport.go
+++ b/transport.go
@@ -1,75 +0,0 @@
-package xmpp
-
-import (
-	"crypto/tls"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-)
-
-var ErrTransportProtocolNotSupported = errors.New("Transport protocol not supported")
-var ErrTLSNotSupported = errors.New("Transport does not support StartTLS")
-
-// TODO: rename to transport config?
-type TransportConfiguration struct {
-	// Address is the XMPP Host and port to connect to. Host is of
-	// the form 'serverhost:port' i.e "localhost:8888"
-	Address        string
-	Domain         string
-	ConnectTimeout int // Client timeout in seconds. Default to 15
-	// tls.Config must not be modified after having been passed to NewClient. Any
-	// changes made after connecting are ignored.
-	TLSConfig     *tls.Config
-	CharsetReader func(charset string, input io.Reader) (io.Reader, error) // passed to xml decoder
-}
-
-type Transport interface {
-	Connect() (string, error)
-	DoesStartTLS() bool
-	StartTLS() error
-
-	LogTraffic(logFile io.Writer)
-
-	StartStream() (string, error)
-	GetDecoder() *xml.Decoder
-	IsSecure() bool
-
-	Ping() error
-	Read(p []byte) (n int, err error)
-	Write(p []byte) (n int, err error)
-	Close() error
-}
-
-// NewClientTransport creates a new Transport instance for clients.
-// The type of transport is determined by the address in the configuration:
-// - if the address is a URL with the `ws` or `wss` scheme WebsocketTransport is used
-// - in all other cases a XMPPTransport is used
-// For XMPPTransport it is mandatory for the address to have a port specified.
-func NewClientTransport(config TransportConfiguration) Transport {
-	if strings.HasPrefix(config.Address, "ws:") || strings.HasPrefix(config.Address, "wss:") {
-		return &WebsocketTransport{Config: config}
-	}
-
-	config.Address = ensurePort(config.Address, 5222)
-	return &XMPPTransport{
-		Config:        config,
-		openStatement: clientStreamOpen,
-	}
-}
-
-// NewComponentTransport creates a new Transport instance for components.
-// Only XMPP transports are allowed. If you try to use any other protocol an error
-// will be returned.
-func NewComponentTransport(config TransportConfiguration) (Transport, error) {
-	if strings.HasPrefix(config.Address, "ws:") || strings.HasPrefix(config.Address, "wss:") {
-		return nil, fmt.Errorf("Components only support XMPP transport: %w", ErrTransportProtocolNotSupported)
-	}
-
-	config.Address = ensurePort(config.Address, 5222)
-	return &XMPPTransport{
-		Config:        config,
-		openStatement: componentStreamOpen,
-	}, nil
-}
--- a/websocket_transport.go
+++ b/websocket_transport.go
@@ -1,179 +0,0 @@
-package xmpp
-
-import (
-	"bufio"
-	"context"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"gosrc.io/xmpp/stanza"
-	"nhooyr.io/websocket"
-)
-
-const maxPacketSize = 32768
-
-const pingTimeout = time.Duration(5) * time.Second
-
-var ServerDoesNotSupportXmppOverWebsocket = errors.New("The websocket server does not support the xmpp subprotocol")
-
-// The decoder is expected to be initialized after connecting to a server.
-type WebsocketTransport struct {
-	Config  TransportConfiguration
-	decoder *xml.Decoder
-	wsConn  *websocket.Conn
-	queue   chan []byte
-	logFile io.Writer
-
-	closeCtx  context.Context
-	closeFunc context.CancelFunc
-}
-
-func (t *WebsocketTransport) Connect() (string, error) {
-	t.queue = make(chan []byte, 256)
-	t.closeCtx, t.closeFunc = context.WithCancel(context.Background())
-
-	var ctx context.Context
-	ctx = context.Background()
-	if t.Config.ConnectTimeout > 0 {
-		var cancelConnect context.CancelFunc
-		ctx, cancelConnect = context.WithTimeout(t.closeCtx, time.Duration(t.Config.ConnectTimeout)*time.Second)
-		defer cancelConnect()
-	}
-
-	wsConn, response, err := websocket.Dial(ctx, t.Config.Address, &websocket.DialOptions{
-		Subprotocols: []string{"xmpp"},
-	})
-	if err != nil {
-		return "", NewConnError(err, true)
-	}
-	if response.Header.Get("Sec-WebSocket-Protocol") != "xmpp" {
-		t.cleanup(websocket.StatusBadGateway)
-		return "", NewConnError(ServerDoesNotSupportXmppOverWebsocket, true)
-	}
-
-	wsConn.SetReadLimit(maxPacketSize)
-	t.wsConn = wsConn
-	t.startReader()
-
-	t.decoder = xml.NewDecoder(bufio.NewReaderSize(t, maxPacketSize))
-	t.decoder.CharsetReader = t.Config.CharsetReader
-
-	return t.StartStream()
-}
-
-func (t WebsocketTransport) StartStream() (string, error) {
-	if _, err := fmt.Fprintf(t, `<open xmlns="urn:ietf:params:xml:ns:xmpp-framing" to="%s" version="1.0" />`, t.Config.Domain); err != nil {
-		t.cleanup(websocket.StatusBadGateway)
-		return "", NewConnError(err, true)
-	}
-
-	sessionID, err := stanza.InitStream(t.GetDecoder())
-	if err != nil {
-		t.Close()
-		return "", NewConnError(err, false)
-	}
-	return sessionID, nil
-}
-
-// startReader runs a go function that keeps reading from the websocket. This
-// is required to allow Ping() to work: Ping requires a Reader to be running
-// to process incoming control frames.
-func (t WebsocketTransport) startReader() {
-	go func() {
-		buffer := make([]byte, maxPacketSize)
-		for {
-			_, reader, err := t.wsConn.Reader(t.closeCtx)
-			if err != nil {
-				return
-			}
-			n, err := reader.Read(buffer)
-			if err != nil && err != io.EOF {
-				return
-			}
-			if n > 0 {
-				// We need to make a copy, otherwise we will overwrite the slice content
-				// on the next iteration of the for loop.
-				tmp := make([]byte, n)
-				copy(tmp, buffer)
-				t.queue <- tmp
-			}
-		}
-	}()
-}
-
-func (t WebsocketTransport) StartTLS() error {
-	return ErrTLSNotSupported
-}
-
-func (t WebsocketTransport) DoesStartTLS() bool {
-	return false
-}
-
-func (t WebsocketTransport) GetDomain() string {
-	return t.Config.Domain
-}
-
-func (t WebsocketTransport) GetDecoder() *xml.Decoder {
-	return t.decoder
-}
-
-func (t WebsocketTransport) IsSecure() bool {
-	return strings.HasPrefix(t.Config.Address, "wss:")
-}
-
-func (t WebsocketTransport) Ping() error {
-	ctx, cancel := context.WithTimeout(t.closeCtx, pingTimeout)
-	defer cancel()
-	return t.wsConn.Ping(ctx)
-}
-
-func (t *WebsocketTransport) Read(p []byte) (int, error) {
-	select {
-	case <-t.closeCtx.Done():
-		return 0, t.closeCtx.Err()
-	case data := <-t.queue:
-		if t.logFile != nil && len(data) > 0 {
-			_, _ = fmt.Fprintf(t.logFile, "RECV:\n%s\n\n", data)
-		}
-		copy(p, data)
-		return len(data), nil
-	}
-}
-
-func (t WebsocketTransport) Write(p []byte) (int, error) {
-	if t.logFile != nil {
-		_, _ = fmt.Fprintf(t.logFile, "SEND:\n%s\n\n", p)
-	}
-	return len(p), t.wsConn.Write(t.closeCtx, websocket.MessageText, p)
-}
-
-func (t WebsocketTransport) Close() error {
-	t.Write([]byte("<close xmlns=\"urn:ietf:params:xml:ns:xmpp-framing\" />"))
-	return t.cleanup(websocket.StatusGoingAway)
-}
-
-func (t *WebsocketTransport) LogTraffic(logFile io.Writer) {
-	t.logFile = logFile
-}
-
-func (t *WebsocketTransport) cleanup(code websocket.StatusCode) error {
-	var err error
-	if t.queue != nil {
-		close(t.queue)
-		t.queue = nil
-	}
-	if t.wsConn != nil {
-		err = t.wsConn.Close(websocket.StatusGoingAway, "Done")
-		t.wsConn = nil
-	}
-	if t.closeFunc != nil {
-		t.closeFunc()
-		t.closeFunc = nil
-		t.closeCtx = nil
-	}
-	return err
-}
--- a/xmpp_transport.go
+++ b/xmpp_transport.go
@@ -1,145 +0,0 @@
-package xmpp
-
-import (
-	"bufio"
-	"crypto/tls"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"time"
-
-	"gosrc.io/xmpp/stanza"
-)
-
-// XMPPTransport implements the XMPP native TCP transport
-// The decoder is expected to be initialized after connecting to a server.
-type XMPPTransport struct {
-	openStatement string
-	Config        TransportConfiguration
-	TLSConfig     *tls.Config
-	decoder       *xml.Decoder
-	conn          net.Conn
-	readWriter    io.ReadWriter
-	logFile       io.Writer
-	isSecure      bool
-}
-
-var componentStreamOpen = fmt.Sprintf("<?xml version='1.0'?><stream:stream to='%%s' xmlns='%s' xmlns:stream='%s'>", stanza.NSComponent, stanza.NSStream)
-
-var clientStreamOpen = fmt.Sprintf("<?xml version='1.0'?><stream:stream to='%%s' xmlns='%s' xmlns:stream='%s' version='1.0'>", stanza.NSClient, stanza.NSStream)
-
-func (t *XMPPTransport) Connect() (string, error) {
-	var err error
-
-	t.conn, err = net.DialTimeout("tcp", t.Config.Address, time.Duration(t.Config.ConnectTimeout)*time.Second)
-	if err != nil {
-		return "", NewConnError(err, true)
-	}
-
-	t.readWriter = newStreamLogger(t.conn, t.logFile)
-	t.decoder = xml.NewDecoder(bufio.NewReaderSize(t.readWriter, maxPacketSize))
-	t.decoder.CharsetReader = t.Config.CharsetReader
-	return t.StartStream()
-}
-
-func (t XMPPTransport) StartStream() (string, error) {
-	if _, err := fmt.Fprintf(t, t.openStatement, t.Config.Domain); err != nil {
-		t.Close()
-		return "", NewConnError(err, true)
-	}
-
-	sessionID, err := stanza.InitStream(t.GetDecoder())
-	if err != nil {
-		t.Close()
-		return "", NewConnError(err, false)
-	}
-	return sessionID, nil
-}
-
-func (t XMPPTransport) DoesStartTLS() bool {
-	return true
-}
-
-func (t XMPPTransport) GetDomain() string {
-	return t.Config.Domain
-}
-
-func (t XMPPTransport) GetDecoder() *xml.Decoder {
-	return t.decoder
-}
-
-func (t XMPPTransport) IsSecure() bool {
-	return t.isSecure
-}
-
-func (t *XMPPTransport) StartTLS() error {
-	if t.Config.TLSConfig == nil {
-		t.TLSConfig = &tls.Config{}
-	} else {
-		t.TLSConfig = t.Config.TLSConfig.Clone()
-	}
-
-	if t.TLSConfig.ServerName == "" {
-		t.TLSConfig.ServerName = t.Config.Domain
-	}
-	tlsConn := tls.Client(t.conn, t.TLSConfig)
-	// We convert existing connection to TLS
-	if err := tlsConn.Handshake(); err != nil {
-		return err
-	}
-
-	t.conn = tlsConn
-	t.readWriter = newStreamLogger(tlsConn, t.logFile)
-	t.decoder = xml.NewDecoder(bufio.NewReaderSize(t.readWriter, maxPacketSize))
-	t.decoder.CharsetReader = t.Config.CharsetReader
-
-	if !t.TLSConfig.InsecureSkipVerify {
-		if err := tlsConn.VerifyHostname(t.Config.Domain); err != nil {
-			return err
-		}
-	}
-
-	t.isSecure = true
-	return nil
-}
-
-func (t XMPPTransport) Ping() error {
-	n, err := t.conn.Write([]byte("\n"))
-	if err != nil {
-		return err
-	}
-	if n != 1 {
-		return errors.New("Could not write ping")
-	}
-	return nil
-}
-
-func (t XMPPTransport) Read(p []byte) (n int, err error) {
-	if t.readWriter == nil {
-		return 0, errors.New("cannot read: not connected, no readwriter")
-	}
-	return t.readWriter.Read(p)
-}
-
-func (t XMPPTransport) Write(p []byte) (n int, err error) {
-	if t.readWriter == nil {
-		return 0, errors.New("cannot write: not connected, no readwriter")
-	}
-	return t.readWriter.Write(p)
-}
-
-func (t XMPPTransport) Close() error {
-	if t.readWriter != nil {
-		_, _ = t.readWriter.Write([]byte("</stream:stream>"))
-	}
-	if t.conn != nil {
-		return t.conn.Close()
-	}
-	return nil
-}
-
-func (t *XMPPTransport) LogTraffic(logFile io.Writer) {
-	t.logFile = logFile
-}
Author	SHA1	Message	Date
Mickael Remond	1c4dd6c967	Remove debug print-out	2019-07-31 18:54:49 +02:00
Mickael Remond	1b3dec3902	Clean-up: remove test/debug code	2019-07-31 18:51:16 +02:00
Mickael Remond	3f48672946	Add initial support for stream management For now it support enabling SM, replying to ack requests from server, and trying resuming the session with existing Stream Management state.	2019-07-31 18:47:30 +02:00