go-xmpp2: comparison xmpp.go

equal deleted inserted replaced

-:578c2a83dc18
+:53f15893a1a7
 	// Version of RFC 3920 that we implement.
 	Version = "1.0"
 	// Various XML namespaces.
 	NsStreams = "urn:ietf:params:xml:ns:xmpp-streams"
-	NsStream = "http://etherx.jabber.org/streams"
+	NsStream  = "http://etherx.jabber.org/streams"
-	NsTLS = "urn:ietf:params:xml:ns:xmpp-tls"
+	NsTLS     = "urn:ietf:params:xml:ns:xmpp-tls"
-	NsSASL = "urn:ietf:params:xml:ns:xmpp-sasl"
+	NsSASL    = "urn:ietf:params:xml:ns:xmpp-sasl"
-	NsBind = "urn:ietf:params:xml:ns:xmpp-bind"
+	NsBind    = "urn:ietf:params:xml:ns:xmpp-bind"
 	NsSession = "urn:ietf:params:xml:ns:xmpp-session"
-	NsRoster = "jabber:iq:roster"
+	NsRoster  = "jabber:iq:roster"
 	// DNS SRV names
 	serverSrv = "xmpp-server"
 	clientSrv = "xmpp-client"
 )
 	}(idCh)
 }
 // Extensions can add stanza filters and/or new XML element types.
 type Extension struct {
-	StanzaHandlers map[string] func(*xml.Name) interface{}
+	StanzaHandlers map[string]func(*xml.Name) interface{}
-	Start func(*Client)
+	Start          func(*Client)
 }
 // The client in a client-server XMPP connection.
 type Client struct {
 	// This client's unique ID. It's unique within the context of
 	// this process, so if multiple Client objects exist, each
 	// will be distinguishable by its Uid.
 	Uid string
 	// This client's JID. This will be updated asynchronously by
 	// the time StartSession() returns.
-	Jid JID
+	Jid          JID
-	password string
+	password     string
-	socket net.Conn
+	socket       net.Conn
-	socketSync sync.WaitGroup
+	socketSync   sync.WaitGroup
 	saslExpected string
-	authDone bool
+	authDone     bool
-	handlers chan *stanzaHandler
+	handlers     chan *stanzaHandler
 	inputControl chan int
 	// Incoming XMPP stanzas from the server will be published on
 	// this channel. Information which is only used by this
 	// library to set up the XMPP stream will not appear here.
 	In <-chan Stanza
 	// Outgoing XMPP stanzas to the server should be sent to this
 	// channel.
-	Out chan<- Stanza
+	Out    chan<- Stanza
 	xmlOut chan<- interface{}
 	// Features advertised by the remote. This will be updated
 	// asynchronously as new features are received throughout the
 	// connection process. It should not be updated once
 	// StartSession() returns.
-	Features *Features
+	Features  *Features
 	filterOut chan<- <-chan Stanza
-	filterIn <-chan <-chan Stanza
+	filterIn  <-chan <-chan Stanza
 }
 // Connect to the appropriate server and authenticate as the given JID
 // with the given password. This function will return as soon as a TCP
 // connection has been established, but before XMPP stream negotiation
 // has completed. The negotiation will occur asynchronously, and any
 // send operation to Client.Out will block until negotiation (resource
 // binding) is complete.
 func NewClient(jid *JID, password string, exts []Extension) (*Client,
-	os.Error) {
+os.Error) {
 	// Include the mandatory extensions.
 	exts = append(exts, rosterExt)
 	exts = append(exts, bindExt)
 	// Resolve the domain in the JID.
 	if tcp == nil {
 		return nil, err
 	}
 	cl := new(Client)
-	cl.Uid = <- Id
+	cl.Uid = <-Id
 	cl.password = password
 	cl.Jid = *jid
 	cl.socket = tcp
 	cl.handlers = make(chan *stanzaHandler, 100)
 	cl.inputControl = make(chan int)
-	extStanza := make(map[string] func(*xml.Name) interface{})
+	extStanza := make(map[string]func(*xml.Name) interface{})
-	for _, ext := range(exts) {
+	for _, ext := range exts {
-		for k, v := range(ext.StanzaHandlers) {
+		for k, v := range ext.StanzaHandlers {
 			extStanza[k] = v
 		}
 	}
 	// Start the transport handler, initially unencrypted.
 	// app sees.
 	clIn := cl.startFilter(stIn)
 	cl.In = clIn
 	// Add filters for our extensions.
-	for _, ext := range(exts) {
+	for _, ext := range exts {
 		ext.Start(cl)
 	}
 	// Initial handshake.
 	hsOut := &stream{To: jid.Domain, Version: Version}
 	go cl.writeTransport(outr)
 	return inr, outw
 }
 func startXmlReader(r io.Reader,
-	extStanza map[string] func(*xml.Name) interface{}) <-chan interface{} {
+extStanza map[string]func(*xml.Name) interface{}) <-chan interface{} {
 	ch := make(chan interface{})
 	go readXml(r, ch, extStanza)
 	return ch
 }
 	return cliIn
 }
 func tee(r io.Reader, w io.Writer, prefix string) {
 	defer func(w io.Writer) {
-		if c, ok := w.(io.Closer) ; ok {
+		if c, ok := w.(io.Closer); ok {
 			c.Close()
 		}
 	}(w)
 	buf := bytes.NewBuffer([]uint8(prefix))
 // immediately after creating the Client in order to start the
 // session, retrieve the roster, and broadcast an initial
 // presence. The presence can be as simple as a newly-initialized
 // Presence struct.  See RFC 3921, Section 3.
 func (cl *Client) StartSession(getRoster bool, pr *Presence) os.Error {
-	id := <- Id
+	id := <-Id
-	iq := &Iq{To: cl.Jid.Domain, Id: id, Type: "set", Nested:
+	iq := &Iq{To: cl.Jid.Domain, Id: id, Type: "set", Nested: []interface{}{Generic{XMLName: xml.Name{Space: NsSession, Local: "session"}}}}
-		[]interface{}{ Generic{XMLName: xml.Name{Space:
-					NsSession, Local: "session"}}}}
 	ch := make(chan os.Error)
 	f := func(st Stanza) bool {
 		if st.GetType() == "error" {
 			if Log != nil {
 				Log.Err(fmt.Sprintf("Can't start session: %v",
 	}
 	cl.HandleStanza(id, f)
 	cl.Out <- iq
 	// Now wait until the callback is called.
-	if err := <- ch ; err != nil {
+	if err := <-ch; err != nil {
 		return err
 	}
 	if getRoster {
 		err := fetchRoster(cl)
 		if err != nil {
 // filter's output channel is given to this function, and it returns a
 // new input channel which the filter should read from. When its input
 // channel closes, the filter should close its output channel.
 func (cl *Client) AddFilter(out <-chan Stanza) <-chan Stanza {
 	cl.filterOut <- out
-	return <- cl.filterIn
+	return <-cl.filterIn
 }

changeset 72	53f15893a1a7
parent 67	e8ad85bb6608
child 74	e619e18dcec3
child 98	c9cc4eda6dce