debug = false

	TextOut chan<- *string

	var tcp *net.TCPConn

		tcp, err = net.DialTCP("tcp", nil, addr)

	if tcp == nil {

	// Start the transport handler, initially unencrypted.

	tlsr, tlsw := startTransport(tcp)

	// Start the reader and writers that convert to and from XML.

	xmlIn := startXmlReader(tlsr)

	xmlOut := startXmlWriter(tlsw)

	textOut := startTextWriter(tlsw)

	// Start the XMPP stream handler which filters stream-level

	// events and responds to them.

	clIn := startStreamReader(xmlIn)

	clOut := startStreamWriter(xmlOut)

	xmlOut <- hsOut

	// TODO Wait for initialization to finish.

	// Make the Client and init its fields.

	cl := new(Client)

	cl.In = clIn

	cl.Out = clOut

	cl.TextOut = textOut

	tryClose(c.In, c.Out, c.TextOut)

	return nil

}

func startTransport(tcp io.ReadWriter) (io.Reader, io.Writer) {

	f := func(r io.Reader, w io.Writer, dir string) {

		defer tryClose(r, w)

		p := make([]byte, 1024)

		for {

			nr, err := r.Read(p)

			if nr == 0 {

				log.Printf("%s: %s", dir, err.String())

				break

			}

			nw, err := w.Write(p[:nr])

			if nw < nr {

				log.Println("%s: %s", dir, err.String())

				break

			}

		}

	}

	inr, inw := io.Pipe()

	outr, outw := io.Pipe()

	go f(tcp, inw, "read")

	go f(outr, tcp, "write")

	return inr, outw

func startXmlReader(r io.Reader) <-chan interface{} {

	ch := make(chan interface{})

	go readXml(r, ch)

	return ch

}

func startXmlWriter(w io.Writer) chan<- interface{} {

	ch := make(chan interface{})

	go writeXml(w, ch)

	return ch

func startTextWriter(w io.Writer) chan<- *string {

	ch := make(chan *string)

	go writeText(w, ch)

	return ch

}

func startStreamReader(xmlIn <-chan interface{}) <-chan interface{} {

	ch := make(chan interface{})

	go readStream(xmlIn, ch)

	return ch

}

func startStreamWriter(xmlOut chan<- interface{}) chan<- interface{} {

	ch := make(chan interface{})

	go writeStream(xmlOut, ch)

	return ch

}

func readXml(r io.Reader, ch chan<- interface{}) {

	if debug {

	defer tryClose(r, ch)

		case "stream error", nsStream + " error":

func writeXml(w io.Writer, ch <-chan interface{}) {

	if debug {

	defer tryClose(w, ch)

func writeText(w io.Writer, ch <-chan *string) {

	if debug {

		pr, pw := io.Pipe()

		go tee(pr, w, "C: ")

		w = pw

	}

	defer tryClose(w, ch)

	for str := range ch {

		_, err := w.Write([]byte(*str))

		if err != nil {

			log.Printf("writeStr: %v", err)

			break

		}

	}

}

func readStream(srvIn <-chan interface{}, cliOut chan<- interface{}) {

	defer tryClose(srvIn, cliOut)

	for x := range srvIn {

		cliOut <- x

	}

}

func writeStream(srvOut chan<- interface{}, cliIn <-chan interface{}) {

	defer tryClose(srvOut, cliIn)

	for x := range cliIn {

		srvOut <- x

	}

}

	defer tryClose(r, w)

		n, _ = w.Write(c[:n])

		buf.Write(c[:n])

		if c[0] == '\n' || c[0] == '>' {

			fmt.Printf("%s%s\n", prefix, buf.String())

func tryClose(xs ...interface{}) {

	f1 := func(ch chan<- interface{}) {

		defer func() {

			recover()

		}()

		close(ch)

	}

	f2 := func(ch <-chan interface{}) {

		defer func() {

			recover()

		}()

		close(ch)

	}

	for _, x := range xs {

		if c, ok := x.(io.Closer) ; ok {

			c.Close()

		} else if ch, ok := x.(chan<- interface{}) ; ok {

			f1(ch)

		} else if ch, ok := x.(<-chan interface{}) ; ok {

			f2(ch)

		}

	}

}