// Copyright 2011 The Go Authors.  All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// This file contains the three layers of processing for the

// communication with the server: transport (where TLS happens), XML

// (where strings are converted to go structures), and Stream (where

// we respond to XMPP events on behalf of the library client), or send

// those events to the client.

package xmpp

import (

	"bytes"

	"crypto/md5"

	"crypto/rand"

	"crypto/tls"

	"encoding/base64"

	"encoding/xml"

	"fmt"

	"io"

	"log/syslog"

	"math/big"

	"net"

	"regexp"

	"strings"

	"time"

)

// Callback to handle a stanza with a particular id.

type stanzaHandler struct {

	id string

	// Return true means pass this to the application

	f func(Stanza) bool

}

// BUG(cjyar): There's no way to specify xml:lang for the top-level

// <stream:stream> element as the default language for this client.

// BUG(cjyar): We SHOULD send a text declaration before the "open

// stream" element.

// Generate the "open stream" element which tells the remote we want

// to speak XMPP. This is actually done 3 times, since we renegotiate

// our transport layer with TLS and then with SASL.

func openStream(jid *JID) *stream {

	return &stream{To: jid.Domain, Version: Version}

}

// BUG(cjyar) Review all these *Client receiver methods. They should

// probably either all be receivers, or none.

func (cl *Client) readTransport(w io.WriteCloser) {

	defer w.Close()

	cl.socket.SetReadTimeout(1e8)

	p := make([]byte, 1024)

	for {

		if cl.socket == nil {

			cl.waitForSocket()

		}

		nr, err := cl.socket.Read(p)

		if nr == 0 {

			if errno, ok := err.(*net.OpError); ok {

				if errno.Timeout() {

					continue

				}

			}

			if Log != nil {

				Log.Println("read: " + err.Error())

			}

			break

		}

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

		if nw < nr {

			if Log != nil {

				Log.Println("read: " + err.Error())

			}

			break

		}

	}

}

func (cl *Client) writeTransport(r io.Reader) {

	defer cl.socket.Close()

	p := make([]byte, 1024)

	for {

		nr, err := r.Read(p)

		if nr == 0 {

			if Log != nil {

				Log.Println("write: " + err.Error())

			}

			break

		}

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

		if nw < nr {

			if Log != nil {

				Log.Println("write: " + err.Error())

			}

			break

		}

	}

}

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

	extStanza map[string]func(*xml.Name) interface{}) {

	if Loglevel >= syslog.LOG_DEBUG {

		pr, pw := io.Pipe()

		go tee(r, pw, "S: ")

		r = pr

	}

	defer close(ch)

	p := xml.NewParser(r)

Loop:

	for {

		// Sniff the next token on the stream.

		t, err := p.Token()

		if t == nil {

			if err != io.EOF {

				if Log != nil {

					Log.Println("read: " + err.Error())

				}

			}

			break

		}

		var se xml.StartElement

		var ok bool

		if se, ok = t.(xml.StartElement); !ok {

			continue

		}

		// Allocate the appropriate structure for this token.

		var obj interface{}

		switch se.Name.Space + " " + se.Name.Local {

		case NsStream + " stream":

			st, err := parseStream(se)

			if err != nil {

				if Log != nil {

					Log.Println("unmarshal stream: " +

						err.Error())

				}

				break Loop

			}

			ch <- st

			continue

		case "stream error", NsStream + " error":

			obj = &streamError{}

		case NsStream + " features":

			obj = &Features{}

		case NsTLS + " proceed", NsTLS + " failure":

			obj = &starttls{}

		case NsSASL + " challenge", NsSASL + " failure",

			NsSASL + " success":

			obj = &auth{}

		case "jabber:client iq":

			obj = &Iq{}

		case "jabber:client message":

			obj = &Message{}

		case "jabber:client presence":

			obj = &Presence{}

		default:

			obj = &Generic{}

			if Log != nil && Loglevel >= syslog.LOG_NOTICE {

				Log.Printf("Ignoring unrecognized: %s %s",

					se.Name.Space, se.Name.Local)

			}

		}

		// Read the complete XML stanza.

		err = p.Unmarshal(obj, &se)

		if err != nil {

			if Log != nil {

				Log.Println("unmarshal: " + err.Error())

			}

			break Loop

		}

		// If it's a Stanza, we try to unmarshal its innerxml

		// into objects of the appropriate respective

		// types. This is specified by our extensions.

		if st, ok := obj.(Stanza); ok {

			err = parseExtended(st, extStanza)

			if err != nil {

				if Log != nil {

					Log.Println("ext unmarshal: " +

						err.Error())

				}

				break Loop

			}

		}

		// Put it on the channel.

		ch <- obj

	}

}

