Unverified Commit 2b3f8ad4 authored by Ola Bini's avatar Ola Bini

Add initial sketch of a working XMPP prekey server spec implementation

parent 30640228
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
[[projects]]
name = "github.com/pkg/errors"
packages = ["."]
revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
version = "v0.8.0"
[[projects]]
name = "github.com/sheenobu/go-xco"
packages = ["."]
revision = "20e894c4a59fe4190ed402bf6d65f5995f7cb8ce"
version = "0.2.3"
[[projects]]
branch = "master"
name = "golang.org/x/net"
packages = ["context"]
revision = "d0887baf81f4598189d4e12a37c6da86f0bba4d0"
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "ab4fef131ee828e96ba67d31a7d690bd5f2f42040c6766b1b12fe856f87e0ff7"
inputs-digest = "d87305bfb9e7c75b7a655333ec2ff27023abd3b14fd900e5495ae7beb27a9ce0"
solver-name = "gps-cdcl"
solver-version = 1
package main
import "flag"
// Here we can have command line options later
var (
rawPort = flag.Uint("raw-port", 3242, "Port to connect to the raw server on")
rawIP = flag.String("raw-address", "localhost", "Address to connect to the raw server on")
xmppPort = flag.Uint("xmpp-port", 53200, "Port to connect to the XMPP server on")
xmppIP = flag.String("xmpp-address", "localhost", "Address to connect to the XMPP server on")
xmppSharedSecret = flag.String("shared-secret", "changeme", "Shared secret for authenticating to the XMPP server")
xmppName = flag.String("name", "changeme", "Name for the XMPP component. Usually something like prekeys.example.org")
prekeyServerFingerprint = flag.String("fingerprint", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "Fingerprint for the prekey server. This is expected to be 56 bytes expressed in hexadecimal - thus 112 digits")
)
package main
import (
"bytes"
"encoding/xml"
"flag"
"fmt"
"io/ioutil"
"net"
xco "github.com/sheenobu/go-xco"
)
func main() {
flag.Parse()
opts := xco.Options{
Name: *xmppName,
SharedSecret: *xmppSharedSecret,
Address: net.JoinHostPort(*xmppIP, fmt.Sprintf("%d", *xmppPort)),
}
c, err := xco.NewComponent(opts)
if err != nil {
panic(err)
}
c.MessageHandler = func(_ *xco.Component, m *xco.Message) error {
res := getPrekeyResponseFromRealServer(fmt.Sprintf("%s@%s", m.Header.From.LocalPart, m.Header.From.DomainPart), []byte(m.Body))
resp := xco.Message{
Header: xco.Header{
From: m.To,
To: m.From,
ID: m.ID,
},
Type: m.Type,
Body: string(res),
XMLName: m.XMLName,
}
c.Send(&resp)
return nil
}
c.IqHandler = func(_ *xco.Component, m *xco.Iq) error {
ret, _, _ := processIQ(m)
resp := xco.Iq{
Header: xco.Header{
From: m.To,
To: m.From,
ID: m.ID,
},
Type: "result",
Content: xmlToString(ret),
XMLName: m.XMLName,
}
c.Send(&resp)
return nil
}
e := c.Run()
if e != nil {
panic(e)
}
}
func xmlToString(x interface{}) string {
enc, _ := xml.Marshal(x)
return string(enc)
}
func unknownIQ(stanza *xco.Iq) (ret interface{}, iqtype string, ignore bool) {
fmt.Printf("Unknown IQ: %s\n", stanza.Content)
return nil, "", false
}
type iqFunction func(*xco.Iq) (interface{}, string, bool)
var knownIQs = map[string]iqFunction{}
func registerKnownIQ(stanzaType, fullName string, f iqFunction) {
knownIQs[stanzaType+" "+fullName] = f
}
func getIQHandler(stanzaType, namespace, local string) iqFunction {
f, ok := knownIQs[fmt.Sprintf("%s %s %s", stanzaType, namespace, local)]
if ok {
return f
}
return unknownIQ
}
func processIQ(stanza *xco.Iq) (ret interface{}, iqtype string, ignore bool) {
if nspace, local, ok := tryDecodeXML([]byte(stanza.Content)); ok {
return getIQHandler(stanza.Type, nspace, local)(stanza)
}
return nil, "", false
}
func tryDecodeXML(data []byte) (nspace, local string, ok bool) {
token, _ := xml.NewDecoder(bytes.NewBuffer(data)).Token()
if token == nil {
return "", "", false
}
startElem, ok := token.(xml.StartElement)
if !ok {
return "", "", false
}
return startElem.Name.Space, startElem.Name.Local, true
}
func discoInfoIQ(_ *xco.Iq) (interface{}, string, bool) {
return DiscoveryInfoQuery{
Identities: []DiscoveryIdentity{
{
Category: "auth",
Type: "otr-prekey",
Name: "OTR Prekey Server",
},
},
Features: []DiscoveryFeature{
{Var: "http://jabber.org/protocol/disco#info"},
{Var: "http://jabber.org/protocol/disco#items"},
{Var: "http://jabber.org/protocol/otrv4-prekey-server"},
},
}, "", false
}
func discoItemsIQ(_ *xco.Iq) (interface{}, string, bool) {
return DiscoveryItemsQuery{
DiscoveryItems: []DiscoveryItem{
{
Jid: *xmppName,
Node: "fingerprint",
Name: *prekeyServerFingerprint,
},
},
}, "", false
}
func init() {
registerKnownIQ("get", "http://jabber.org/protocol/disco#info query", discoInfoIQ)
registerKnownIQ("get", "http://jabber.org/protocol/disco#items query", discoItemsIQ)
}
// DiscoveryInfoQuery contains the deserialized information about a service discovery info query
// See: XEP-0030, Section 3
type DiscoveryInfoQuery struct {
XMLName xml.Name `xml:"http://jabber.org/protocol/disco#info query"`
Node string `xml:"node,omitempty"`
Identities []DiscoveryIdentity `xml:"identity,omitempty"`
Features []DiscoveryFeature `xml:"feature,omitempty"`
}
// DiscoveryIdentity contains identity information for a specific discovery
type DiscoveryIdentity struct {
XMLName xml.Name `xml:"http://jabber.org/protocol/disco#info identity"`
Lang string `xml:"lang,attr,omitempty"`
Category string `xml:"category,attr"`
Type string `xml:"type,attr"`
Name string `xml:"name,attr"`
}
// DiscoveryFeature contains information about a specific discovery feature
type DiscoveryFeature struct {
XMLName xml.Name `xml:"http://jabber.org/protocol/disco#info feature"`
Var string `xml:"var,attr"`
}
// DiscoveryItemsQuery contains a query for discovery items
type DiscoveryItemsQuery struct {
XMLName xml.Name `xml:"http://jabber.org/protocol/disco#items query"`
DiscoveryItems []DiscoveryItem `xml:"item,omitempty"`
}
// DiscoveryItem contains one discovery item
type DiscoveryItem struct {
XMLName xml.Name `xml:"http://jabber.org/protocol/disco#items item"`
Jid string `xml:"jid,attr"`
Name string `xml:"name,attr"`
Node string `xml:"node, attr"`
}
func appendShort(l []byte, r uint16) []byte {
return append(l, byte(r>>8), byte(r))
}
func extractShort(d []byte) ([]byte, uint16, bool) {
if len(d) < 2 {
return nil, 0, false
}
return d[2:], uint16(d[0])<<8 |
uint16(d[1]), true
}
func getPrekeyResponseFromRealServer(u string, data []byte) []byte {
addr, _ := net.ResolveTCPAddr("tcp", net.JoinHostPort(*rawIP, fmt.Sprintf("%d", *rawPort)))
con, _ := net.DialTCP(addr.Network(), nil, addr)
defer con.Close()
toSend := []byte{}
toSend = appendShort(toSend, uint16(len(u)))
toSend = append(toSend, []byte(u)...)
toSend = appendShort(toSend, uint16(len(data)))
toSend = append(toSend, data...)
con.Write(toSend)
con.CloseWrite()
res, _ := ioutil.ReadAll(con)
res2, ss, _ := extractShort(res)
if uint16(len(res2)) != ss {
fmt.Printf("Unexpected length of data received\n")
return nil
}
return res2
}
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof
language: go
go_import_path: github.com/pkg/errors
go:
- 1.4.3
- 1.5.4
- 1.6.2
- 1.7.1
- tip
script:
- go test -v ./...
Copyright (c) 2015, Dave Cheney <dave@cheney.net>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# errors [![Travis-CI](https://travis-ci.org/pkg/errors.svg)](https://travis-ci.org/pkg/errors) [![AppVeyor](https://ci.appveyor.com/api/projects/status/b98mptawhudj53ep/branch/master?svg=true)](https://ci.appveyor.com/project/davecheney/errors/branch/master) [![GoDoc](https://godoc.org/github.com/pkg/errors?status.svg)](http://godoc.org/github.com/pkg/errors) [![Report card](https://goreportcard.com/badge/github.com/pkg/errors)](https://goreportcard.com/report/github.com/pkg/errors)
Package errors provides simple error handling primitives.
`go get github.com/pkg/errors`
The traditional error handling idiom in Go is roughly akin to
```go
if err != nil {
return err
}
```
which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
## Adding context to an error
The errors.Wrap function returns a new error that adds context to the original error. For example
```go
_, err := ioutil.ReadAll(r)
if err != nil {
return errors.Wrap(err, "read failed")
}
```
## Retrieving the cause of an error
Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
```go
type causer interface {
Cause() error
}
```
`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
```go
switch err := errors.Cause(err).(type) {
case *MyError:
// handle specifically
default:
// unknown error
}
```
[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
## Contributing
We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
Before proposing a change, please discuss your change by raising an issue.
## Licence
BSD-2-Clause
version: build-{build}.{branch}
clone_folder: C:\gopath\src\github.com\pkg\errors
shallow_clone: true # for startup speed
environment:
GOPATH: C:\gopath
platform:
- x64
# http://www.appveyor.com/docs/installed-software
install:
# some helpful output for debugging builds
- go version
- go env
# pre-installed MinGW at C:\MinGW is 32bit only
# but MSYS2 at C:\msys64 has mingw64
- set PATH=C:\msys64\mingw64\bin;%PATH%
- gcc --version
- g++ --version
build_script:
- go install -v ./...
test_script:
- set PATH=C:\gopath\bin;%PATH%
- go test -v ./...
#artifacts:
# - path: '%GOPATH%\bin\*.exe'
deploy: off
// Package errors provides simple error handling primitives.
//
// The traditional error handling idiom in Go is roughly akin to
//
// if err != nil {
// return err
// }
//
// which applied recursively up the call stack results in error reports
// without context or debugging information. The errors package allows
// programmers to add context to the failure path in their code in a way
// that does not destroy the original value of the error.
//
// Adding context to an error
//
// The errors.Wrap function returns a new error that adds context to the
// original error by recording a stack trace at the point Wrap is called,
// and the supplied message. For example
//
// _, err := ioutil.ReadAll(r)
// if err != nil {
// return errors.Wrap(err, "read failed")
// }
//
// If additional control is required the errors.WithStack and errors.WithMessage
// functions destructure errors.Wrap into its component operations of annotating
// an error with a stack trace and an a message, respectively.
//
// Retrieving the cause of an error
//
// Using errors.Wrap constructs a stack of errors, adding context to the
// preceding error. Depending on the nature of the error it may be necessary
// to reverse the operation of errors.Wrap to retrieve the original error
// for inspection. Any error value which implements this interface
//
// type causer interface {
// Cause() error
// }
//
// can be inspected by errors.Cause. errors.Cause will recursively retrieve
// the topmost error which does not implement causer, which is assumed to be
// the original cause. For example:
//
// switch err := errors.Cause(err).(type) {
// case *MyError:
// // handle specifically
// default:
// // unknown error
// }
//
// causer interface is not exported by this package, but is considered a part
// of stable public API.
//
// Formatted printing of errors
//
// All error values returned from this package implement fmt.Formatter and can
// be formatted by the fmt package. The following verbs are supported
//
// %s print the error. If the error has a Cause it will be
// printed recursively
// %v see %s
// %+v extended format. Each Frame of the error's StackTrace will
// be printed in detail.
//
// Retrieving the stack trace of an error or wrapper
//
// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
// invoked. This information can be retrieved with the following interface.
//
// type stackTracer interface {
// StackTrace() errors.StackTrace
// }
//
// Where errors.StackTrace is defined as
//
// type StackTrace []Frame
//
// The Frame type represents a call site in the stack trace. Frame supports
// the fmt.Formatter interface that can be used for printing information about
// the stack trace of this error. For example:
//
// if err, ok := err.(stackTracer); ok {
// for _, f := range err.StackTrace() {
// fmt.Printf("%+s:%d", f)
// }
// }
//
// stackTracer interface is not exported by this package, but is considered a part
// of stable public API.
//
// See the documentation for Frame.Format for more details.
package errors
import (
"fmt"
"io"
)
// New returns an error with the supplied message.
// New also records the stack trace at the point it was called.
func New(message string) error {
return &fundamental{
msg: message,
stack: callers(),
}
}
// Errorf formats according to a format specifier and returns the string
// as a value that satisfies error.
// Errorf also records the stack trace at the point it was called.
func Errorf(format string, args ...interface{}) error {
return &fundamental{
msg: fmt.Sprintf(format, args...),
stack: callers(),
}
}
// fundamental is an error that has a message and a stack, but no caller.
type fundamental struct {
msg string
*stack
}
func (f *fundamental) Error() string { return f.msg }
func (f *fundamental) Format(s fmt.State, verb rune) {
switch verb {
case 'v':
if s.Flag('+') {
io.WriteString(s, f.msg)
f.stack.Format(s, verb)
return
}
fallthrough
case 's':
io.WriteString(s, f.msg)
case 'q':
fmt.Fprintf(s, "%q", f.msg)
}
}
// WithStack annotates err with a stack trace at the point WithStack was called.
// If err is nil, WithStack returns nil.
func WithStack(err error) error {
if err == nil {
return nil
}
return &withStack{
err,
callers(),
}
}
type withStack struct {
error
*stack
}
func (w *withStack) Cause() error { return w.error }
func (w *withStack) Format(s fmt.State, verb rune) {
switch verb {
case 'v':
if s.Flag('+') {
fmt.Fprintf(s, "%+v", w.Cause())
w.stack.Format(s, verb)
return
}
fallthrough
case 's':
io.WriteString(s, w.Error())
case 'q':
fmt.Fprintf(s, "%q", w.Error())
}
}
// Wrap returns an error annotating err with a stack trace
// at the point Wrap is called, and the supplied message.
// If err is nil, Wrap returns nil.
func Wrap(err error, message string) error {
if err == nil {
return nil
}
err = &withMessage{
cause: err,
msg: message,
}
return &withStack{
err,
callers(),
}
}
// Wrapf returns an error annotating err with a stack trace
// at the point Wrapf is call, and the format specifier.
// If err is nil, Wrapf returns nil.
func Wrapf(err error, format string, args ...interface{}) error {
if err == nil {
return nil
}
err = &withMessage{
cause: err,
msg: fmt.Sprintf(format, args...),
}
return &withStack{
err,
callers(),
}
}
// WithMessage annotates err with a new message.
// If err is nil, WithMessage returns nil.
func WithMessage(err error, message string) error {
if err == nil {
return nil
}
return &withMessage{
cause: err,
msg: message,
}
}
type withMessage struct {
cause error
msg string
}
func (w *withMessage) Error() string { return