client.go

@@ -50,7 +50,7 @@ func main() {
 
 	// Get disco#info for home server.
 	info := &DiscoInfo{}
-	iq := xmpp.IQ{ID: xmpp.UUID4(), Type: "get", To: client.JID.Domain}
+	iq := xmpp.Iq{Id: xmpp.UUID4(), Type: "get", To: client.JID.Domain}
 	iq.PayloadEncode(info)
 	reply, _ := client.SendRecv(&iq)
 	reply.PayloadDecode(info)

src/xmpp/client.go

@@ -93,13 +93,14 @@ func startClient(stream *Stream, jid JID) error {
 		},
 	}
 
-	rstart, err := stream.SendStart(&start)
+	if rstart, err := stream.SendStart(&start); err != nil {
-	if err != nil {
 		return err
-	}
+	} else {
 		if rstart.Name != (xml.Name{nsStreams, "stream"}) {
 			return fmt.Errorf("unexpected start element: %s", rstart.Name)
 		}
+	}
+
 	return nil
 }
 
@@ -136,7 +137,7 @@ func authenticate(stream *Stream, mechanisms []string, user, password string) er
 			return nil
 		}
 	}
-	return errors.New("no supported SASL mechanism found")
+	return errors.New("No supported SASL mechanism found.")
 }
 
 type authHandler struct {
@@ -157,11 +158,9 @@ func authenticatePlain(stream *Stream, user, password string) error {
 }
 
 func authenticateResponse(stream *Stream) error {
-	se, err := stream.Next()
+	if se, err := stream.Next(); err != nil {
-	if err != nil {
 		return err
-	}
+	} else {
-
 		switch se.Name.Local {
 		case "success":
 			if err := stream.Skip(); err != nil {
@@ -178,6 +177,8 @@ func authenticateResponse(stream *Stream) error {
 			return fmt.Errorf("Unexpected: %s", se.Name)
 		}
 	}
+	panic("unreachable")
+}
 
 type saslAuth struct {
 	XMLName   xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-sasl auth"`
@@ -187,29 +188,29 @@ type saslAuth struct {
 
 func bindResource(stream *Stream, jid JID) (JID, error) {
 
-	req := IQ{ID: UUID4(), Type: "set"}
+	req := Iq{Id: UUID4(), Type: "set"}
 	if jid.Resource == "" {
-		req.PayloadEncode(bindIQ{})
+		req.PayloadEncode(bindIq{})
 	} else {
-		req.PayloadEncode(bindIQ{Resource: jid.Resource})
+		req.PayloadEncode(bindIq{Resource: jid.Resource})
 	}
 	if err := stream.Send(req); err != nil {
 		return JID{}, err
 	}
 
-	resp := IQ{}
+	resp := Iq{}
 	err := stream.Decode(&resp, nil)
 	if err != nil {
 		return JID{}, err
 	}
-	bindResp := bindIQ{}
+	bindResp := bindIq{}
 	resp.PayloadDecode(&bindResp)
 
 	boundJID, err := ParseJID(bindResp.JID)
 	return boundJID, nil
 }
 
-type bindIQ struct {
+type bindIq struct {
 	XMLName  xml.Name `xml:"urn:ietf:params:xml:ns:xmpp-bind bind"`
 	Resource string   `xml:"resource,omitempty"`
 	JID      string   `xml:"jid,omitempty"`
@@ -217,13 +218,13 @@ type bindIQ struct {
 
 func establishSession(stream *Stream, domain string) error {
 
-	req := IQ{ID: UUID4(), Type: "set", To: domain}
+	req := Iq{Id: UUID4(), Type: "set", To: domain}
 	req.PayloadEncode(&session{})
 	if err := stream.Send(req); err != nil {
 		return err
 	}
 
-	resp := IQ{}
+	resp := Iq{}
 	if err := stream.Decode(&resp, nil); err != nil {
 		return err
 	} else if resp.Error != nil {

src/xmpp/component.go

@@ -10,12 +10,12 @@ import (
 // Create a component XMPP connection over the stream.
 func NewComponentXMPP(stream *Stream, jid JID, secret string) (*XMPP, error) {
 
-	streamID, err := startComponent(stream, jid)
+	streamId, err := startComponent(stream, jid)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := handshake(stream, streamID, secret); err != nil {
+	if err := handshake(stream, streamId, secret); err != nil {
 		return nil, err
 	}
 
@@ -33,33 +33,34 @@ func startComponent(stream *Stream, jid JID) (string, error) {
 		},
 	}
 
-	var streamID string
+	var streamId string
 
-	rstart, err := stream.SendStart(&start)
+	if rstart, err := stream.SendStart(&start); err != nil {
-	if err != nil {
 		return "", err
-	}
+	} else {
 		if rstart.Name != (xml.Name{nsStreams, "stream"}) {
 			return "", fmt.Errorf("unexpected start element: %s", rstart.Name)
 		}
 		// Find the stream id.
 		for _, attr := range rstart.Attr {
 			if attr.Name.Local == "id" {
-			streamID = attr.Value
+				streamId = attr.Value
 				break
 			}
 		}
-	if streamID == "" {
+	}
+
+	if streamId == "" {
 		return "", errors.New("Missing stream id")
 	}
 
-	return streamID, nil
+	return streamId, nil
 }
 
-func handshake(stream *Stream, streamID, secret string) error {
+func handshake(stream *Stream, streamId, secret string) error {
 
 	hash := sha1.New()
-	hash.Write([]byte(streamID))
+	hash.Write([]byte(streamId))
 	hash.Write([]byte(secret))
 
 	// Send handshake.
@@ -69,14 +70,18 @@ func handshake(stream *Stream, streamID, secret string) error {
 	}
 
 	// Get handshake response.
-	start, err := stream.Next()
+	if start, err := stream.Next(); err != nil {
-	if err != nil {
 		return err
-	}
+	} else {
 		if start.Name != (xml.Name{nsComponentAccept, "handshake"}) {
 			return fmt.Errorf("Expected <handshake/>, for %s", start.Name)
 		}
-	return stream.Skip()
+	}
+	if err := stream.Skip(); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 type saslHandshake struct {

src/xmpp/disco.go

@@ -16,7 +16,7 @@ type Disco struct {
 	XMPP *XMPP
 }
 
-// IQ get/result payload for "info" requests.
+// Iq get/result payload for "info" requests.
 type DiscoInfo struct {
 	XMLName  xml.Name        `xml:"http://jabber.org/protocol/disco#info query"`
 	Node     string          `xml:"node,attr"`
@@ -36,7 +36,7 @@ type DiscoFeature struct {
 	Var string `xml:"var,attr"`
 }
 
-// IQ get/result payload for "items" requests.
+// Iq get/result payload for "items" requests.
 type DiscoItems struct {
 	XMLName xml.Name    `xml:"http://jabber.org/protocol/disco#items query"`
 	Node    string      `xml:"node,attr"`
@@ -57,7 +57,7 @@ func (disco *Disco) Info(to, from string) (*DiscoInfo, error) {
 		from = disco.XMPP.JID.Full()
 	}
 
-	req := &IQ{ID: UUID4(), Type: IQTypeGet, To: to, From: from}
+	req := &Iq{Id: UUID4(), Type: IQTypeGet, To: to, From: from}
 	req.PayloadEncode(&DiscoInfo{})
 
 	resp, err := disco.XMPP.SendRecv(req)
@@ -80,7 +80,7 @@ func (disco *Disco) Items(to, from, node string) (*DiscoItems, error) {
 		from = disco.XMPP.JID.Full()
 	}
 
-	req := &IQ{ID: UUID4(), Type: IQTypeGet, To: to, From: from}
+	req := &Iq{Id: UUID4(), Type: IQTypeGet, To: to, From: from}
 	req.PayloadEncode(&DiscoItems{Node: node})
 
 	resp, err := disco.XMPP.SendRecv(req)
@@ -101,7 +101,7 @@ var discoNamespacePrefix = strings.Split(NSDiscoInfo, "#")[0]
 // Matcher instance to match <iq/> stanzas with a disco payload.
 var DiscoPayloadMatcher = MatcherFunc(
 	func(v interface{}) bool {
-		iq, ok := v.(*IQ)
+		iq, ok := v.(*Iq)
 		if !ok {
 			return false
 		}

src/xmpp/dns.go

@@ -8,7 +8,7 @@ import (
 
 const (
 	// Standard port for XMPP clients to connect to.
-	ClientPort = 5222
+	XMPP_CLIENT_PORT = 5222
 )
 
 // Perform a DNS SRV lookup and return an ordered list of "host:port" TCP
@@ -22,7 +22,7 @@ func HomeServerAddrs(jid JID) (addr []string, err error) {
 	// If there's nothing in DNS then assume the JID's domain and the standard
 	// port will work.
 	if len(addrs) == 0 {
-		addr = []string{fmt.Sprintf("%s:%d", jid.Domain, ClientPort)}
+		addr = []string{fmt.Sprintf("%s:%d", jid.Domain, XMPP_CLIENT_PORT)}
 		return
 	}
 

src/xmpp/doc.go

@@ -33,7 +33,7 @@ shutdown or any other error for something unexpected). The channel is also
 closed after an error.
 
 XMPP defines four types of stanza: <error/>, <iq/>, <message/> and <presence/>
-represented by Error, IQ, Message (shown below) and Presence structs
+represented by Error, Iq, Message (shown below) and Presence structs
 respectively.
 
 	for i := range X.In {

src/xmpp/httpAuth.go

@@ -11,7 +11,7 @@ const (
 // XEP-0070: Verifying HTTP Requests via XMPP
 type Confirm struct {
 	XMLName xml.Name `xml:"http://jabber.org/protocol/http-auth confirm"`
-	ID      string   `xml:"id,attr"`
+	Id      string   `xml:"id,attr"`
 	Method  string   `xml:"method,attr"`
 	URL     string   `xml:"url,attr"`
 }

src/xmpp/stanza.go

@@ -18,9 +18,9 @@ const (
 )
 
 // XMPP <iq/> stanza.
-type IQ struct {
+type Iq struct {
 	XMLName xml.Name `xml:"iq"`
-	ID      string   `xml:"id,attr"`
+	Id      string   `xml:"id,attr"`
 	Type    string   `xml:"type,attr"`
 	To      string   `xml:"to,attr,omitempty"`
 	From    string   `xml:"from,attr,omitempty"`
@@ -30,7 +30,7 @@ type IQ struct {
 
 // Encode the value to an XML string and set as the payload. See xml.Marshal
 // for how the value is encoded.
-func (iq *IQ) PayloadEncode(v interface{}) error {
+func (iq *Iq) PayloadEncode(v interface{}) error {
 	bytes, err := xml.Marshal(v)
 	if err != nil {
 		return err
@@ -41,12 +41,12 @@ func (iq *IQ) PayloadEncode(v interface{}) error {
 
 // Decode the payload (an XML string) into the given value. See xml.Unmarshal
 // for how the value is decoded.
-func (iq *IQ) PayloadDecode(v interface{}) error {
+func (iq *Iq) PayloadDecode(v interface{}) error {
 	return xml.Unmarshal([]byte(iq.Payload), v)
 }
 
 // Return the name of the payload element.
-func (iq *IQ) PayloadName() (name xml.Name) {
+func (iq *Iq) PayloadName() (name xml.Name) {
 	dec := xml.NewDecoder(bytes.NewBufferString(iq.Payload))
 	tok, err := dec.Token()
 	if err != nil {
@@ -59,16 +59,16 @@ func (iq *IQ) PayloadName() (name xml.Name) {
 	return start.Name
 }
 
-// Create a response IQ. The ID is kept, To and From are reversed, Type is set
+// Create a response Iq. The Id is kept, To and From are reversed, Type is set
 // to the given value.
-func (iq *IQ) Response(iqType string) *IQ {
+func (iq *Iq) Response(type_ string) *Iq {
-	return &IQ{ID: iq.ID, Type: iqType, From: iq.To, To: iq.From}
+	return &Iq{Id: iq.Id, Type: type_, From: iq.To, To: iq.From}
 }
 
 // XMPP <message/> stanza.
 type Message struct {
 	XMLName xml.Name      `xml:"message"`
-	ID      string        `xml:"id,attr,omitempty"`
+	Id      string        `xml:"id,attr,omitempty"`
 	Type    string        `xml:"type,attr,omitempty"`
 	To      string        `xml:"to,attr,omitempty"`
 	From    string        `xml:"from,attr,omitempty"`
@@ -95,7 +95,7 @@ type MessageBody struct {
 // XMPP <presence/> stanza.
 type Presence struct {
 	XMLName xml.Name `xml:"presence"`
-	ID      string   `xml:"id,attr,omitempty"`
+	Id      string   `xml:"id,attr,omitempty"`
 	Type    string   `xml:"type,attr,omitempty"`
 	To      string   `xml:"to,attr,omitempty"`
 	From    string   `xml:"from,attr,omitempty"`
@@ -115,12 +115,13 @@ type Error struct {
 }
 
 func (e Error) Error() string {
-	text := e.Text()
+	if text := e.Text(); text == "" {
-	if text == "" {
 		return fmt.Sprintf("[%s] %s", e.Type, e.Condition().Local)
-	}
+	} else {
 		return fmt.Sprintf("[%s] %s, %s", e.Type, e.Condition().Local, text)
 	}
+	panic("unreachable")
+}
 
 type errorText struct {
 	XMLName xml.Name

src/xmpp/stream.go

@@ -30,7 +30,7 @@ type Stream struct {
 	incomingNamespace nsMap
 }
 
-// Create a XML stream connection. A Stream is used by an XMPP instance to
+// Create a XML stream connection. A Steam is used by an XMPP instance to
 // handle sending and receiving XML data over the net connection.
 func NewStream(addr string, config *StreamConfig) (*Stream, error) {
 
@@ -148,11 +148,11 @@ func (stream *Stream) Next() (*xml.StartElement, error) {
 	}
 
 	if stream.config.LogStanzas {
-		xml, err := collectElement(stream.dec, start, stream.incomingNamespace)
+		if xml, err := collectElement(stream.dec, start, stream.incomingNamespace); err != nil {
-		if err != nil {
 			return nil, err
-		}
+		} else {
 			stream.stanzaBuf = xml
+		}
 		log.Println("recv:", stream.stanzaBuf)
 	}
 
@@ -170,7 +170,7 @@ func nextStartElement(dec *xml.Decoder) (*xml.StartElement, error) {
 		}
 		switch e := t.(type) {
 		case xml.StartElement:
-			for i := range e.Attr {
+			for i, _ := range e.Attr {
 				// Replace URL namespace to xml in order to avoid error on Unmarshal
 				// It's quite ugly, but working for now
 				if e.Attr[i].Name.Space == "http://www.w3.org/XML/1998/namespace" {
@@ -183,6 +183,7 @@ func nextStartElement(dec *xml.Decoder) (*xml.StartElement, error) {
 			return nil, io.EOF
 		}
 	}
+	panic("Unreachable")
 }
 
 // Skip reads tokens until it reaches the end element of the most recent start
@@ -204,12 +205,12 @@ func (stream *Stream) Decode(v interface{}, start *xml.StartElement) error {
 	// Explicity lookup next start element to ensure stream is validated,
 	// stanza is logged, etc.
 	if start == nil {
-		se, err := stream.Next()
+		if se, err := stream.Next(); err != nil {
-		if err != nil {
 			return err
-		}
+		} else {
 			start = se
 		}
+	}
 
 	if stream.config.LogStanzas {
 		return xml.Unmarshal([]byte(stream.stanzaBuf), v)

src/xmpp/xml.go

@@ -76,13 +76,14 @@ func writeXMLAttr(w io.Writer, attr xml.Attr) error {
 func startElementIter(dec *xml.Decoder) func() *xml.StartElement {
 	return func() *xml.StartElement {
 		for {
-			tok, err := dec.Token()
+			if tok, err := dec.Token(); err != nil {
-			if err != nil {
 				return nil
-			}
+			} else {
 				if start, ok := tok.(xml.StartElement); ok {
 					return &start
 				}
 			}
 		}
+		return nil
+	}
 }

src/xmpp/xmpp.go

@@ -18,19 +18,19 @@ type XMPP struct {
 	JID    JID
 	stream *Stream
 
-	// Channel of incoming messages. Values will be one of IQ, Message,
+	// Channel of incoming messages. Values will be one of Iq, Message,
 	// Presence, Error or error. Will be closed at the end when the stream is
 	// closed or the stream's net connection dies.
 	In chan interface{}
 
 	// Channel of outgoing messages. Messages must be able to be marshaled by
-	// the standard xml package, however you should try to send one of IQ,
+	// the standard xml package, however you should try to send one of Iq,
 	// Message or Presence.
 	Out chan interface{}
 
 	// Incoming stanza filters.
 	filterLock   sync.Mutex
-	nextFilterID FilterID
+	nextFilterId FilterId
 	filters      []filter
 }
 
@@ -46,17 +46,17 @@ func newXMPP(jid JID, stream *Stream) *XMPP {
 	return x
 }
 
-func (x *XMPP) SendRecv(iq *IQ) (*IQ, error) {
+func (x *XMPP) SendRecv(iq *Iq) (*Iq, error) {
 
-	fid, ch := x.AddFilter(IQResult(iq.ID))
+	fid, ch := x.AddFilter(IqResult(iq.Id))
 	defer x.RemoveFilter(fid)
 
 	x.Out <- iq
 
 	stanza := <-ch
-	reply, ok := stanza.(*IQ)
+	reply, ok := stanza.(*Iq)
 	if !ok {
-		return nil, fmt.Errorf("Expected IQ, for %T", stanza)
+		return nil, fmt.Errorf("Expected Iq, for %T", stanza)
 	}
 	return reply, nil
 }
@@ -76,25 +76,25 @@ func (fn MatcherFunc) Match(v interface{}) bool {
 	return fn(v)
 }
 
-// Uniquely identifies a stream filter. Used to remove a filter that's no
+// Uniquly identifies a stream fiter. Used to remove a filter that's no longer
-// longer needed.
+// needed.
-type FilterID int64
+type FilterId int64
 
-// Implements the error interface for a FilterID.
+// Implements the error interface for a FilterId.
-func (fid FilterID) Error() string {
+func (fid FilterId) Error() string {
 	return fmt.Sprintf("Invalid filter id: %d", fid)
 }
 
 type filter struct {
-	id FilterID
+	id FilterId
 	m  Matcher
 	ch chan interface{}
 }
 
 // Add a filter that routes matching stanzas to the returned channel. A
-// FilterID is also returned and can be pased to RemoveFilter to remove the
+// FilterId is also returned and can be pased to RemoveFilter to remove the
 // filter again.
-func (x *XMPP) AddFilter(m Matcher) (FilterID, chan interface{}) {
+func (x *XMPP) AddFilter(m Matcher) (FilterId, chan interface{}) {
 
 	// Protect against concurrent access.
 	x.filterLock.Lock()
@@ -102,8 +102,8 @@ func (x *XMPP) AddFilter(m Matcher) (FilterID, chan interface{}) {
 
 	// Allocate chan and id.
 	ch := make(chan interface{})
-	id := x.nextFilterID
+	id := x.nextFilterId
-	x.nextFilterID++
+	x.nextFilterId++
 
 	// Insert at head of filters list.
 	filters := make([]filter, len(x.filters)+1)
@@ -115,7 +115,7 @@ func (x *XMPP) AddFilter(m Matcher) (FilterID, chan interface{}) {
 }
 
 // Remove a filter previously added with AddFilter.
-func (x *XMPP) RemoveFilter(id FilterID) error {
+func (x *XMPP) RemoveFilter(id FilterId) error {
 
 	// Protect against concurrent access.
 	x.filterLock.Lock()
@@ -145,14 +145,14 @@ func (x *XMPP) RemoveFilter(id FilterID) error {
 
 // Matcher to identify a <iq id="..." type="result" /> stanza with the given
 // id.
-func IQResult(id string) Matcher {
+func IqResult(id string) Matcher {
 	return MatcherFunc(
 		func(v interface{}) bool {
-			iq, ok := v.(*IQ)
+			iq, ok := v.(*Iq)
 			if !ok {
 				return false
 			}
-			if iq.ID != id {
+			if iq.Id != id {
 				return false
 			}
 			return true
@@ -193,13 +193,13 @@ func (x *XMPP) receiver() {
 		case "error":
 			v = &Error{}
 		case "iq":
-			v = &IQ{}
+			v = &Iq{}
 		case "message":
 			v = &Message{}
 		case "presence":
 			v = &Presence{}
 		default:
-			log.Printf("Error. Unexected element: %T %v", start, start)
+			log.Println("Error. Unexected element: %T %v", start, start)
 		}
 
 		err = x.stream.Decode(v, start)