func parseExtended(st Stanza, extStanza map[string]func(*xml.Name) interface{}) error {

	// Now parse the stanza's innerxml to find the string that we

	// can unmarshal this nested element from.

	reader := strings.NewReader(st.innerxml())

	p := xml.NewParser(reader)

	for {

		t, err := p.Token()

		if err == io.EOF {

			break

		}

		if err != nil {

			return err

		}

		if se, ok := t.(xml.StartElement); ok {

			if con, ok := extStanza[se.Name.Space]; ok {

				// Call the indicated constructor.

				nested := con(&se.Name)

				// Unmarshal the nested element and

				// stuff it back into the stanza.

				err := p.Unmarshal(nested, &se)

				if err != nil {

					return err

				}

				st.addNested(nested)

			}

		}

	}

	return nil

}

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

	if Loglevel >= syslog.LOG_DEBUG {

		pr, pw := io.Pipe()

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

		w = pw

	}

	defer func(w io.Writer) {

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

			c.Close()

		}

	}(w)

	for obj := range ch {

		err := xml.Marshal(w, obj)

		if err != nil {

			if Log != nil {

				Log.Println("write: " + err.Error())

			}

			break

		}

	}

}

func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- Stanza) {

	defer close(cliOut)

	handlers := make(map[string]func(Stanza) bool)

Loop:

	for {

		select {

		case h := <-cl.handlers:

			handlers[h.id] = h.f

		case x, ok := <-srvIn:

			if !ok {

				break Loop

			}

			send := false

			switch obj := x.(type) {

			case *stream:

				handleStream(obj)

			case *streamError:

				cl.handleStreamError(obj)

			case *Features:

				cl.handleFeatures(obj)

			case *starttls:

				cl.handleTls(obj)

			case *auth:

				cl.handleSasl(obj)

			default:

				send = true

			}

			if !send {

				continue

			}

			st, ok := x.(Stanza)

			if !ok {

				if Log != nil && Loglevel >= syslog.LOG_WARNING {

					Log.Printf(

						"Unhandled non-stanza: %v", x)

				}

				continue

			}

			if handlers[st.GetId()] != nil {

				f := handlers[st.GetId()]

				handlers[st.GetId()] = nil

				send = f(st)

			}

			if send {

				cliOut <- st

			}

		}

	}

}

// This loop is paused until resource binding is complete. Otherwise

// the app might inject something inappropriate into our negotiations

// with the server. The control channel controls this loop's

// activity.

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

	control <-chan int) {

	defer close(srvOut)

	var input <-chan Stanza

Loop:

	for {

		select {

		case status := <-control:

			switch status {

			case 0:

				input = nil

			case 1:

				input = cliIn

			case -1:

				break Loop

			}

		case x, ok := <-input:

			if !ok {

				break Loop

			}

			if x == nil {

				if Log != nil && Loglevel >= syslog.LOG_NOTICE {

					Log.Println("Refusing to send" +

						" nil stanza")

				}

				continue

			}

			srvOut <- x

		}

	}

}

// Stanzas from the remote go up through a stack of filters to the

// app. This function manages the filters.

func filterTop(filterOut <-chan <-chan Stanza, filterIn chan<- <-chan Stanza,

	topFilter <-chan Stanza, app chan<- Stanza) {

	defer close(app)

Loop:

	for {

		select {

		case newFilterOut := <-filterOut:

			if newFilterOut == nil {

				if Log != nil && Loglevel >= syslog.LOG_WARNING {

					Log.Println("Received nil filter")

				}

				filterIn <- nil