Compare commits
5 Commits
| Author | SHA1 | Date |
|---|---|---|
 Adrien Marquès
|
e7c84eddf8
|
|
|
Adrien Marquès
|
9e69b66289
|
|
|
Adrien Marquès
|
d092eaed01
|
|
|
Adrien Marquès
|
6c47dbc38f
|
|
|
Adrien Marquès
|
db52cfd28f |
179
client.go
179
client.go
|
|
@ -4,10 +4,11 @@ import (
|
|||
"bufio"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/request"
|
||||
"net"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.xdrm.io/go/ws/internal/http/upgrade"
|
||||
)
|
||||
|
||||
// Represents a client socket utility (reader, writer, ..)
|
||||
|
|
@ -35,36 +36,27 @@ type client struct {
|
|||
status MessageError // close status ; 0 = nothing ; else -> must close
|
||||
}
|
||||
|
||||
// Create creates a new client
|
||||
func buildClient(s net.Conn, ctl ControllerSet, serverCh serverChannelSet) (*client, error) {
|
||||
// newClient creates a new client
|
||||
func newClient(s net.Conn, ctl ControllerSet, serverCh serverChannelSet) (*client, error) {
|
||||
req := &upgrade.Request{}
|
||||
_, err := req.ReadFrom(s)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("request read: %w", err)
|
||||
}
|
||||
|
||||
/* (1) Manage UPGRADE request
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Parse request */
|
||||
req, _ := request.Parse(s)
|
||||
|
||||
/* (3) Build response */
|
||||
res := req.BuildResponse()
|
||||
|
||||
/* (4) Write into socket */
|
||||
_, err := res.Send(s)
|
||||
_, err = res.WriteTo(s)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Upgrade write error: %s", err)
|
||||
return nil, fmt.Errorf("upgrade write: %w", err)
|
||||
}
|
||||
|
||||
if res.GetStatusCode() != 101 {
|
||||
if res.StatusCode != 101 {
|
||||
s.Close()
|
||||
return nil, fmt.Errorf("Upgrade error (HTTP %d)\n", res.GetStatusCode())
|
||||
return nil, fmt.Errorf("upgrade failed (HTTP %d)", res.StatusCode)
|
||||
}
|
||||
|
||||
/* (2) Initialise client
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Get upgrade data */
|
||||
clientURI := req.GetURI()
|
||||
clientProtocol := res.GetProtocol()
|
||||
|
||||
/* (2) Initialise client */
|
||||
cli := &client{
|
||||
var cli = &client{
|
||||
io: clientIO{
|
||||
sock: s,
|
||||
reader: bufio.NewReader(s),
|
||||
|
|
@ -72,8 +64,8 @@ func buildClient(s net.Conn, ctl ControllerSet, serverCh serverChannelSet) (*cli
|
|||
},
|
||||
|
||||
iface: &Client{
|
||||
Protocol: string(clientProtocol),
|
||||
Arguments: [][]string{[]string{clientURI}},
|
||||
Protocol: string(res.Protocol),
|
||||
Arguments: [][]string{{req.URI()}},
|
||||
},
|
||||
|
||||
ch: clientChannelSet{
|
||||
|
|
@ -82,67 +74,54 @@ func buildClient(s net.Conn, ctl ControllerSet, serverCh serverChannelSet) (*cli
|
|||
},
|
||||
}
|
||||
|
||||
/* (3) Find controller by URI
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Try to find one */
|
||||
controller, arguments := ctl.Match(clientURI)
|
||||
|
||||
/* (2) If nothing found -> error */
|
||||
// find controller by URI
|
||||
controller, arguments := ctl.Match(req.URI())
|
||||
if controller == nil {
|
||||
return nil, fmt.Errorf("No controller found, no default controller set\n")
|
||||
return nil, fmt.Errorf("no controller found, no default controller set")
|
||||
}
|
||||
|
||||
/* (3) Copy arguments */
|
||||
// copy args
|
||||
cli.iface.Arguments = arguments
|
||||
|
||||
/* (4) Launch client routines
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Launch client controller */
|
||||
go controller.Fun(
|
||||
cli.iface, // pass the client
|
||||
cli.ch.receive, // the receiver
|
||||
cli.ch.send, // the sender
|
||||
serverCh.broadcast, // broadcast sender
|
||||
)
|
||||
|
||||
/* (2) Launch message reader */
|
||||
go clientReader(cli)
|
||||
|
||||
/* (3) Launc writer */
|
||||
go clientWriter(cli)
|
||||
|
||||
return cli, nil
|
||||
|
||||
}
|
||||
|
||||
// reader reads and parses messages from the buffer
|
||||
// clientReader reads and parses messages from the buffer
|
||||
func clientReader(c *client) {
|
||||
var frag *Message
|
||||
|
||||
closeStatus := NORMAL
|
||||
clientAck := true
|
||||
var (
|
||||
frag *Message
|
||||
closeStatus = Normal
|
||||
clientAck = true
|
||||
)
|
||||
|
||||
c.io.reading.Add(1)
|
||||
|
||||
for {
|
||||
|
||||
/* (1) if currently closing -> exit */
|
||||
// currently closing -> exit
|
||||
if c.io.closing {
|
||||
fmt.Printf("[reader] killed because closing")
|
||||
break
|
||||
}
|
||||
|
||||
/* (2) Parse message */
|
||||
msg, err := readMessage(c.io.reader)
|
||||
|
||||
// Parse message
|
||||
var msg = &Message{}
|
||||
_, err := msg.ReadFrom(c.io.reader)
|
||||
if err == ErrUnmaskedFrame || err == ErrReservedBits {
|
||||
closeStatus = PROTOCOL_ERR
|
||||
closeStatus = ProtocolError
|
||||
}
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
|
||||
/* (3) Fail on invalid message */
|
||||
// invalid message
|
||||
msgErr := msg.check(frag != nil)
|
||||
if msgErr != nil {
|
||||
|
||||
|
|
@ -150,27 +129,27 @@ func clientReader(c *client) {
|
|||
|
||||
switch msgErr {
|
||||
|
||||
// Fail
|
||||
// fail
|
||||
case ErrUnexpectedContinuation:
|
||||
closeStatus = NONE
|
||||
closeStatus = None
|
||||
clientAck = false
|
||||
mustClose = true
|
||||
|
||||
// proper close
|
||||
case CloseFrame:
|
||||
closeStatus = NORMAL
|
||||
case ErrCloseFrame:
|
||||
closeStatus = Normal
|
||||
clientAck = true
|
||||
mustClose = true
|
||||
|
||||
// invalid payload proper close
|
||||
case ErrInvalidPayload:
|
||||
closeStatus = INVALID_PAYLOAD
|
||||
closeStatus = InvalidPayload
|
||||
clientAck = true
|
||||
mustClose = true
|
||||
|
||||
// any other error -> protocol error
|
||||
default:
|
||||
closeStatus = PROTOCOL_ERR
|
||||
closeStatus = ProtocolError
|
||||
clientAck = true
|
||||
mustClose = true
|
||||
}
|
||||
|
|
@ -181,15 +160,15 @@ func clientReader(c *client) {
|
|||
|
||||
}
|
||||
|
||||
/* (4) Ping <-> Pong */
|
||||
if msg.Type == PING && c.io.writing {
|
||||
// ping <-> Pong
|
||||
if msg.Type == Ping && c.io.writing {
|
||||
msg.Final = true
|
||||
msg.Type = PONG
|
||||
msg.Type = Pong
|
||||
c.ch.send <- *msg
|
||||
continue
|
||||
}
|
||||
|
||||
/* (5) Store first fragment */
|
||||
// store first fragment
|
||||
if frag == nil && !msg.Final {
|
||||
frag = &Message{
|
||||
Type: msg.Type,
|
||||
|
|
@ -200,7 +179,7 @@ func clientReader(c *client) {
|
|||
continue
|
||||
}
|
||||
|
||||
/* (6) Store fragments */
|
||||
// store fragments
|
||||
if frag != nil {
|
||||
frag.Final = msg.Final
|
||||
frag.Size += msg.Size
|
||||
|
|
@ -213,10 +192,10 @@ func clientReader(c *client) {
|
|||
// check message errors
|
||||
fragErr := frag.check(false)
|
||||
if fragErr == ErrInvalidPayload {
|
||||
closeStatus = INVALID_PAYLOAD
|
||||
closeStatus = InvalidPayload
|
||||
break
|
||||
} else if fragErr != nil {
|
||||
closeStatus = PROTOCOL_ERR
|
||||
closeStatus = ProtocolError
|
||||
break
|
||||
}
|
||||
|
||||
|
|
@ -225,8 +204,8 @@ func clientReader(c *client) {
|
|||
|
||||
}
|
||||
|
||||
/* (7) Dispatch to receiver */
|
||||
if msg.Type == TEXT || msg.Type == BINARY {
|
||||
// dispatch to receiver
|
||||
if msg.Type == Text || msg.Type == Binary {
|
||||
c.ch.receive <- *msg
|
||||
}
|
||||
|
||||
|
|
@ -235,111 +214,79 @@ func clientReader(c *client) {
|
|||
close(c.ch.receive)
|
||||
c.io.reading.Done()
|
||||
|
||||
/* (8) close channel (if not already done) */
|
||||
// close channel (if not already done)
|
||||
// fmt.Printf("[reader] end\n")
|
||||
c.close(closeStatus, clientAck)
|
||||
|
||||
}
|
||||
|
||||
// writer writes into websocket
|
||||
// and is triggered by client.ch.send channel
|
||||
// clientWriter writes to the websocket connection and is triggered by
|
||||
// client.ch.send channel
|
||||
func clientWriter(c *client) {
|
||||
|
||||
c.io.writing = true // if channel still exists
|
||||
|
||||
for msg := range c.ch.send {
|
||||
|
||||
/* (2) Send message */
|
||||
err := msg.Send(c.io.sock)
|
||||
|
||||
/* (3) Fail on error */
|
||||
_, err := msg.WriteTo(c.io.sock)
|
||||
if err != nil {
|
||||
fmt.Printf(" [writer] %s\n", err)
|
||||
c.io.writing = false
|
||||
break
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
c.io.writing = false
|
||||
|
||||
/* (4) close channel (if not already done) */
|
||||
// close channel (if not already done)
|
||||
// fmt.Printf("[writer] end\n")
|
||||
c.close(NORMAL, true)
|
||||
c.close(Normal, true)
|
||||
|
||||
}
|
||||
|
||||
// closes the connection
|
||||
// close the connection
|
||||
// send CLOSE frame is 'status' is not NONE
|
||||
// wait for the next message (CLOSE acknowledge) if 'clientACK'
|
||||
// then delete client
|
||||
func (c *client) close(status MessageError, clientACK bool) {
|
||||
|
||||
/* (1) Fail if already closing */
|
||||
// fail if already closing
|
||||
alreadyClosing := false
|
||||
c.io.closingMu.Lock()
|
||||
alreadyClosing = c.io.closing
|
||||
c.io.closing = true
|
||||
c.io.closingMu.Unlock()
|
||||
|
||||
if alreadyClosing {
|
||||
return
|
||||
}
|
||||
|
||||
/* (2) kill writer' if still running */
|
||||
// kill writer' if still running
|
||||
if c.io.writing {
|
||||
close(c.ch.send)
|
||||
}
|
||||
|
||||
/* (3) kill reader if still running */
|
||||
// kill reader if still running
|
||||
c.io.sock.SetReadDeadline(time.Now().Add(time.Second * -1))
|
||||
c.io.reading.Wait()
|
||||
|
||||
if status != NONE {
|
||||
|
||||
/* (3) Build message */
|
||||
if status != None {
|
||||
msg := &Message{
|
||||
Final: true,
|
||||
Type: CLOSE,
|
||||
Type: Close,
|
||||
Size: 2,
|
||||
Data: make([]byte, 2),
|
||||
}
|
||||
binary.BigEndian.PutUint16(msg.Data, uint16(status))
|
||||
|
||||
/* (4) Send message */
|
||||
msg.Send(c.io.sock)
|
||||
// if err != nil {
|
||||
// fmt.Printf("[close] send error (%s0\n", err)
|
||||
// }
|
||||
|
||||
msg.WriteTo(c.io.sock)
|
||||
}
|
||||
|
||||
/* (2) Wait for client CLOSE if needed */
|
||||
// wait for client CLOSE if needed
|
||||
if clientACK {
|
||||
|
||||
c.io.sock.SetReadDeadline(time.Now().Add(time.Millisecond))
|
||||
|
||||
/* Wait for message */
|
||||
readMessage(c.io.reader)
|
||||
// if err != nil || msg.Type != CLOSE {
|
||||
// if err == nil {
|
||||
// fmt.Printf("[close] received OpCode = %d\n", msg.Type)
|
||||
// } else {
|
||||
// fmt.Printf("[close] read error (%v)\n", err)
|
||||
// }
|
||||
// }
|
||||
|
||||
// fmt.Printf("[close] received ACK\n")
|
||||
|
||||
var tmpMsg = &Message{}
|
||||
tmpMsg.ReadFrom(c.io.reader)
|
||||
}
|
||||
|
||||
/* (3) Close socket */
|
||||
c.io.sock.Close()
|
||||
// fmt.Printf("[close] socket closed\n")
|
||||
|
||||
/* (4) Unregister */
|
||||
c.io.kill <- c
|
||||
|
||||
return
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,21 +1,21 @@
|
|||
package iface
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
ws "git.xdrm.io/go/websocket"
|
||||
"time"
|
||||
|
||||
ws "git.xdrm.io/go/ws"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
startTime := time.Now().UnixNano()
|
||||
|
||||
/* (1) Bind WebSocket server */
|
||||
serv := ws.CreateServer("0.0.0.0", 4444)
|
||||
// creqte WebSocket server
|
||||
serv := ws.NewServer("0.0.0.0", 4444)
|
||||
|
||||
/* (2) Bind default controller */
|
||||
// bind default controller
|
||||
serv.BindDefault(func(cli *ws.Client, receiver <-chan ws.Message, sender chan<- ws.Message, bc chan<- ws.Message) {
|
||||
|
||||
defer func() {
|
||||
if recover() != nil {
|
||||
fmt.Printf("*** PANIC\n")
|
||||
|
|
@ -23,35 +23,28 @@ func main() {
|
|||
}()
|
||||
|
||||
for msg := range receiver {
|
||||
|
||||
// if receive message -> send it back
|
||||
sender <- msg
|
||||
// close(sender)
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
/* (3) Bind to URI */
|
||||
// bnd to URI
|
||||
err := serv.Bind("/channel/./room/./", func(cli *ws.Client, receiver <-chan ws.Message, sender chan<- ws.Message, bc chan<- ws.Message) {
|
||||
|
||||
fmt.Printf("[uri] connected\n")
|
||||
|
||||
for msg := range receiver {
|
||||
|
||||
fmt.Printf("[uri] received '%s'\n", msg.Data)
|
||||
sender <- msg
|
||||
|
||||
}
|
||||
|
||||
fmt.Printf("[uri] unexpectedly closed\n")
|
||||
|
||||
})
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
/* (4) Launch the server */
|
||||
// launch the server
|
||||
err = serv.Launch()
|
||||
if err != nil {
|
||||
fmt.Printf("[ERROR] %s\n", err)
|
||||
|
|
@ -59,5 +52,4 @@ func main() {
|
|||
}
|
||||
|
||||
fmt.Printf("+ elapsed: %1.1f us\n", float32(time.Now().UnixNano()-startTime)/1e3)
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,63 +1,48 @@
|
|||
package websocket
|
||||
|
||||
import (
|
||||
"git.xdrm.io/go/websocket/internal/uri/parser"
|
||||
)
|
||||
import "git.xdrm.io/go/ws/internal/uri"
|
||||
|
||||
// Represents available information about a client
|
||||
// Client contains available information about a client
|
||||
type Client struct {
|
||||
Protocol string // choosen protocol (Sec-WebSocket-Protocol)
|
||||
Arguments [][]string // URI parameters, index 0 is full URI, then matching groups
|
||||
Store interface{} // store (for client implementation-specific data)
|
||||
}
|
||||
|
||||
// Represents a websocket controller callback function
|
||||
// ControllerFunc is a websocket controller callback function
|
||||
type ControllerFunc func(*Client, <-chan Message, chan<- Message, chan<- Message)
|
||||
|
||||
// Represents a websocket controller
|
||||
// Controller is a websocket controller
|
||||
type Controller struct {
|
||||
URI *parser.Scheme // uri scheme
|
||||
URI *uri.Scheme // uri scheme
|
||||
Fun ControllerFunc // controller function
|
||||
}
|
||||
|
||||
// Represents a controller set
|
||||
// ControllerSet contains a set of controllers
|
||||
type ControllerSet struct {
|
||||
Def *Controller // default controller
|
||||
Uri []*Controller // uri controllers
|
||||
URI []*Controller // uri controllers
|
||||
}
|
||||
|
||||
// Match finds a controller for a given URI
|
||||
// also it returns the matching string patterns
|
||||
func (s *ControllerSet) Match(uri string) (*Controller, [][]string) {
|
||||
arguments := [][]string{{uri}}
|
||||
|
||||
/* (1) Initialise argument list */
|
||||
arguments := [][]string{[]string{uri}}
|
||||
|
||||
/* (2) Try each controller */
|
||||
for _, c := range s.Uri {
|
||||
|
||||
/* 1. If matches */
|
||||
for _, c := range s.URI {
|
||||
if c.URI.Match(uri) {
|
||||
|
||||
/* Extract matches */
|
||||
match := c.URI.GetAllMatch()
|
||||
|
||||
/* Add them to the 'arg' attribute */
|
||||
arguments = append(arguments, match...)
|
||||
|
||||
/* Mark that we have a controller */
|
||||
return c, arguments
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* (3) If no controller found -> set default controller */
|
||||
// fallback to default
|
||||
if s.Def != nil {
|
||||
return s.Def, arguments
|
||||
}
|
||||
|
||||
/* (4) If default is NIL, return empty controller */
|
||||
// no default
|
||||
return nil, arguments
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,48 +6,43 @@ package reader
|
|||
// the golang standard library
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"io"
|
||||
"bufio"
|
||||
)
|
||||
|
||||
// Maximum line length
|
||||
var maxLineLength = 4096
|
||||
const maxLineLength = 4096
|
||||
|
||||
// Chunk reader
|
||||
type chunkReader struct {
|
||||
// ChunkReader struct
|
||||
type ChunkReader struct {
|
||||
reader *bufio.Reader // the reader
|
||||
isEnded bool // If we are done (2 consecutive CRLF)
|
||||
}
|
||||
|
||||
|
||||
// New creates a new reader
|
||||
func NewReader(r io.Reader) (reader *chunkReader) {
|
||||
// NewReader creates a new reader
|
||||
func NewReader(r io.Reader) *ChunkReader {
|
||||
|
||||
br, ok := r.(*bufio.Reader)
|
||||
if !ok {
|
||||
br = bufio.NewReader(r)
|
||||
}
|
||||
|
||||
return &chunkReader{reader: br}
|
||||
return &ChunkReader{reader: br}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Read reads a chunk, err is io.EOF when done
|
||||
func (r *chunkReader) Read() ([]byte, error){
|
||||
|
||||
/* (1) If already ended */
|
||||
// Read reads a chunk, io.EOF when done
|
||||
func (r *ChunkReader) Read() ([]byte, error) {
|
||||
// already ended
|
||||
if r.isEnded {
|
||||
return nil, io.EOF
|
||||
}
|
||||
|
||||
/* (2) Read line */
|
||||
// read line
|
||||
var line []byte
|
||||
line, err := r.reader.ReadSlice('\n')
|
||||
|
||||
/* (3) manage errors */
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
|
|
@ -60,10 +55,8 @@ func (r *chunkReader) Read() ([]byte, error){
|
|||
return nil, fmt.Errorf("HTTP line %d exceeded buffer size %d", len(line), maxLineLength)
|
||||
}
|
||||
|
||||
/* (4) Trim */
|
||||
line = removeTrailingSpace(line)
|
||||
line = trimSpaces(line)
|
||||
|
||||
/* (5) Manage ending line */
|
||||
if len(line) == 0 {
|
||||
r.isEnded = true
|
||||
return line, io.EOF
|
||||
|
|
@ -73,15 +66,13 @@ func (r *chunkReader) Read() ([]byte, error){
|
|||
|
||||
}
|
||||
|
||||
|
||||
|
||||
func removeTrailingSpace(b []byte) []byte{
|
||||
for len(b) > 0 && isASCIISpace(b[len(b)-1]) {
|
||||
func trimSpaces(b []byte) []byte {
|
||||
for len(b) > 0 && isSpaceChar(b[len(b)-1]) {
|
||||
b = b[:len(b)-1]
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func isASCIISpace(b byte) bool {
|
||||
return b == ' ' || b == '\t' || b == '\r' || b =='\n'
|
||||
func isSpaceChar(b byte) bool {
|
||||
return b == ' ' || b == '\t' || b == '\r' || b == '\n'
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package upgrade
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// ErrInvalidRequest for invalid requests
|
||||
// - multiple-value if only 1 expected
|
||||
type ErrInvalidRequest struct {
|
||||
Field string
|
||||
Reason string
|
||||
}
|
||||
|
||||
func (err ErrInvalidRequest) Error() string {
|
||||
return fmt.Sprintf("invalid field '%s': %s", err.Field, err.Reason)
|
||||
}
|
||||
|
||||
// ErrIncompleteRequest when mandatory request fields are missing (request-line or headers)
|
||||
// it contains the missing field as a string
|
||||
type ErrIncompleteRequest string
|
||||
|
||||
func (err ErrIncompleteRequest) Error() string {
|
||||
return fmt.Sprintf("incomplete request, '%s' is invalid or missing", string(err))
|
||||
}
|
||||
|
||||
// ErrInvalidOriginPolicy when a request has a violated origin policy
|
||||
type ErrInvalidOriginPolicy struct {
|
||||
Host string
|
||||
Origin string
|
||||
err error
|
||||
}
|
||||
|
||||
func (err ErrInvalidOriginPolicy) Error() string {
|
||||
return fmt.Sprintf("invalid origin policy; (host: '%s' origin: '%s' error: '%s')", err.Host, err.Origin, err.err)
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
package upgrade
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// HeaderType represents all 'valid' HTTP request headers
|
||||
type HeaderType uint8
|
||||
|
||||
// header types
|
||||
const (
|
||||
Unknown HeaderType = iota
|
||||
Host
|
||||
Upgrade
|
||||
Connection
|
||||
Origin
|
||||
WSKey
|
||||
WSProtocol
|
||||
WSExtensions
|
||||
WSVersion
|
||||
)
|
||||
|
||||
// HeaderValue represents a unique or multiple header value(s)
|
||||
type HeaderValue [][]byte
|
||||
|
||||
// Header represents the data of a HTTP request header
|
||||
type Header struct {
|
||||
Name HeaderType
|
||||
Values HeaderValue
|
||||
}
|
||||
|
||||
// ReadHeader tries to parse an HTTP header from a byte array
|
||||
func ReadHeader(b []byte) (*Header, error) {
|
||||
|
||||
// 1. Split by ':'
|
||||
parts := bytes.Split(b, []byte(": "))
|
||||
|
||||
if len(parts) != 2 {
|
||||
return nil, fmt.Errorf("invalid HTTP header format '%s'", b)
|
||||
}
|
||||
|
||||
// 2. Create instance
|
||||
inst := &Header{}
|
||||
|
||||
// 3. Check for header name
|
||||
switch strings.ToLower(string(parts[0])) {
|
||||
case "host":
|
||||
inst.Name = Host
|
||||
case "upgrade":
|
||||
inst.Name = Upgrade
|
||||
case "connection":
|
||||
inst.Name = Connection
|
||||
case "origin":
|
||||
inst.Name = Origin
|
||||
case "sec-websocket-key":
|
||||
inst.Name = WSKey
|
||||
case "sec-websocket-protocol":
|
||||
inst.Name = WSProtocol
|
||||
case "sec-websocket-extensions":
|
||||
inst.Name = WSExtensions
|
||||
case "sec-websocket-version":
|
||||
inst.Name = WSVersion
|
||||
default:
|
||||
inst.Name = Unknown
|
||||
}
|
||||
|
||||
// 4. Split values
|
||||
inst.Values = bytes.Split(parts[1], []byte(", "))
|
||||
|
||||
return inst, nil
|
||||
|
||||
}
|
||||
|
|
@ -1,22 +1,20 @@
|
|||
package request
|
||||
package upgrade
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/request/parser/header"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/response"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// checkHost checks and extracts the Host header
|
||||
func (r *T) extractHostPort(bb header.HeaderValue) error {
|
||||
func (r *Request) extractHostPort(bb HeaderValue) error {
|
||||
|
||||
if len(bb) != 1 {
|
||||
return &InvalidRequest{"Host", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
return &ErrInvalidRequest{"Host", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
}
|
||||
|
||||
if len(bb[0]) <= 3 {
|
||||
return &InvalidRequest{"Host", fmt.Sprintf("expected non-empty value (got %d bytes)", len(bb[0]))}
|
||||
return &ErrInvalidRequest{"Host", fmt.Sprintf("expected non-empty value (got %d bytes)", len(bb[0]))}
|
||||
}
|
||||
|
||||
split := strings.Split(string(bb[0]), ":")
|
||||
|
|
@ -31,8 +29,8 @@ func (r *T) extractHostPort(bb header.HeaderValue) error {
|
|||
// extract port
|
||||
readPort, err := strconv.ParseUint(split[1], 10, 16)
|
||||
if err != nil {
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Host", "cannot read port"}
|
||||
r.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Host", "cannot read port"}
|
||||
}
|
||||
|
||||
r.port = uint16(readPort)
|
||||
|
|
@ -41,8 +39,8 @@ func (r *T) extractHostPort(bb header.HeaderValue) error {
|
|||
if len(r.origin) > 0 {
|
||||
if err != nil {
|
||||
err = r.checkOriginPolicy()
|
||||
r.code = response.FORBIDDEN
|
||||
return &InvalidOriginPolicy{r.host, r.origin, err}
|
||||
r.statusCode = StatusForbidden
|
||||
return &ErrInvalidOriginPolicy{r.host, r.origin, err}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -51,7 +49,7 @@ func (r *T) extractHostPort(bb header.HeaderValue) error {
|
|||
}
|
||||
|
||||
// checkOrigin checks the Origin Header
|
||||
func (r *T) extractOrigin(bb header.HeaderValue) error {
|
||||
func (r *Request) extractOrigin(bb HeaderValue) error {
|
||||
|
||||
// bypass
|
||||
if bypassOriginPolicy {
|
||||
|
|
@ -59,8 +57,8 @@ func (r *T) extractOrigin(bb header.HeaderValue) error {
|
|||
}
|
||||
|
||||
if len(bb) != 1 {
|
||||
r.code = response.FORBIDDEN
|
||||
return &InvalidRequest{"Origin", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
r.statusCode = StatusForbidden
|
||||
return &ErrInvalidRequest{"Origin", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
}
|
||||
|
||||
r.origin = string(bb[0])
|
||||
|
|
@ -69,8 +67,8 @@ func (r *T) extractOrigin(bb header.HeaderValue) error {
|
|||
if len(r.host) > 0 {
|
||||
err := r.checkOriginPolicy()
|
||||
if err != nil {
|
||||
r.code = response.FORBIDDEN
|
||||
return &InvalidOriginPolicy{r.host, r.origin, err}
|
||||
r.statusCode = StatusForbidden
|
||||
return &ErrInvalidOriginPolicy{r.host, r.origin, err}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -79,7 +77,7 @@ func (r *T) extractOrigin(bb header.HeaderValue) error {
|
|||
}
|
||||
|
||||
// checkOriginPolicy origin policy based on 'host' value
|
||||
func (r *T) checkOriginPolicy() error {
|
||||
func (r *Request) checkOriginPolicy() error {
|
||||
// TODO: Origin policy, for now BYPASS
|
||||
r.validPolicy = true
|
||||
return nil
|
||||
|
|
@ -87,7 +85,7 @@ func (r *T) checkOriginPolicy() error {
|
|||
|
||||
// checkConnection checks the 'Connection' header
|
||||
// it MUST contain 'Upgrade'
|
||||
func (r *T) checkConnection(bb header.HeaderValue) error {
|
||||
func (r *Request) checkConnection(bb HeaderValue) error {
|
||||
|
||||
for _, b := range bb {
|
||||
|
||||
|
|
@ -98,18 +96,18 @@ func (r *T) checkConnection(bb header.HeaderValue) error {
|
|||
|
||||
}
|
||||
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Upgrade", "expected 'Upgrade' (case insensitive)"}
|
||||
r.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Upgrade", "expected 'Upgrade' (case insensitive)"}
|
||||
|
||||
}
|
||||
|
||||
// checkUpgrade checks the 'Upgrade' header
|
||||
// it MUST be 'websocket'
|
||||
func (r *T) checkUpgrade(bb header.HeaderValue) error {
|
||||
func (r *Request) checkUpgrade(bb HeaderValue) error {
|
||||
|
||||
if len(bb) != 1 {
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Upgrade", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
r.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Upgrade", fmt.Sprintf("expected single value, got %d", len(bb))}
|
||||
}
|
||||
|
||||
if strings.ToLower(string(bb[0])) == "websocket" {
|
||||
|
|
@ -117,18 +115,18 @@ func (r *T) checkUpgrade(bb header.HeaderValue) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Upgrade", fmt.Sprintf("expected 'websocket' (case insensitive), got '%s'", bb[0])}
|
||||
r.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Upgrade", fmt.Sprintf("expected 'websocket' (case insensitive), got '%s'", bb[0])}
|
||||
|
||||
}
|
||||
|
||||
// checkVersion checks the 'Sec-WebSocket-Version' header
|
||||
// it MUST be '13'
|
||||
func (r *T) checkVersion(bb header.HeaderValue) error {
|
||||
func (r *Request) checkVersion(bb HeaderValue) error {
|
||||
|
||||
if len(bb) != 1 || string(bb[0]) != "13" {
|
||||
r.code = response.UPGRADE_REQUIRED
|
||||
return &InvalidRequest{"Sec-WebSocket-Version", fmt.Sprintf("expected '13', got '%s'", bb[0])}
|
||||
r.statusCode = StatusUpgradeRequired
|
||||
return &ErrInvalidRequest{"Sec-WebSocket-Version", fmt.Sprintf("expected '13', got '%s'", bb[0])}
|
||||
}
|
||||
|
||||
r.hasVersion = true
|
||||
|
|
@ -138,11 +136,11 @@ func (r *T) checkVersion(bb header.HeaderValue) error {
|
|||
|
||||
// extractKey extracts the 'Sec-WebSocket-Key' header
|
||||
// it MUST be 24 bytes (base64)
|
||||
func (r *T) extractKey(bb header.HeaderValue) error {
|
||||
func (r *Request) extractKey(bb HeaderValue) error {
|
||||
|
||||
if len(bb) != 1 || len(bb[0]) != 24 {
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Sec-WebSocket-Key", fmt.Sprintf("expected 24 bytes base64, got %d bytes", len(bb[0]))}
|
||||
r.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Sec-WebSocket-Key", fmt.Sprintf("expected 24 bytes base64, got %d bytes", len(bb[0]))}
|
||||
}
|
||||
|
||||
r.key = bb[0]
|
||||
|
|
@ -153,7 +151,7 @@ func (r *T) extractKey(bb header.HeaderValue) error {
|
|||
|
||||
// extractProtocols extracts the 'Sec-WebSocket-Protocol' header
|
||||
// it can contain multiple values
|
||||
func (r *T) extractProtocols(bb header.HeaderValue) error {
|
||||
func (r *Request) extractProtocols(bb HeaderValue) error {
|
||||
|
||||
r.protocols = bb
|
||||
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
package upgrade
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"git.xdrm.io/go/ws/internal/http/reader"
|
||||
)
|
||||
|
||||
// whether origin is required
|
||||
const bypassOriginPolicy = true
|
||||
|
||||
// Request represents an HTTP Upgrade request
|
||||
type Request struct {
|
||||
// whether the first line has been read (GET uri HTTP/version)
|
||||
first bool
|
||||
statusCode StatusCode
|
||||
requestLine RequestLine
|
||||
|
||||
// data to check origin (depends on reading order)
|
||||
host string
|
||||
port uint16 // 0 if not set
|
||||
origin string
|
||||
validPolicy bool
|
||||
|
||||
// websocket specific
|
||||
key []byte
|
||||
protocols [][]byte
|
||||
|
||||
// mandatory fields to check
|
||||
hasConnection bool
|
||||
hasUpgrade bool
|
||||
hasVersion bool
|
||||
}
|
||||
|
||||
// ReadFrom reads an upgrade HTTP request ; typically from bufio.NewRead of the
|
||||
// socket
|
||||
//
|
||||
// implements io.ReaderFrom
|
||||
func (req *Request) ReadFrom(r io.Reader) (int64, error) {
|
||||
var read int64
|
||||
|
||||
// reset request
|
||||
req.statusCode = 500
|
||||
|
||||
// parse header line by line
|
||||
var cr = reader.NewReader(r)
|
||||
for {
|
||||
line, err := cr.Read()
|
||||
read += int64(len(line))
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return read, err
|
||||
}
|
||||
|
||||
err = req.parseHeader(line)
|
||||
|
||||
if err != nil {
|
||||
return read, err
|
||||
}
|
||||
}
|
||||
|
||||
err := req.isComplete()
|
||||
if err != nil {
|
||||
req.statusCode = StatusBadRequest
|
||||
return read, err
|
||||
}
|
||||
|
||||
req.statusCode = StatusSwitchingProtocols
|
||||
return read, nil
|
||||
}
|
||||
|
||||
// StatusCode returns the status current
|
||||
func (req Request) StatusCode() StatusCode {
|
||||
return req.statusCode
|
||||
}
|
||||
|
||||
// BuildResponse builds a response from the request
|
||||
func (req *Request) BuildResponse() *Response {
|
||||
|
||||
res := &Response{
|
||||
StatusCode: req.statusCode,
|
||||
Protocol: nil,
|
||||
}
|
||||
|
||||
if len(req.protocols) > 0 {
|
||||
res.Protocol = req.protocols[0]
|
||||
}
|
||||
|
||||
res.ProcessKey(req.key)
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
// URI returns the actual URI
|
||||
func (req Request) URI() string {
|
||||
return req.requestLine.URI()
|
||||
}
|
||||
|
||||
// parseHeader parses any http request line
|
||||
// (header and request-line)
|
||||
func (req *Request) parseHeader(b []byte) error {
|
||||
// first line -> GET {uri} HTTP/{version}
|
||||
if !req.first {
|
||||
|
||||
_, err := req.requestLine.Read(b)
|
||||
if err != nil {
|
||||
req.statusCode = StatusBadRequest
|
||||
return &ErrInvalidRequest{"Request-Line", err.Error()}
|
||||
}
|
||||
|
||||
req.first = true
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// other lines -> Header-Name: Header-Value
|
||||
head, err := ReadHeader(b)
|
||||
if err != nil {
|
||||
req.statusCode = StatusBadRequest
|
||||
return fmt.Errorf("parse header: %w", err)
|
||||
}
|
||||
|
||||
// 2. Manage header
|
||||
switch head.Name {
|
||||
case Host:
|
||||
err = req.extractHostPort(head.Values)
|
||||
case Origin:
|
||||
err = req.extractOrigin(head.Values)
|
||||
case Upgrade:
|
||||
err = req.checkUpgrade(head.Values)
|
||||
case Connection:
|
||||
err = req.checkConnection(head.Values)
|
||||
case WSVersion:
|
||||
err = req.checkVersion(head.Values)
|
||||
case WSKey:
|
||||
err = req.extractKey(head.Values)
|
||||
case WSProtocol:
|
||||
err = req.extractProtocols(head.Values)
|
||||
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
|
||||
// dispatch error
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// isComplete returns whether the Upgrade Request
|
||||
// is complete (no required field missing)
|
||||
// returns nil on success
|
||||
func (req Request) isComplete() error {
|
||||
if !req.first {
|
||||
return ErrIncompleteRequest("Request-Line")
|
||||
}
|
||||
|
||||
if len(req.host) == 0 {
|
||||
return ErrIncompleteRequest("Host")
|
||||
}
|
||||
|
||||
if !bypassOriginPolicy && len(req.origin) == 0 {
|
||||
return ErrIncompleteRequest("Origin")
|
||||
}
|
||||
|
||||
if !req.hasConnection {
|
||||
return ErrIncompleteRequest("Connection")
|
||||
}
|
||||
|
||||
if !req.hasUpgrade {
|
||||
return ErrIncompleteRequest("Upgrade")
|
||||
}
|
||||
|
||||
if !req.hasVersion {
|
||||
return ErrIncompleteRequest("Sec-WebSocket-Version")
|
||||
}
|
||||
|
||||
if len(req.key) < 1 {
|
||||
return ErrIncompleteRequest("Sec-WebSocket-Key")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
package request
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// invalid request
|
||||
// - multiple-value if only 1 expected
|
||||
type InvalidRequest struct {
|
||||
Field string
|
||||
Reason string
|
||||
}
|
||||
|
||||
func (err InvalidRequest) Error() string {
|
||||
return fmt.Sprintf("Invalid field '%s': %s", err.Field, err.Reason)
|
||||
}
|
||||
|
||||
// Request misses fields (request-line or headers)
|
||||
type IncompleteRequest struct {
|
||||
MissingField string
|
||||
}
|
||||
|
||||
func (err IncompleteRequest) Error() string {
|
||||
return fmt.Sprintf("imcomplete request, '%s' is invalid or missing", err.MissingField)
|
||||
}
|
||||
|
||||
// Request has a violated origin policy
|
||||
type InvalidOriginPolicy struct {
|
||||
Host string
|
||||
Origin string
|
||||
err error
|
||||
}
|
||||
|
||||
func (err InvalidOriginPolicy) Error() string {
|
||||
return fmt.Sprintf("invalid origin policy; (host: '%s' origin: '%s' error: '%s')", err.Host, err.Origin, err.err)
|
||||
}
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
package header
|
||||
|
||||
import (
|
||||
// "regexp"
|
||||
"fmt"
|
||||
"strings"
|
||||
"bytes"
|
||||
)
|
||||
|
||||
// parse tries to return a 'T' (httpHeader) from a byte array
|
||||
func Parse(b []byte) (*T, error) {
|
||||
|
||||
/* (1) Split by ':' */
|
||||
parts := bytes.Split(b, []byte(": "))
|
||||
|
||||
if len(parts) != 2 {
|
||||
return nil, fmt.Errorf("Invalid HTTP header format '%s'", b)
|
||||
}
|
||||
|
||||
/* (2) Create instance */
|
||||
inst := new(T)
|
||||
|
||||
/* (3) Check for header name */
|
||||
switch strings.ToLower(string(parts[0])) {
|
||||
case "host": inst.Name = HOST
|
||||
case "upgrade": inst.Name = UPGRADE
|
||||
case "connection": inst.Name = CONNECTION
|
||||
case "origin": inst.Name = ORIGIN
|
||||
case "sec-websocket-key": inst.Name = WSKEY
|
||||
case "sec-websocket-protocol": inst.Name = WSPROTOCOL
|
||||
case "sec-websocket-extensions": inst.Name = WSEXTENSIONS
|
||||
case "sec-websocket-version": inst.Name = WSVERSION
|
||||
default: inst.Name = UNKNOWN
|
||||
}
|
||||
|
||||
/* (4) Split values */
|
||||
inst.Values = bytes.Split(parts[1], []byte(", "))
|
||||
|
||||
return inst, nil
|
||||
|
||||
}
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
package header
|
||||
|
||||
// HeaderType represents all 'valid' HTTP request headers
|
||||
type HeaderType byte
|
||||
const (
|
||||
UNKNOWN HeaderType = iota
|
||||
HOST
|
||||
UPGRADE
|
||||
CONNECTION
|
||||
ORIGIN
|
||||
WSKEY
|
||||
WSPROTOCOL
|
||||
WSEXTENSIONS
|
||||
WSVERSION
|
||||
)
|
||||
|
||||
// HeaderValue represents a unique or multiple header value(s)
|
||||
type HeaderValue [][]byte
|
||||
|
||||
|
||||
// T represents the data of a HTTP request header
|
||||
type T struct{
|
||||
Name HeaderType
|
||||
Values HeaderValue
|
||||
}
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
package request
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/request/parser/header"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/response"
|
||||
)
|
||||
|
||||
// parseHeader parses any http request line
|
||||
// (header and request-line)
|
||||
func (r *T) parseHeader(b []byte) error {
|
||||
|
||||
/* (1) First line -> GET {uri} HTTP/{version}
|
||||
---------------------------------------------------------*/
|
||||
if !r.first {
|
||||
|
||||
err := r.request.Parse(b)
|
||||
|
||||
if err != nil {
|
||||
r.code = response.BAD_REQUEST
|
||||
return &InvalidRequest{"Request-Line", err.Error()}
|
||||
}
|
||||
|
||||
r.first = true
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
/* (2) Other lines -> Header-Name: Header-Value
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Try to parse header */
|
||||
head, err := header.Parse(b)
|
||||
if err != nil {
|
||||
r.code = response.BAD_REQUEST
|
||||
return fmt.Errorf("Error parsing header: %s", err)
|
||||
}
|
||||
|
||||
/* (2) Manage header */
|
||||
switch head.Name {
|
||||
case header.HOST:
|
||||
err = r.extractHostPort(head.Values)
|
||||
case header.ORIGIN:
|
||||
err = r.extractOrigin(head.Values)
|
||||
case header.UPGRADE:
|
||||
err = r.checkUpgrade(head.Values)
|
||||
case header.CONNECTION:
|
||||
err = r.checkConnection(head.Values)
|
||||
case header.WSVERSION:
|
||||
err = r.checkVersion(head.Values)
|
||||
case header.WSKEY:
|
||||
err = r.extractKey(head.Values)
|
||||
case header.WSPROTOCOL:
|
||||
err = r.extractProtocols(head.Values)
|
||||
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
|
||||
// dispatch error
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// isComplete returns whether the Upgrade Request
|
||||
// is complete (no missing required item)
|
||||
func (r T) isComplete() error {
|
||||
|
||||
/* (1) Request-Line */
|
||||
if !r.first {
|
||||
return &IncompleteRequest{"Request-Line"}
|
||||
}
|
||||
|
||||
/* (2) Host */
|
||||
if len(r.host) == 0 {
|
||||
return &IncompleteRequest{"Host"}
|
||||
}
|
||||
|
||||
/* (3) Origin */
|
||||
if !bypassOriginPolicy && len(r.origin) == 0 {
|
||||
return &IncompleteRequest{"Origin"}
|
||||
}
|
||||
|
||||
/* (4) Connection */
|
||||
if !r.hasConnection {
|
||||
return &IncompleteRequest{"Connection"}
|
||||
}
|
||||
|
||||
/* (5) Upgrade */
|
||||
if !r.hasUpgrade {
|
||||
return &IncompleteRequest{"Upgrade"}
|
||||
}
|
||||
|
||||
/* (6) Sec-WebSocket-Version */
|
||||
if !r.hasVersion {
|
||||
return &IncompleteRequest{"Sec-WebSocket-Version"}
|
||||
}
|
||||
|
||||
/* (7) Sec-WebSocket-Key */
|
||||
if len(r.key) < 1 {
|
||||
return &IncompleteRequest{"Sec-WebSocket-Key"}
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
package request
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.xdrm.io/go/websocket/internal/http/reader"
|
||||
"git.xdrm.io/go/websocket/internal/http/upgrade/response"
|
||||
"io"
|
||||
)
|
||||
|
||||
// Parse builds an upgrade HTTP request
|
||||
// from a reader (typically bufio.NewRead of the socket)
|
||||
func Parse(r io.Reader) (request *T, err error) {
|
||||
|
||||
req := new(T)
|
||||
req.code = 500
|
||||
|
||||
/* (1) Parse request
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Get chunk reader */
|
||||
cr := reader.NewReader(r)
|
||||
if err != nil {
|
||||
return req, fmt.Errorf("Error while creating chunk reader: %s", err)
|
||||
}
|
||||
|
||||
/* (2) Parse header line by line */
|
||||
for {
|
||||
|
||||
line, err := cr.Read()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return req, err
|
||||
}
|
||||
|
||||
err = req.parseHeader(line)
|
||||
|
||||
if err != nil {
|
||||
return req, err
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* (3) Check completion */
|
||||
err = req.isComplete()
|
||||
if err != nil {
|
||||
req.code = response.BAD_REQUEST
|
||||
return req, err
|
||||
}
|
||||
|
||||
req.code = response.SWITCHING_PROTOCOLS
|
||||
return req, nil
|
||||
|
||||
}
|
||||
|
||||
// StatusCode returns the status current
|
||||
func (r T) StatusCode() response.StatusCode {
|
||||
return r.code
|
||||
}
|
||||
|
||||
// BuildResponse builds a response.T from the request
|
||||
func (r *T) BuildResponse() *response.T {
|
||||
|
||||
inst := new(response.T)
|
||||
|
||||
/* (1) Copy code */
|
||||
inst.SetStatusCode(r.code)
|
||||
|
||||
/* (2) Set Protocol */
|
||||
if len(r.protocols) > 0 {
|
||||
inst.SetProtocol(r.protocols[0])
|
||||
}
|
||||
|
||||
/* (4) Process key */
|
||||
inst.ProcessKey(r.key)
|
||||
|
||||
return inst
|
||||
}
|
||||
|
||||
// GetURI returns the actual URI
|
||||
func (r T) GetURI() string {
|
||||
return r.request.GetURI()
|
||||
}
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
package request
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// httpMethod represents available http methods
|
||||
type httpMethod byte
|
||||
|
||||
const (
|
||||
OPTIONS httpMethod = iota
|
||||
GET
|
||||
HEAD
|
||||
POST
|
||||
PUT
|
||||
DELETE
|
||||
)
|
||||
|
||||
// RequestLine represents the HTTP Request line
|
||||
// defined in rfc-2616 : https://tools.ietf.org/html/rfc2616#section-5.1
|
||||
type RequestLine struct {
|
||||
method httpMethod
|
||||
uri string
|
||||
version byte
|
||||
}
|
||||
|
||||
// parseRequestLine parses the first HTTP request line
|
||||
func (r *RequestLine) Parse(b []byte) error {
|
||||
|
||||
/* (1) Split by ' ' */
|
||||
parts := bytes.Split(b, []byte(" "))
|
||||
|
||||
/* (2) Fail when missing parts */
|
||||
if len(parts) != 3 {
|
||||
return fmt.Errorf("expected 3 space-separated elements, got %d elements", len(parts))
|
||||
}
|
||||
|
||||
/* (3) Extract HTTP method */
|
||||
err := r.extractHttpMethod(parts[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
/* (4) Extract URI */
|
||||
err = r.extractURI(parts[1])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
/* (5) Extract version */
|
||||
err = r.extractHttpVersion(parts[2])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// GetURI returns the actual URI
|
||||
func (r RequestLine) GetURI() string {
|
||||
return r.uri
|
||||
}
|
||||
|
||||
// extractHttpMethod extracts the HTTP method from a []byte
|
||||
// and checks for errors
|
||||
// allowed format: OPTIONS|GET|HEAD|POST|PUT|DELETE
|
||||
func (r *RequestLine) extractHttpMethod(b []byte) error {
|
||||
|
||||
switch string(b) {
|
||||
// case "OPTIONS": r.method = OPTIONS
|
||||
case "GET":
|
||||
r.method = GET
|
||||
// case "HEAD": r.method = HEAD
|
||||
// case "POST": r.method = POST
|
||||
// case "PUT": r.method = PUT
|
||||
// case "DELETE": r.method = DELETE
|
||||
|
||||
default:
|
||||
return fmt.Errorf("Invalid HTTP method '%s', expected 'GET'", b)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// extractURI extracts the URI from a []byte and checks for errors
|
||||
// allowed format: /([^/]/)*/?
|
||||
func (r *RequestLine) extractURI(b []byte) error {
|
||||
|
||||
/* (1) Check format */
|
||||
checker := regexp.MustCompile("^(?:/[^/]+)*/?$")
|
||||
if !checker.Match(b) {
|
||||
return fmt.Errorf("invalid URI, expected an absolute path, got '%s'", b)
|
||||
}
|
||||
|
||||
/* (2) Store */
|
||||
r.uri = string(b)
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// extractHttpVersion extracts the version and checks for errors
|
||||
// allowed format: [1-9] or [1.9].[0-9]
|
||||
func (r *RequestLine) extractHttpVersion(b []byte) error {
|
||||
|
||||
/* (1) Extract version parts */
|
||||
extractor := regexp.MustCompile(`^HTTP/([1-9])(?:\.([0-9]))?$`)
|
||||
|
||||
if !extractor.Match(b) {
|
||||
return fmt.Errorf("HTTP version, expected INT or INT.INT, got '%s'", b)
|
||||
}
|
||||
|
||||
/* (2) Extract version number */
|
||||
matches := extractor.FindSubmatch(b)
|
||||
var version byte = matches[1][0] - '0'
|
||||
|
||||
/* (3) Extract subversion (if exists) */
|
||||
var subVersion byte = 0
|
||||
if len(matches[2]) > 0 {
|
||||
subVersion = matches[2][0] - '0'
|
||||
}
|
||||
|
||||
/* (4) Store version (x 10 to fit uint8) */
|
||||
r.version = version*10 + subVersion
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
package request
|
||||
|
||||
import "git.xdrm.io/go/websocket/internal/http/upgrade/response"
|
||||
|
||||
// If origin is required
|
||||
const bypassOriginPolicy = true
|
||||
|
||||
// T represents an HTTP Upgrade request
|
||||
type T struct {
|
||||
first bool // whether the first line has been read (GET uri HTTP/version)
|
||||
|
||||
// status code
|
||||
code response.StatusCode
|
||||
|
||||
// request line
|
||||
request RequestLine
|
||||
|
||||
// data to check origin (depends of reading order)
|
||||
host string
|
||||
port uint16 // 0 if not set
|
||||
origin string
|
||||
validPolicy bool
|
||||
|
||||
// ws data
|
||||
key []byte
|
||||
protocols [][]byte
|
||||
|
||||
// required fields check
|
||||
hasConnection bool
|
||||
hasUpgrade bool
|
||||
hasVersion bool
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
package upgrade
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// RequestLine represents the HTTP Request line
|
||||
// defined in rfc-2616 : https://tools.ietf.org/html/rfc2616#section-5.1
|
||||
type RequestLine struct {
|
||||
uri string
|
||||
version byte
|
||||
}
|
||||
|
||||
// Read an HTTP request line from a byte array
|
||||
//
|
||||
// implements io.Reader
|
||||
func (rl *RequestLine) Read(b []byte) (int, error) {
|
||||
var read = len(b)
|
||||
|
||||
// split by spaces
|
||||
parts := bytes.Split(b, []byte(" "))
|
||||
|
||||
if len(parts) != 3 {
|
||||
return read, fmt.Errorf("expected 3 space-separated elements, got %d elements", len(parts))
|
||||
}
|
||||
|
||||
err := rl.extractHttpMethod(parts[0])
|
||||
if err != nil {
|
||||
return read, err
|
||||
}
|
||||
|
||||
err = rl.extractURI(parts[1])
|
||||
if err != nil {
|
||||
return read, err
|
||||
}
|
||||
|
||||
err = rl.extractHttpVersion(parts[2])
|
||||
if err != nil {
|
||||
return read, err
|
||||
}
|
||||
|
||||
return read, nil
|
||||
|
||||
}
|
||||
|
||||
// URI of the request line
|
||||
func (rl RequestLine) URI() string {
|
||||
return rl.uri
|
||||
}
|
||||
|
||||
// extractHttpMethod extracts the HTTP method from a []byte
|
||||
// and checks for errors
|
||||
// allowed format: OPTIONS|GET|HEAD|POST|PUT|DELETE
|
||||
func (rl *RequestLine) extractHttpMethod(b []byte) error {
|
||||
if string(b) != "GET" {
|
||||
return fmt.Errorf("invalid HTTP method '%s', expected 'GET'", b)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// extractURI extracts the URI from a []byte and checks for errors
|
||||
// allowed format: /([^/]/)*/?
|
||||
func (rl *RequestLine) extractURI(b []byte) error {
|
||||
checker := regexp.MustCompile("^(?:/[^/]+)*/?$")
|
||||
if !checker.Match(b) {
|
||||
return fmt.Errorf("invalid URI, expected an absolute path, got '%s'", b)
|
||||
}
|
||||
rl.uri = string(b)
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// extractHttpVersion extracts the version and checks for errors
|
||||
// allowed format: [1-9] or [1.9].[0-9]
|
||||
func (rl *RequestLine) extractHttpVersion(b []byte) error {
|
||||
extractor := regexp.MustCompile(`^HTTP/([1-9])(?:\.([0-9]))?$`)
|
||||
|
||||
if !extractor.Match(b) {
|
||||
return fmt.Errorf("invalid HTTP version, expected INT or INT.INT, got '%s'", b)
|
||||
}
|
||||
matches := extractor.FindSubmatch(b)
|
||||
|
||||
var version byte = matches[1][0] - '0'
|
||||
|
||||
var subversion byte = 0
|
||||
if len(matches[2]) > 0 {
|
||||
subversion = matches[2][0] - '0'
|
||||
}
|
||||
|
||||
rl.version = version*10 + subversion
|
||||
return nil
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package request
|
||||
package upgrade
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
|
@ -6,40 +6,21 @@ import (
|
|||
"testing"
|
||||
)
|
||||
|
||||
// /* (1) Parse request */
|
||||
// req, _ := request.Parse(s)
|
||||
|
||||
// /* (3) Build response */
|
||||
// res := req.BuildResponse()
|
||||
|
||||
// /* (4) Write into socket */
|
||||
// _, err := res.Send(s)
|
||||
// if err != nil {
|
||||
// return nil, fmt.Errorf("Upgrade write error: %s", err)
|
||||
// }
|
||||
|
||||
// if res.GetStatusCode() != 101 {
|
||||
// s.Close()
|
||||
// return nil, fmt.Errorf("Upgrade error (HTTP %d)\n", res.GetStatusCode())
|
||||
// }
|
||||
|
||||
func TestEOFSocket(t *testing.T) {
|
||||
var (
|
||||
socket = &bytes.Buffer{}
|
||||
req = &Request{}
|
||||
)
|
||||
|
||||
socket := new(bytes.Buffer)
|
||||
|
||||
_, err := Parse(socket)
|
||||
|
||||
if err == nil {
|
||||
t.Fatalf("Empty socket expected EOF, got no error")
|
||||
} else if err != io.ErrUnexpectedEOF {
|
||||
t.Fatalf("Empty socket expected EOF, got '%s'", err)
|
||||
_, err := req.ReadFrom(socket)
|
||||
if err != io.ErrUnexpectedEOF {
|
||||
t.Fatalf("unexpected error <%v> expected <%v>", err, io.ErrUnexpectedEOF)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestInvalidRequestLine(t *testing.T) {
|
||||
|
||||
socket := new(bytes.Buffer)
|
||||
socket := &bytes.Buffer{}
|
||||
cases := []struct {
|
||||
Reqline string
|
||||
HasError bool
|
||||
|
|
@ -76,15 +57,13 @@ func TestInvalidRequestLine(t *testing.T) {
|
|||
socket.Write([]byte(tc.Reqline))
|
||||
socket.Write([]byte("\r\n\r\n"))
|
||||
|
||||
_, err := Parse(socket)
|
||||
|
||||
var req = &Request{}
|
||||
_, err := req.ReadFrom(socket)
|
||||
if !tc.HasError {
|
||||
|
||||
// no error -> ok
|
||||
if err == nil {
|
||||
continue
|
||||
// error for the end of the request -> ok
|
||||
} else if _, ok := err.(*IncompleteRequest); ok {
|
||||
} else if _, ok := err.(ErrIncompleteRequest); ok {
|
||||
continue
|
||||
}
|
||||
|
||||
|
|
@ -97,7 +76,7 @@ func TestInvalidRequestLine(t *testing.T) {
|
|||
continue
|
||||
}
|
||||
|
||||
ir, ok := err.(*InvalidRequest)
|
||||
ir, ok := err.(*ErrInvalidRequest)
|
||||
|
||||
// not InvalidRequest err -> error
|
||||
if !ok || ir.Field != "Request-Line" {
|
||||
|
|
@ -113,7 +92,7 @@ func TestInvalidHost(t *testing.T) {
|
|||
|
||||
requestLine := []byte("GET / HTTP/1.1\r\n")
|
||||
|
||||
socket := new(bytes.Buffer)
|
||||
socket := &bytes.Buffer{}
|
||||
cases := []struct {
|
||||
Host string
|
||||
HasError bool
|
||||
|
|
@ -148,15 +127,15 @@ func TestInvalidHost(t *testing.T) {
|
|||
socket.Write([]byte(tc.Host))
|
||||
socket.Write([]byte("\r\n\r\n"))
|
||||
|
||||
_, err := Parse(socket)
|
||||
|
||||
var req = &Request{}
|
||||
_, err := req.ReadFrom(socket)
|
||||
if !tc.HasError {
|
||||
|
||||
// no error -> ok
|
||||
if err == nil {
|
||||
continue
|
||||
// error for the end of the request -> ok
|
||||
} else if _, ok := err.(*IncompleteRequest); ok {
|
||||
} else if _, ok := err.(ErrIncompleteRequest); ok {
|
||||
continue
|
||||
}
|
||||
|
||||
|
|
@ -170,7 +149,7 @@ func TestInvalidHost(t *testing.T) {
|
|||
}
|
||||
|
||||
// check if InvalidRequest
|
||||
ir, ok := err.(*InvalidRequest)
|
||||
ir, ok := err.(ErrInvalidRequest)
|
||||
|
||||
// not InvalidRequest err -> error
|
||||
if ok && ir.Field != "Host" {
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
package upgrade
|
||||
|
||||
import (
|
||||
"crypto/sha1"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
)
|
||||
|
||||
// constants
|
||||
const (
|
||||
httpVersion = "1.1"
|
||||
wsVersion = 13
|
||||
keySalt = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||
)
|
||||
|
||||
// Response is an HTTP Upgrade Response
|
||||
type Response struct {
|
||||
StatusCode StatusCode
|
||||
// Sec-WebSocket-Protocol or nil if missing
|
||||
Protocol []byte
|
||||
// processed from Sec-WebSocket-Key
|
||||
key []byte
|
||||
}
|
||||
|
||||
// ProcessKey processes the accept token according
|
||||
// to the rfc from the Sec-WebSocket-Key
|
||||
func (r *Response) ProcessKey(k []byte) {
|
||||
// ignore empty key
|
||||
if k == nil || len(k) < 1 {
|
||||
return
|
||||
}
|
||||
|
||||
// concat with constant salt
|
||||
salted := append(k, []byte(keySalt)...)
|
||||
// hash with sha1
|
||||
digest := sha1.Sum(salted)
|
||||
// base64 encode
|
||||
r.key = []byte(base64.StdEncoding.EncodeToString(digest[:sha1.Size]))
|
||||
}
|
||||
|
||||
// WriteTo writes the response; typically in a socket
|
||||
//
|
||||
// implements io.WriterTo
|
||||
func (r Response) WriteTo(w io.Writer) (int64, error) {
|
||||
responseLine := fmt.Sprintf("HTTP/%s %d %s\r\n", httpVersion, r.StatusCode, r.StatusCode)
|
||||
|
||||
optionalProtocol := ""
|
||||
if len(r.Protocol) > 0 {
|
||||
optionalProtocol = fmt.Sprintf("Sec-WebSocket-Protocol: %s\r\n", r.Protocol)
|
||||
}
|
||||
|
||||
headers := fmt.Sprintf("Upgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: %d\r\n%s", wsVersion, optionalProtocol)
|
||||
if r.key != nil {
|
||||
headers = fmt.Sprintf("%sSec-WebSocket-Accept: %s\r\n", headers, r.key)
|
||||
}
|
||||
headers = fmt.Sprintf("%s\r\n", headers)
|
||||
|
||||
combined := []byte(fmt.Sprintf("%s%s", responseLine, headers))
|
||||
|
||||
written, err := w.Write(combined)
|
||||
return int64(written), err
|
||||
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
package response
|
||||
|
||||
import (
|
||||
"crypto/sha1"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
)
|
||||
|
||||
// SetStatusCode sets the status code
|
||||
func (r *T) SetStatusCode(sc StatusCode) {
|
||||
r.code = sc
|
||||
}
|
||||
|
||||
// SetProtocols sets the protocols
|
||||
func (r *T) SetProtocol(p []byte) {
|
||||
r.protocol = p
|
||||
}
|
||||
|
||||
// ProcessKey processes the accept token according
|
||||
// to the rfc from the Sec-WebSocket-Key
|
||||
func (r *T) ProcessKey(k []byte) {
|
||||
|
||||
// do nothing for empty key
|
||||
if k == nil || len(k) == 0 {
|
||||
r.accept = nil
|
||||
return
|
||||
}
|
||||
|
||||
/* (1) Concat with constant salt */
|
||||
mix := append(k, WSSalt...)
|
||||
|
||||
/* (2) Hash with sha1 algorithm */
|
||||
digest := sha1.Sum(mix)
|
||||
|
||||
/* (3) Base64 encode it */
|
||||
r.accept = []byte(base64.StdEncoding.EncodeToString(digest[:sha1.Size]))
|
||||
|
||||
}
|
||||
|
||||
// Send sends the response through an io.Writer
|
||||
// typically a socket
|
||||
func (r T) Send(w io.Writer) (int, error) {
|
||||
|
||||
/* (1) Build response line */
|
||||
responseLine := fmt.Sprintf("HTTP/%s %d %s\r\n", HttpVersion, r.code, r.code.Message())
|
||||
|
||||
/* (2) Build headers */
|
||||
optionalProtocol := ""
|
||||
if len(r.protocol) > 0 {
|
||||
optionalProtocol = fmt.Sprintf("Sec-WebSocket-Protocol: %s\r\n", r.protocol)
|
||||
}
|
||||
|
||||
headers := fmt.Sprintf("Upgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: %d\r\n%s", WSVersion, optionalProtocol)
|
||||
if r.accept != nil {
|
||||
headers = fmt.Sprintf("%sSec-WebSocket-Accept: %s\r\n", headers, r.accept)
|
||||
}
|
||||
headers = fmt.Sprintf("%s\r\n", headers)
|
||||
|
||||
/* (3) Build all */
|
||||
raw := []byte(fmt.Sprintf("%s%s", responseLine, headers))
|
||||
|
||||
/* (4) Write */
|
||||
written, err := w.Write(raw)
|
||||
|
||||
return written, err
|
||||
|
||||
}
|
||||
|
||||
// GetProtocol returns the choosen protocol if set, else nil
|
||||
func (r T) GetProtocol() []byte {
|
||||
return r.protocol
|
||||
}
|
||||
|
||||
// GetStatusCode returns the response status code
|
||||
func (r T) GetStatusCode() StatusCode {
|
||||
return r.code
|
||||
}
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
package response
|
||||
|
||||
// StatusCode maps the status codes (and description)
|
||||
type StatusCode uint16
|
||||
|
||||
var SWITCHING_PROTOCOLS StatusCode = 101 // handshake success
|
||||
var BAD_REQUEST StatusCode = 400 // missing/malformed headers
|
||||
var FORBIDDEN StatusCode = 403 // invalid origin policy, TLS required
|
||||
var UPGRADE_REQUIRED StatusCode = 426 // invalid WS version
|
||||
var NOT_FOUND StatusCode = 404 // unserved or invalid URI
|
||||
var INTERNAL StatusCode = 500 // custom error
|
||||
|
||||
func (sc StatusCode) Message() string {
|
||||
|
||||
switch sc {
|
||||
case SWITCHING_PROTOCOLS:
|
||||
return "Switching Protocols"
|
||||
case BAD_REQUEST:
|
||||
return "Bad Request"
|
||||
case FORBIDDEN:
|
||||
return "Forbidden"
|
||||
case UPGRADE_REQUIRED:
|
||||
return "Upgrade Required"
|
||||
case NOT_FOUND:
|
||||
return "Not Found"
|
||||
case INTERNAL:
|
||||
return "Internal Server Error"
|
||||
default:
|
||||
return "Unknown Status Code"
|
||||
}
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
package response
|
||||
|
||||
// Constant
|
||||
const HttpVersion = "1.1"
|
||||
const WSVersion = 13
|
||||
|
||||
var WSSalt []byte = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
|
||||
|
||||
// T represents an HTTP Upgrade Response
|
||||
type T struct {
|
||||
code StatusCode // status code
|
||||
accept []byte // processed from Sec-WebSocket-Key
|
||||
protocol []byte // set from Sec-WebSocket-Protocol or none if not received
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
package upgrade
|
||||
|
||||
// StatusCode maps HTTP status codes (and description)
|
||||
type StatusCode int
|
||||
|
||||
const (
|
||||
// StatusSwitchingProtocols - handshake success
|
||||
StatusSwitchingProtocols StatusCode = 101
|
||||
// StatusBadRequest - missing/malformed headers
|
||||
StatusBadRequest StatusCode = 400
|
||||
// StatusForbidden - invalid origin policy, TLS required
|
||||
StatusForbidden StatusCode = 403
|
||||
// StatusUpgradeRequired - invalid WS version
|
||||
StatusUpgradeRequired StatusCode = 426
|
||||
// StatusNotFound - unserved or invalid URI
|
||||
StatusNotFound StatusCode = 404
|
||||
// StatusInternal - custom error
|
||||
StatusInternal StatusCode = 500
|
||||
)
|
||||
|
||||
// String implements the Stringer interface
|
||||
func (sc StatusCode) String() string {
|
||||
switch sc {
|
||||
case StatusSwitchingProtocols:
|
||||
return "Switching Protocols"
|
||||
case StatusBadRequest:
|
||||
return "Bad Request"
|
||||
case StatusForbidden:
|
||||
return "Forbidden"
|
||||
case StatusUpgradeRequired:
|
||||
return "Upgrade Required"
|
||||
case StatusNotFound:
|
||||
return "Not Found"
|
||||
case StatusInternal:
|
||||
return "Internal Server Error"
|
||||
default:
|
||||
return "Unknown Status Code"
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,319 @@
|
|||
package uri
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// === WILDCARDS ===
|
||||
//
|
||||
// The star '*' -> matches 0 or 1 slash-bounded string
|
||||
// The multi star '**' -> matches 0 or more slash-separated strings
|
||||
// The dot '.' -> matches 1 slash-bounded string
|
||||
// The multi dot '..' -> matches 1 or more slash-separated strings
|
||||
//
|
||||
// === SCHEME POLICY ===
|
||||
//
|
||||
// - The last '/' is optional
|
||||
// - Any '**' at the very end will match anything that starts with the given prefix
|
||||
//
|
||||
// === LIMITATIONS ==
|
||||
//
|
||||
// - A scheme must begin with '/'
|
||||
// - A scheme cannot contain something else than a STRING or WILDCARD between 2 '/' separators
|
||||
// - A scheme STRING cannot contain the symbols '/' as a character
|
||||
// - A scheme STRING containing '*' or '.' characters will be treating as STRING only
|
||||
// - A maximum of 16 slash-separated matchers (STRING or WILDCARD) are allowed
|
||||
|
||||
const maxMatch = 16
|
||||
|
||||
// Represents an URI matcher
|
||||
type matcher struct {
|
||||
pat string // pattern to match (empty if wildcard)
|
||||
req bool // whether it is required
|
||||
mul bool // whether multiple matches are allowed
|
||||
|
||||
buf []string // matched content (when matching)
|
||||
}
|
||||
|
||||
// Scheme represents an URI scheme
|
||||
type Scheme []*matcher
|
||||
|
||||
// FromString builds an URI scheme from a string pattern
|
||||
func FromString(s string) (*Scheme, error) {
|
||||
// handle '/' at the start
|
||||
if len(s) < 1 || s[0] != '/' {
|
||||
return nil, fmt.Errorf("invalid URI; must start with '/'")
|
||||
}
|
||||
|
||||
parts := strings.Split(s, "/")
|
||||
|
||||
// check max match size
|
||||
if len(parts)-2 > maxMatch {
|
||||
for i, p := range parts {
|
||||
fmt.Printf("%d: '%s'\n", i, p)
|
||||
}
|
||||
return nil, fmt.Errorf("URI must not exceed %d slash-separated components, got %d", maxMatch, len(parts))
|
||||
}
|
||||
|
||||
sch, err := buildScheme(parts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
opti, err := sch.optimise()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &opti, nil
|
||||
|
||||
}
|
||||
|
||||
// Match returns whether the given URI is matched by the scheme
|
||||
func (s Scheme) Match(uri string) bool {
|
||||
if len(s) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
// check for string match
|
||||
clearURI, match := s.matchString(uri)
|
||||
if !match {
|
||||
return false
|
||||
}
|
||||
|
||||
// check for non-string match (wildcards)
|
||||
return s.matchWildcards(clearURI)
|
||||
}
|
||||
|
||||
// GetMatch returns the indexed match (excluding string matchers)
|
||||
func (s Scheme) GetMatch(n uint8) ([]string, error) {
|
||||
if n > uint8(len(s)) {
|
||||
return nil, fmt.Errorf("index out of range")
|
||||
}
|
||||
|
||||
// iterate to find index (exclude strings)
|
||||
matches := -1
|
||||
for _, m := range s {
|
||||
if len(m.pat) > 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
matches++
|
||||
|
||||
// expected index -> return matches
|
||||
if uint8(matches) == n {
|
||||
return m.buf, nil
|
||||
}
|
||||
}
|
||||
|
||||
// nothing found -> return empty set
|
||||
return nil, fmt.Errorf("index out of range (max: %d)", matches)
|
||||
|
||||
}
|
||||
|
||||
// GetAllMatch returns all the indexed match (excluding string matchers)
|
||||
func (s Scheme) GetAllMatch() [][]string {
|
||||
match := make([][]string, 0, len(s))
|
||||
|
||||
for _, m := range s {
|
||||
if len(m.pat) > 0 {
|
||||
continue
|
||||
}
|
||||
match = append(match, m.buf)
|
||||
}
|
||||
return match
|
||||
}
|
||||
|
||||
// buildScheme builds a 'basic' scheme
|
||||
// from a pattern string
|
||||
func buildScheme(ss []string) (Scheme, error) {
|
||||
sch := make(Scheme, 0, maxMatch)
|
||||
|
||||
for _, s := range ss {
|
||||
if len(s) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
m := &matcher{}
|
||||
|
||||
switch s {
|
||||
|
||||
// card: 0, N
|
||||
case "**":
|
||||
m.req = false
|
||||
m.mul = true
|
||||
sch = append(sch, m)
|
||||
|
||||
// card: 1, N
|
||||
case "..":
|
||||
m.req = true
|
||||
m.mul = true
|
||||
sch = append(sch, m)
|
||||
|
||||
// card: 0, 1
|
||||
case "*":
|
||||
m.req = false
|
||||
m.mul = false
|
||||
sch = append(sch, m)
|
||||
|
||||
// card: 1
|
||||
case ".":
|
||||
m.req = true
|
||||
m.mul = false
|
||||
sch = append(sch, m)
|
||||
|
||||
// card: 1, literal string
|
||||
default:
|
||||
m.req = true
|
||||
m.mul = false
|
||||
m.pat = fmt.Sprintf("/%s", s)
|
||||
sch = append(sch, m)
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return sch, nil
|
||||
}
|
||||
|
||||
// optimise optimised the scheme for further parsing
|
||||
func (s Scheme) optimise() (Scheme, error) {
|
||||
if len(s) <= 1 {
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// init reshifted scheme
|
||||
rshift := make(Scheme, 0, maxMatch)
|
||||
rshift = append(rshift, s[0])
|
||||
|
||||
// iterate over matchers
|
||||
for p, i, l := 0, 1, len(s); i < l; i++ {
|
||||
|
||||
pre, cur := s[p], s[i]
|
||||
|
||||
// merge: 2 following literals
|
||||
if len(pre.pat) > 0 && len(cur.pat) > 0 {
|
||||
// merge strings into previous
|
||||
pre.pat = fmt.Sprintf("%s%s", pre.pat, cur.pat)
|
||||
|
||||
// delete current
|
||||
s[i] = nil
|
||||
}
|
||||
|
||||
// increment previous (only if current is not nul)
|
||||
if s[i] != nil {
|
||||
rshift = append(rshift, s[i])
|
||||
p = i
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return rshift, nil
|
||||
}
|
||||
|
||||
// matchString checks the STRING matchers from an URI
|
||||
// - returns a boolean : false when not matching, true eitherway
|
||||
// - returns a cleared uri, without STRING data
|
||||
func (s Scheme) matchString(uri string) (string, bool) {
|
||||
|
||||
var (
|
||||
clearedInput = uri
|
||||
minOffset = 0
|
||||
)
|
||||
|
||||
for _, m := range s {
|
||||
ls := len(m.pat)
|
||||
|
||||
// ignore no STRING match
|
||||
if ls == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
// get offset in URI (else -1)
|
||||
off := strings.Index(clearedInput, m.pat)
|
||||
if off < 0 {
|
||||
return "", false
|
||||
}
|
||||
|
||||
// fail on invalid offset range
|
||||
if off < minOffset {
|
||||
return "", false
|
||||
}
|
||||
|
||||
// check for trailing '/'
|
||||
hasSlash := 0
|
||||
if off+ls < len(clearedInput) && clearedInput[off+ls] == '/' {
|
||||
hasSlash = 1
|
||||
}
|
||||
|
||||
// remove the current string (+trailing slash) from the URI
|
||||
beg, end := clearedInput[:off], clearedInput[off+ls+hasSlash:]
|
||||
clearedInput = fmt.Sprintf("%s\a/%s", beg, end) // separate matches with a '\a' character
|
||||
|
||||
// update offset range
|
||||
// +2 slash separators
|
||||
// -1 because strings begin with 1 slash already
|
||||
minOffset = len(beg) + 2 - 1
|
||||
|
||||
}
|
||||
|
||||
// if exists, remove trailing '/'
|
||||
if clearedInput[len(clearedInput)-1] == '/' {
|
||||
clearedInput = clearedInput[:len(clearedInput)-1]
|
||||
}
|
||||
|
||||
// if exists, remove trailing '\a'
|
||||
if clearedInput[len(clearedInput)-1] == '\a' {
|
||||
clearedInput = clearedInput[:len(clearedInput)-1]
|
||||
}
|
||||
|
||||
return clearedInput, true
|
||||
}
|
||||
|
||||
// matchWildcards check the WILCARDS (non-string) matchers from
|
||||
// a cleared URI. it returns if the string matches
|
||||
// + it sets the matchers buffers for later extraction
|
||||
func (s Scheme) matchWildcards(clear string) bool {
|
||||
|
||||
// extract wildcards (ref)
|
||||
wildcards := make(Scheme, 0, maxMatch)
|
||||
|
||||
for _, m := range s {
|
||||
if len(m.pat) == 0 {
|
||||
m.buf = nil // flush buffers
|
||||
wildcards = append(wildcards, m)
|
||||
}
|
||||
}
|
||||
|
||||
if len(wildcards) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
// break uri by '\a' characters
|
||||
matches := strings.Split(clear, "\a")[1:]
|
||||
|
||||
for n, match := range matches {
|
||||
// no more matcher
|
||||
if n >= len(wildcards) {
|
||||
return false
|
||||
}
|
||||
|
||||
// from index 1 because it begins with '/'
|
||||
data := strings.Split(match, "/")[1:]
|
||||
|
||||
// missing required
|
||||
if wildcards[n].req && len(data) < 1 {
|
||||
return false
|
||||
}
|
||||
|
||||
// if not multi but got multi
|
||||
if !wildcards[n].mul && len(data) > 1 {
|
||||
return false
|
||||
}
|
||||
|
||||
wildcards[n].buf = data
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
|
@ -1,216 +0,0 @@
|
|||
package parser
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// buildScheme builds a 'basic' scheme
|
||||
// from a pattern string
|
||||
func buildScheme(ss []string) (Scheme, error) {
|
||||
|
||||
/* (1) Build scheme */
|
||||
sch := make(Scheme, 0, maxMatch)
|
||||
|
||||
for _, s := range ss {
|
||||
|
||||
/* (2) ignore empty */
|
||||
if len(s) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
m := new(matcher)
|
||||
|
||||
switch s {
|
||||
|
||||
/* (3) Card: 0, N */
|
||||
case "**":
|
||||
m.req = false
|
||||
m.mul = true
|
||||
sch = append(sch, m)
|
||||
|
||||
/* (4) Card: 1, N */
|
||||
case "..":
|
||||
m.req = true
|
||||
m.mul = true
|
||||
sch = append(sch, m)
|
||||
|
||||
/* (5) Card: 0, 1 */
|
||||
case "*":
|
||||
m.req = false
|
||||
m.mul = false
|
||||
sch = append(sch, m)
|
||||
|
||||
/* (6) Card: 1 */
|
||||
case ".":
|
||||
m.req = true
|
||||
m.mul = false
|
||||
sch = append(sch, m)
|
||||
|
||||
/* (7) Card: 1, literal string */
|
||||
default:
|
||||
m.req = true
|
||||
m.mul = false
|
||||
m.pat = fmt.Sprintf("/%s", s)
|
||||
sch = append(sch, m)
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return sch, nil
|
||||
}
|
||||
|
||||
// optimise optimised the scheme for further parsing
|
||||
func (s Scheme) optimise() (Scheme, error) {
|
||||
|
||||
/* (1) Nothing to do if only 1 element */
|
||||
if len(s) <= 1 {
|
||||
return s, nil
|
||||
}
|
||||
|
||||
/* (2) Init reshifted scheme */
|
||||
rshift := make(Scheme, 0, maxMatch)
|
||||
rshift = append(rshift, s[0])
|
||||
|
||||
/* (2) Iterate over matchers */
|
||||
for p, i, l := 0, 1, len(s); i < l; i++ {
|
||||
|
||||
pre, cur := s[p], s[i]
|
||||
|
||||
/* Merge: 2 following literals */
|
||||
if len(pre.pat) > 0 && len(cur.pat) > 0 {
|
||||
|
||||
// merge strings into previous
|
||||
pre.pat = fmt.Sprintf("%s%s", pre.pat, cur.pat)
|
||||
|
||||
// delete current
|
||||
s[i] = nil
|
||||
|
||||
}
|
||||
|
||||
// increment previous (only if current is not nul)
|
||||
if s[i] != nil {
|
||||
rshift = append(rshift, s[i])
|
||||
p = i
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return rshift, nil
|
||||
|
||||
}
|
||||
|
||||
// matchString checks the STRING matchers from an URI
|
||||
// it returns a boolean : false when not matching, true eitherway
|
||||
// it returns a cleared uri, without STRING data
|
||||
func (s Scheme) matchString(uri string) (string, bool) {
|
||||
|
||||
/* (1) Initialise variables */
|
||||
clr := uri // contains cleared input string
|
||||
minOff := 0 // minimum offset
|
||||
|
||||
/* (2) Iterate over strings */
|
||||
for _, m := range s {
|
||||
|
||||
ls := len(m.pat)
|
||||
|
||||
// {1} If not STRING matcher -> ignore //
|
||||
if ls == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
// {2} Get offset in URI (else -1) //
|
||||
off := strings.Index(clr, m.pat)
|
||||
if off < 0 {
|
||||
return "", false
|
||||
}
|
||||
|
||||
// {3} Fail on invalid offset range //
|
||||
if off < minOff {
|
||||
return "", false
|
||||
}
|
||||
|
||||
// {4} Check for trailing '/' //
|
||||
hasSlash := 0
|
||||
if off+ls < len(clr) && clr[off+ls] == '/' {
|
||||
hasSlash = 1
|
||||
}
|
||||
|
||||
// {5} Remove the current string (+trailing slash) from the URI //
|
||||
beg, end := clr[:off], clr[off+ls+hasSlash:]
|
||||
clr = fmt.Sprintf("%s\a/%s", beg, end) // separate matches by '\a' character
|
||||
|
||||
// {6} Update offset range //
|
||||
minOff = len(beg) + 2 - 1 // +2 slash separators
|
||||
// -1 because strings begin with 1 slash already
|
||||
|
||||
}
|
||||
|
||||
/* (3) If exists, remove trailing '/' */
|
||||
if clr[len(clr)-1] == '/' {
|
||||
clr = clr[:len(clr)-1]
|
||||
}
|
||||
|
||||
/* (4) If exists, remove trailing '\a' */
|
||||
if clr[len(clr)-1] == '\a' {
|
||||
clr = clr[:len(clr)-1]
|
||||
}
|
||||
|
||||
return clr, true
|
||||
|
||||
}
|
||||
|
||||
// matchWildcards check the WILCARDS (non-string) matchers from
|
||||
// a cleared URI. it returns if the string matches
|
||||
// + it sets the matchers buffers for later extraction
|
||||
func (s Scheme) matchWildcards(clear string) bool {
|
||||
|
||||
/* (1) Extract wildcards (ref) */
|
||||
wildcards := make(Scheme, 0, maxMatch)
|
||||
|
||||
for _, m := range s {
|
||||
if len(m.pat) == 0 {
|
||||
m.buf = nil // flush buffers
|
||||
wildcards = append(wildcards, m)
|
||||
}
|
||||
}
|
||||
|
||||
/* (2) If no wildcards -> match */
|
||||
if len(wildcards) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
/* (3) Break uri by '\a' characters */
|
||||
matches := strings.Split(clear, "\a")[1:]
|
||||
|
||||
/* (4) Iterate over matches */
|
||||
for n, match := range matches {
|
||||
|
||||
// {1} If no more matcher //
|
||||
if n >= len(wildcards) {
|
||||
return false
|
||||
}
|
||||
|
||||
// {2} Split by '/' //
|
||||
data := strings.Split(match, "/")[1:] // from index 1 because it begins with '/'
|
||||
|
||||
// {3} If required and missing //
|
||||
if wildcards[n].req && len(data) < 1 {
|
||||
return false
|
||||
}
|
||||
|
||||
// {4} If not multi but got multi //
|
||||
if !wildcards[n].mul && len(data) > 1 {
|
||||
return false
|
||||
}
|
||||
|
||||
// {5} Store data into matcher //
|
||||
wildcards[n].buf = data
|
||||
|
||||
}
|
||||
|
||||
/* (5) Match */
|
||||
return true
|
||||
|
||||
}
|
||||
|
|
@ -1,116 +0,0 @@
|
|||
package parser
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Build builds an URI scheme from a pattern string
|
||||
func Build(s string) (*Scheme, error) {
|
||||
|
||||
/* (1) Manage '/' at the start */
|
||||
if len(s) < 1 || s[0] != '/' {
|
||||
return nil, fmt.Errorf("URI must begin with '/'")
|
||||
}
|
||||
|
||||
/* (2) Split by '/' */
|
||||
parts := strings.Split(s, "/")
|
||||
|
||||
/* (3) Max exceeded */
|
||||
if len(parts)-2 > maxMatch {
|
||||
for i, p := range parts {
|
||||
fmt.Printf("%d: '%s'\n", i, p)
|
||||
}
|
||||
return nil, fmt.Errorf("URI must not exceed %d slash-separated components, got %d", maxMatch, len(parts))
|
||||
}
|
||||
|
||||
/* (4) Build for each part */
|
||||
sch, err := buildScheme(parts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
/* (5) Optimise structure */
|
||||
opti, err := sch.optimise()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &opti, nil
|
||||
|
||||
}
|
||||
|
||||
// Match returns if the given URI is matched by the scheme
|
||||
func (s Scheme) Match(str string) bool {
|
||||
|
||||
/* (1) Nothing -> match all */
|
||||
if len(s) == 0 {
|
||||
return true
|
||||
}
|
||||
|
||||
/* (2) Check for string match */
|
||||
clearURI, match := s.matchString(str)
|
||||
if !match {
|
||||
return false
|
||||
}
|
||||
|
||||
/* (3) Check for non-string match (wildcards) */
|
||||
match = s.matchWildcards(clearURI)
|
||||
if !match {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// GetMatch returns the indexed match (excluding string matchers)
|
||||
func (s Scheme) GetMatch(n uint8) ([]string, error) {
|
||||
|
||||
/* (1) Index out of range */
|
||||
if n > uint8(len(s)) {
|
||||
return nil, fmt.Errorf("Index out of range")
|
||||
}
|
||||
|
||||
/* (2) Iterate to find index (exclude strings) */
|
||||
ni := -1
|
||||
for _, m := range s {
|
||||
|
||||
// ignore strings
|
||||
if len(m.pat) > 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
// increment match counter : ni
|
||||
ni++
|
||||
|
||||
// if expected index -> return matches
|
||||
if uint8(ni) == n {
|
||||
return m.buf, nil
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* (3) If nothing found -> return empty set */
|
||||
return nil, fmt.Errorf("Index out of range (max: %d)", ni)
|
||||
|
||||
}
|
||||
|
||||
// GetAllMatch returns all the indexed match (excluding string matchers)
|
||||
func (s Scheme) GetAllMatch() [][]string {
|
||||
|
||||
match := make([][]string, 0, len(s))
|
||||
|
||||
for _, m := range s {
|
||||
|
||||
// ignore strings
|
||||
if len(m.pat) > 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
match = append(match, m.buf)
|
||||
|
||||
}
|
||||
|
||||
return match
|
||||
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
package parser
|
||||
|
||||
// === WILDCARDS ===
|
||||
//
|
||||
// The star '*' -> matches 0 or 1 slash-bounded string
|
||||
// The multi star '**' -> matches 0 or more slash-separated strings
|
||||
// The dot '.' -> matches 1 slash-bounded string
|
||||
// The multi dot '..' -> matches 1 or more slash-separated strings
|
||||
//
|
||||
// === SCHEME POLICY ===
|
||||
//
|
||||
// - The last '/' is optional
|
||||
// - Any '**' at the very end will match anything that starts with the given prefix
|
||||
//
|
||||
// === LIMITATIONS ==
|
||||
//
|
||||
// - A scheme must begin with '/'
|
||||
// - A scheme cannot contain something else than a STRING or WILDCARD between 2 '/' separators
|
||||
// - A scheme STRING cannot contain the symbols '/' as a character
|
||||
// - A scheme STRING containing '*' or '.' characters will be treating as STRING only
|
||||
// - A maximum of 16 slash-separated matchers (STRING or WILDCARD) are allowed
|
||||
|
||||
const maxMatch = 16
|
||||
|
||||
// Represents an URI matcher
|
||||
type matcher struct {
|
||||
pat string // pattern to match (empty if wildcard)
|
||||
req bool // whether it is required
|
||||
mul bool // whether multiple matches are allowed
|
||||
|
||||
buf []string // matched content (when matching)
|
||||
}
|
||||
|
||||
// Represents an URI scheme
|
||||
type Scheme []*matcher
|
||||
219
message.go
219
message.go
|
|
@ -2,52 +2,81 @@ package websocket
|
|||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
var ErrUnmaskedFrame = fmt.Errorf("Received unmasked frame")
|
||||
var ErrTooLongControlFrame = fmt.Errorf("Received a control frame that is fragmented or too long")
|
||||
var ErrInvalidFragment = fmt.Errorf("Received invalid fragmentation")
|
||||
var ErrUnexpectedContinuation = fmt.Errorf("Received unexpected continuation frame")
|
||||
var ErrInvalidSize = fmt.Errorf("Received invalid payload size")
|
||||
var ErrInvalidPayload = fmt.Errorf("Received invalid utf8 payload")
|
||||
var ErrInvalidCloseStatus = fmt.Errorf("Received invalid close status")
|
||||
var ErrInvalidOpCode = fmt.Errorf("Received invalid OpCode")
|
||||
var ErrReservedBits = fmt.Errorf("Received reserved bits")
|
||||
var CloseFrame = fmt.Errorf("Received close Frame")
|
||||
// constant error
|
||||
type constErr string
|
||||
|
||||
func (c constErr) Error() string { return string(c) }
|
||||
|
||||
const (
|
||||
// ErrUnmaskedFrame error
|
||||
ErrUnmaskedFrame constErr = "Received unmasked frame"
|
||||
// ErrTooLongControlFrame error
|
||||
ErrTooLongControlFrame constErr = "Received a control frame that is fragmented or too long"
|
||||
// ErrInvalidFragment error
|
||||
ErrInvalidFragment constErr = "Received invalid fragmentation"
|
||||
// ErrUnexpectedContinuation error
|
||||
ErrUnexpectedContinuation constErr = "Received unexpected continuation frame"
|
||||
// ErrInvalidSize error
|
||||
ErrInvalidSize constErr = "Received invalid payload size"
|
||||
// ErrInvalidPayload error
|
||||
ErrInvalidPayload constErr = "Received invalid utf8 payload"
|
||||
// ErrInvalidCloseStatus error
|
||||
ErrInvalidCloseStatus constErr = "Received invalid close status"
|
||||
// ErrInvalidOpCode error
|
||||
ErrInvalidOpCode constErr = "Received invalid OpCode"
|
||||
// ErrReservedBits error
|
||||
ErrReservedBits constErr = "Received reserved bits"
|
||||
// ErrCloseFrame error
|
||||
ErrCloseFrame constErr = "Received close Frame"
|
||||
)
|
||||
|
||||
// Maximum Header Size = Final/OpCode + isMask/Length + Length + Mask
|
||||
const maximumHeaderSize = 1 + 1 + 8 + 4
|
||||
const maxWriteChunk = 0x7fff
|
||||
|
||||
// Lists websocket close status
|
||||
// MessageError lists websocket close statuses
|
||||
type MessageError uint16
|
||||
|
||||
const (
|
||||
NONE MessageError = 0
|
||||
NORMAL MessageError = 1000
|
||||
GOING_AWAY MessageError = 1001
|
||||
PROTOCOL_ERR MessageError = 1002
|
||||
UNACCEPTABLE_OPCODE MessageError = 1003
|
||||
INVALID_PAYLOAD MessageError = 1007 // utf8
|
||||
MESSAGE_TOO_LARGE MessageError = 1009
|
||||
// None used when there is no error
|
||||
None MessageError = 0
|
||||
// Normal error
|
||||
Normal MessageError = 1000
|
||||
// GoingAway error
|
||||
GoingAway MessageError = 1001
|
||||
// ProtocolError error
|
||||
ProtocolError MessageError = 1002
|
||||
// UnacceptableOpCode error
|
||||
UnacceptableOpCode MessageError = 1003
|
||||
// InvalidPayload error
|
||||
InvalidPayload MessageError = 1007 // utf8
|
||||
// MessageTooLarge error
|
||||
MessageTooLarge MessageError = 1009
|
||||
)
|
||||
|
||||
// Lists websocket message types
|
||||
// MessageType lists websocket message types
|
||||
type MessageType byte
|
||||
|
||||
const (
|
||||
CONTINUATION MessageType = 0x00
|
||||
TEXT MessageType = 0x01
|
||||
BINARY MessageType = 0x02
|
||||
CLOSE MessageType = 0x08
|
||||
PING MessageType = 0x09
|
||||
PONG MessageType = 0x0a
|
||||
// Continuation message type
|
||||
Continuation MessageType = 0x00
|
||||
// Text message type
|
||||
Text MessageType = 0x01
|
||||
// Binary message type
|
||||
Binary MessageType = 0x02
|
||||
// Close message type
|
||||
Close MessageType = 0x08
|
||||
// Ping message type
|
||||
Ping MessageType = 0x09
|
||||
// Pong message type
|
||||
Pong MessageType = 0x0a
|
||||
)
|
||||
|
||||
// Represents a websocket message
|
||||
// Message is a websocket message
|
||||
type Message struct {
|
||||
Final bool
|
||||
Type MessageType
|
||||
|
|
@ -55,36 +84,40 @@ type Message struct {
|
|||
Data []byte
|
||||
}
|
||||
|
||||
// receive reads a message form reader
|
||||
func readMessage(reader io.Reader) (*Message, error) {
|
||||
// ReadFrom reads a message from a reader
|
||||
//
|
||||
// implements io.ReaderFrom
|
||||
func (m *Message) ReadFrom(reader io.Reader) (int64, error) {
|
||||
var (
|
||||
read int64
|
||||
err error
|
||||
tmpBuf []byte
|
||||
mask []byte
|
||||
cursor int
|
||||
)
|
||||
|
||||
var err error
|
||||
var tmpBuf []byte
|
||||
var mask []byte
|
||||
var cursor int
|
||||
|
||||
m := new(Message)
|
||||
|
||||
/* (2) Byte 1: FIN and OpCode */
|
||||
// byte 1: FIN and OpCode
|
||||
tmpBuf = make([]byte, 1)
|
||||
read += int64(len(tmpBuf))
|
||||
err = readBytes(reader, tmpBuf)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read, err
|
||||
}
|
||||
|
||||
// check reserved bits
|
||||
if tmpBuf[0]&0x70 != 0 {
|
||||
return m, ErrReservedBits
|
||||
return read, ErrReservedBits
|
||||
}
|
||||
|
||||
m.Final = bool(tmpBuf[0]&0x80 == 0x80)
|
||||
m.Type = MessageType(tmpBuf[0] & 0x0f)
|
||||
|
||||
/* (3) Byte 2: Mask and Length[0] */
|
||||
// byte 2: mask and length[0]
|
||||
tmpBuf = make([]byte, 1)
|
||||
read += int64(len(tmpBuf))
|
||||
err = readBytes(reader, tmpBuf)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read, err
|
||||
}
|
||||
|
||||
// if mask, byte array not nil
|
||||
|
|
@ -95,71 +128,63 @@ func readMessage(reader io.Reader) (*Message, error) {
|
|||
// payload length
|
||||
m.Size = uint(tmpBuf[0] & 0x7f)
|
||||
|
||||
/* (4) Extended payload */
|
||||
// extended payload
|
||||
if m.Size == 127 {
|
||||
|
||||
tmpBuf = make([]byte, 8)
|
||||
read += int64(len(tmpBuf))
|
||||
err := readBytes(reader, tmpBuf)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read, err
|
||||
}
|
||||
|
||||
m.Size = uint(binary.BigEndian.Uint64(tmpBuf))
|
||||
|
||||
} else if m.Size == 126 {
|
||||
|
||||
tmpBuf = make([]byte, 2)
|
||||
read += int64(len(tmpBuf))
|
||||
err := readBytes(reader, tmpBuf)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read, err
|
||||
}
|
||||
|
||||
m.Size = uint(binary.BigEndian.Uint16(tmpBuf))
|
||||
|
||||
}
|
||||
|
||||
/* (5) Masking key */
|
||||
// masking key
|
||||
if mask != nil {
|
||||
|
||||
tmpBuf = make([]byte, 4)
|
||||
read += int64(len(tmpBuf))
|
||||
err := readBytes(reader, tmpBuf)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read, err
|
||||
}
|
||||
|
||||
mask = make([]byte, 4)
|
||||
copy(mask, tmpBuf)
|
||||
|
||||
}
|
||||
|
||||
/* (6) Read payload by chunks */
|
||||
// read payload by chunks
|
||||
m.Data = make([]byte, int(m.Size))
|
||||
|
||||
cursor = 0
|
||||
|
||||
// {1} While we have data to read //
|
||||
// while data to read
|
||||
for uint(cursor) < m.Size {
|
||||
|
||||
// {2} Try to read (at least 1 byte) //
|
||||
// try to read (at least 1 byte)
|
||||
nbread, err := io.ReadAtLeast(reader, m.Data[cursor:m.Size], 1)
|
||||
if err != nil {
|
||||
return m, err
|
||||
return read + int64(cursor) + int64(nbread), err
|
||||
}
|
||||
|
||||
// {3} Unmask data //
|
||||
// unmask data //
|
||||
if mask != nil {
|
||||
for i, l := cursor, cursor+nbread; i < l; i++ {
|
||||
|
||||
mi := i % 4 // mask index
|
||||
m.Data[i] = m.Data[i] ^ mask[mi]
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// {4} Update cursor //
|
||||
cursor += nbread
|
||||
|
||||
}
|
||||
read += int64(cursor)
|
||||
|
||||
// return error if unmasked frame
|
||||
// we have to fully read it for read buffer to be clean
|
||||
|
|
@ -168,13 +193,14 @@ func readMessage(reader io.Reader) (*Message, error) {
|
|||
err = ErrUnmaskedFrame
|
||||
}
|
||||
|
||||
return m, err
|
||||
return read, err
|
||||
|
||||
}
|
||||
|
||||
// Send sends a frame over a socket
|
||||
func (m Message) Send(writer io.Writer) error {
|
||||
|
||||
// WriteTo writes a message frame over a socket
|
||||
//
|
||||
// implements io.WriterTo
|
||||
func (m Message) WriteTo(writer io.Writer) (int64, error) {
|
||||
header := make([]byte, 0, maximumHeaderSize)
|
||||
|
||||
// fix size
|
||||
|
|
@ -182,20 +208,18 @@ func (m Message) Send(writer io.Writer) error {
|
|||
m.Size = uint(len(m.Data))
|
||||
}
|
||||
|
||||
/* (1) Byte 0 : FIN + opcode */
|
||||
// byte 0 : FIN + opcode
|
||||
var final byte = 0x80
|
||||
if !m.Final {
|
||||
final = 0
|
||||
}
|
||||
header = append(header, final|byte(m.Type))
|
||||
|
||||
/* (2) Get payload length */
|
||||
// get payload length
|
||||
if m.Size < 126 { // simple
|
||||
|
||||
header = append(header, byte(m.Size))
|
||||
|
||||
} else if m.Size <= 0xffff { // extended: 16 bits
|
||||
|
||||
header = append(header, 126)
|
||||
|
||||
buf := make([]byte, 2)
|
||||
|
|
@ -203,7 +227,6 @@ func (m Message) Send(writer io.Writer) error {
|
|||
header = append(header, buf...)
|
||||
|
||||
} else if m.Size <= 0xffffffffffffffff { // extended: 64 bits
|
||||
|
||||
header = append(header, 127)
|
||||
|
||||
buf := make([]byte, 8)
|
||||
|
|
@ -212,16 +235,15 @@ func (m Message) Send(writer io.Writer) error {
|
|||
|
||||
}
|
||||
|
||||
/* (3) Build write buffer */
|
||||
// build write buffer
|
||||
writeBuf := make([]byte, 0, len(header)+int(m.Size))
|
||||
writeBuf = append(writeBuf, header...)
|
||||
writeBuf = append(writeBuf, m.Data[0:m.Size]...)
|
||||
|
||||
/* (4) Send over socket by chunks */
|
||||
// write by chunks
|
||||
toWrite := len(header) + int(m.Size)
|
||||
cursor := 0
|
||||
for cursor < toWrite {
|
||||
|
||||
maxBoundary := cursor + maxWriteChunk
|
||||
if maxBoundary > toWrite {
|
||||
maxBoundary = toWrite
|
||||
|
|
@ -230,56 +252,54 @@ func (m Message) Send(writer io.Writer) error {
|
|||
// Try to wrote (at max 1024 bytes) //
|
||||
nbwritten, err := writer.Write(writeBuf[cursor:maxBoundary])
|
||||
if err != nil {
|
||||
return err
|
||||
return int64(nbwritten), err
|
||||
}
|
||||
|
||||
// Update cursor //
|
||||
cursor += nbwritten
|
||||
|
||||
}
|
||||
|
||||
return nil
|
||||
return int64(cursor), nil
|
||||
}
|
||||
|
||||
// Check for message errors with:
|
||||
// check for message errors with:
|
||||
// (m) the current message
|
||||
// (fragment) whether there is a fragment in construction
|
||||
// returns the message error
|
||||
func (m *Message) check(fragment bool) error {
|
||||
|
||||
/* (1) Invalid first fragment (not TEXT nor BINARY) */
|
||||
if !m.Final && !fragment && m.Type != TEXT && m.Type != BINARY {
|
||||
// invalid first fragment (not TEXT nor BINARY)
|
||||
if !m.Final && !fragment && m.Type != Text && m.Type != Binary {
|
||||
return ErrInvalidFragment
|
||||
}
|
||||
|
||||
/* (2) Waiting fragment but received standalone frame */
|
||||
if fragment && m.Type != CONTINUATION && m.Type != CLOSE && m.Type != PING && m.Type != PONG {
|
||||
// waiting fragment but received standalone frame
|
||||
if fragment && m.Type != Continuation && m.Type != Close && m.Type != Ping && m.Type != Pong {
|
||||
return ErrInvalidFragment
|
||||
}
|
||||
|
||||
/* (3) Control frame too long */
|
||||
if (m.Type == CLOSE || m.Type == PING || m.Type == PONG) && (m.Size > 125 || !m.Final) {
|
||||
// control frame too long
|
||||
if (m.Type == Close || m.Type == Ping || m.Type == Pong) && (m.Size > 125 || !m.Final) {
|
||||
return ErrTooLongControlFrame
|
||||
}
|
||||
|
||||
switch m.Type {
|
||||
case CONTINUATION:
|
||||
case Continuation:
|
||||
// unexpected continuation
|
||||
if !fragment {
|
||||
return ErrUnexpectedContinuation
|
||||
}
|
||||
return nil
|
||||
|
||||
case TEXT:
|
||||
case Text:
|
||||
if m.Final && !utf8.Valid(m.Data) {
|
||||
return ErrInvalidPayload
|
||||
}
|
||||
return nil
|
||||
|
||||
case BINARY:
|
||||
case Binary:
|
||||
return nil
|
||||
|
||||
case CLOSE:
|
||||
case Close:
|
||||
// incomplete code
|
||||
if m.Size == 1 {
|
||||
return ErrInvalidCloseStatus
|
||||
|
|
@ -298,20 +318,18 @@ func (m *Message) check(fragment bool) error {
|
|||
return ErrInvalidCloseStatus
|
||||
}
|
||||
}
|
||||
return CloseFrame
|
||||
return ErrCloseFrame
|
||||
|
||||
case PING:
|
||||
case Ping:
|
||||
return nil
|
||||
|
||||
case PONG:
|
||||
case Pong:
|
||||
return nil
|
||||
|
||||
default:
|
||||
return ErrInvalidOpCode
|
||||
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// readBytes reads from a reader into a byte array
|
||||
|
|
@ -320,20 +338,19 @@ func (m *Message) check(fragment bool) error {
|
|||
//
|
||||
// It manages connections which chunks data
|
||||
func readBytes(reader io.Reader, buffer []byte) error {
|
||||
var (
|
||||
cur = 0
|
||||
len = len(buffer)
|
||||
)
|
||||
|
||||
var cur, len int = 0, len(buffer)
|
||||
|
||||
// try to read until the full size is read
|
||||
// read until the full size is read
|
||||
for cur < len {
|
||||
|
||||
nbread, err := reader.Read(buffer[cur:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
cur += nbread
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
|
|
|||
188
message_test.go
188
message_test.go
|
|
@ -41,25 +41,25 @@ func TestSimpleMessageReading(t *testing.T) {
|
|||
{ // FIN ; TEXT ; hello
|
||||
"simple hello text message",
|
||||
[]byte{0x81, 0x85, 0x00, 0x00, 0x00, 0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f},
|
||||
Message{true, TEXT, 5, []byte("hello")},
|
||||
Message{true, Text, 5, []byte("hello")},
|
||||
nil,
|
||||
},
|
||||
{ // FIN ; BINARY ; hello
|
||||
"simple hello binary message",
|
||||
[]byte{0x82, 0x85, 0x00, 0x00, 0x00, 0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f},
|
||||
Message{true, BINARY, 5, []byte("hello")},
|
||||
Message{true, Binary, 5, []byte("hello")},
|
||||
nil,
|
||||
},
|
||||
{ // FIN ; BINARY ; test unmasking
|
||||
"unmasking test",
|
||||
[]byte{0x82, 0x88, 0x01, 0x02, 0x03, 0x04, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80},
|
||||
Message{true, BINARY, 8, []byte{0x11, 0x22, 0x33, 0x44, 0x51, 0x62, 0x73, 0x84}},
|
||||
Message{true, Binary, 8, []byte{0x11, 0x22, 0x33, 0x44, 0x51, 0x62, 0x73, 0x84}},
|
||||
nil,
|
||||
},
|
||||
{ // FIN=0 ; TEXT ;
|
||||
"non final frame",
|
||||
[]byte{0x01, 0x82, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02},
|
||||
Message{false, TEXT, 2, []byte{0x01, 0x02}},
|
||||
Message{false, Text, 2, []byte{0x01, 0x02}},
|
||||
nil,
|
||||
},
|
||||
}
|
||||
|
|
@ -67,11 +67,12 @@ func TestSimpleMessageReading(t *testing.T) {
|
|||
for _, tc := range cases {
|
||||
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
var (
|
||||
reader = bytes.NewBuffer(tc.ReadBuffer)
|
||||
msg = &Message{}
|
||||
)
|
||||
|
||||
reader := bytes.NewBuffer(tc.ReadBuffer)
|
||||
|
||||
got, err := readMessage(reader)
|
||||
|
||||
_, err := msg.ReadFrom(reader)
|
||||
if err != tc.Err {
|
||||
t.Errorf("Expected %v error, got %v", tc.Err, err)
|
||||
}
|
||||
|
|
@ -82,23 +83,23 @@ func TestSimpleMessageReading(t *testing.T) {
|
|||
}
|
||||
|
||||
// check FIN
|
||||
if got.Final != tc.Expected.Final {
|
||||
t.Errorf("Expected FIN=%t, got %t", tc.Expected.Final, got.Final)
|
||||
if msg.Final != tc.Expected.Final {
|
||||
t.Errorf("Expected FIN=%t, got %t", tc.Expected.Final, msg.Final)
|
||||
}
|
||||
|
||||
// check OpCode
|
||||
if got.Type != tc.Expected.Type {
|
||||
t.Errorf("Expected TYPE=%x, got %x", tc.Expected.Type, got.Type)
|
||||
if msg.Type != tc.Expected.Type {
|
||||
t.Errorf("Expected TYPE=%x, got %x", tc.Expected.Type, msg.Type)
|
||||
}
|
||||
|
||||
// check Size
|
||||
if got.Size != tc.Expected.Size {
|
||||
t.Errorf("Expected SIZE=%d, got %d", tc.Expected.Size, got.Size)
|
||||
if msg.Size != tc.Expected.Size {
|
||||
t.Errorf("Expected SIZE=%d, got %d", tc.Expected.Size, msg.Size)
|
||||
}
|
||||
|
||||
// check Data
|
||||
if string(got.Data) != string(tc.Expected.Data) {
|
||||
t.Errorf("Expected Data='%s', got '%d'", tc.Expected.Data, got.Data)
|
||||
if string(msg.Data) != string(tc.Expected.Data) {
|
||||
t.Errorf("Expected Data='%s', got '%d'", tc.Expected.Data, msg.Data)
|
||||
}
|
||||
|
||||
})
|
||||
|
|
@ -177,17 +178,15 @@ func TestReadEOF(t *testing.T) {
|
|||
for _, tc := range cases {
|
||||
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
|
||||
reader := bytes.NewBuffer(tc.ReadBuffer)
|
||||
|
||||
got, err := readMessage(reader)
|
||||
|
||||
var (
|
||||
reader = bytes.NewBuffer(tc.ReadBuffer)
|
||||
msg = &Message{}
|
||||
)
|
||||
_, err := msg.ReadFrom(reader)
|
||||
if tc.eof {
|
||||
|
||||
if err != io.EOF {
|
||||
t.Errorf("Expected EOF, got %v", err)
|
||||
t.Fatalf("Expected EOF, got %v", err)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -195,8 +194,8 @@ func TestReadEOF(t *testing.T) {
|
|||
t.Errorf("Expected UnmaskedFrameor, got %v", err)
|
||||
}
|
||||
|
||||
if got.Size != 0x00 {
|
||||
t.Errorf("Expected a size of 0, got %d", got.Size)
|
||||
if msg.Size != 0x00 {
|
||||
t.Errorf("Expected a size of 0, got %d", msg.Size)
|
||||
}
|
||||
|
||||
})
|
||||
|
|
@ -222,43 +221,43 @@ func TestSimpleMessageSending(t *testing.T) {
|
|||
}{
|
||||
{
|
||||
"simple hello text message",
|
||||
Message{true, TEXT, 5, []byte("hello")},
|
||||
Message{true, Text, 5, []byte("hello")},
|
||||
[]byte{0x81, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f},
|
||||
}, {
|
||||
"simple hello binary message",
|
||||
Message{true, BINARY, 5, []byte("hello")},
|
||||
Message{true, Binary, 5, []byte("hello")},
|
||||
[]byte{0x82, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f},
|
||||
}, {
|
||||
"other simple binary message",
|
||||
Message{true, BINARY, 8, []byte{0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80}},
|
||||
Message{true, Binary, 8, []byte{0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80}},
|
||||
[]byte{0x82, 0x08, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80},
|
||||
}, {
|
||||
"non final frame",
|
||||
Message{false, TEXT, 2, []byte{0x01, 0x02}},
|
||||
Message{false, Text, 2, []byte{0x01, 0x02}},
|
||||
[]byte{0x01, 0x02, 0x01, 0x02},
|
||||
}, {
|
||||
"125 > normal length",
|
||||
Message{true, TEXT, uint(len(m4b1)), m4b1},
|
||||
Message{true, Text, uint(len(m4b1)), m4b1},
|
||||
append([]byte{0x81, 0x7e - 1}, m4b1...),
|
||||
}, {
|
||||
"126 > extended 16 bits length",
|
||||
Message{true, TEXT, uint(len(m4b2)), m4b2},
|
||||
Message{true, Text, uint(len(m4b2)), m4b2},
|
||||
append([]byte{0x81, 126, 0x00, 0x7e}, m4b2...),
|
||||
}, {
|
||||
"127 > extended 16 bits length",
|
||||
Message{true, TEXT, uint(len(m4b3)), m4b3},
|
||||
Message{true, Text, uint(len(m4b3)), m4b3},
|
||||
append([]byte{0x81, 126, 0x00, 0x7e + 1}, m4b3...),
|
||||
}, {
|
||||
"fffe > extended 16 bits length",
|
||||
Message{true, TEXT, uint(len(m16b1)), m16b1},
|
||||
Message{true, Text, uint(len(m16b1)), m16b1},
|
||||
append([]byte{0x81, 126, 0xff, 0xfe}, m16b1...),
|
||||
}, {
|
||||
"ffff > extended 16 bits length",
|
||||
Message{true, TEXT, uint(len(m16b2)), m16b2},
|
||||
Message{true, Text, uint(len(m16b2)), m16b2},
|
||||
append([]byte{0x81, 126, 0xff, 0xff}, m16b2...),
|
||||
}, {
|
||||
"10000 > extended 64 bits length",
|
||||
Message{true, TEXT, uint(len(m16b3)), m16b3},
|
||||
Message{true, Text, uint(len(m16b3)), m16b3},
|
||||
append([]byte{0x81, 127, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}, m16b3...),
|
||||
},
|
||||
}
|
||||
|
|
@ -267,10 +266,9 @@ func TestSimpleMessageSending(t *testing.T) {
|
|||
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
|
||||
writer := new(bytes.Buffer)
|
||||
|
||||
err := tc.Base.Send(writer)
|
||||
writer := &bytes.Buffer{}
|
||||
|
||||
_, err := tc.Base.WriteTo(writer)
|
||||
if err != nil {
|
||||
t.Errorf("expected no error, got %v", err)
|
||||
return
|
||||
|
|
@ -305,22 +303,22 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CONTINUATION must fail",
|
||||
Message{false, CONTINUATION, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Continuation, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"TEXT must not fail",
|
||||
Message{false, TEXT, 0, []byte{}}, false, nil,
|
||||
Message{false, Text, 0, []byte{}}, false, nil,
|
||||
}, {
|
||||
"BINARY must not fail",
|
||||
Message{false, BINARY, 0, []byte{}}, false, nil,
|
||||
Message{false, Binary, 0, []byte{}}, false, nil,
|
||||
}, {
|
||||
"CLOSE must fail",
|
||||
Message{false, CLOSE, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Close, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"PING must fail",
|
||||
Message{false, PING, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Ping, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"PONG must fail",
|
||||
Message{false, PONG, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Pong, 0, []byte{}}, false, ErrInvalidFragment,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -328,22 +326,22 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CONTINUATION must not fail",
|
||||
Message{true, CONTINUATION, 0, []byte{}}, true, nil,
|
||||
Message{true, Continuation, 0, []byte{}}, true, nil,
|
||||
}, {
|
||||
"TEXT must fail",
|
||||
Message{true, TEXT, 0, []byte{}}, true, ErrInvalidFragment,
|
||||
Message{true, Text, 0, []byte{}}, true, ErrInvalidFragment,
|
||||
}, {
|
||||
"BINARY must fail",
|
||||
Message{true, BINARY, 0, []byte{}}, true, ErrInvalidFragment,
|
||||
Message{true, Binary, 0, []byte{}}, true, ErrInvalidFragment,
|
||||
}, {
|
||||
"CLOSE must not fail",
|
||||
Message{true, CLOSE, 0, []byte{}}, true, CloseFrame,
|
||||
Message{true, Close, 0, []byte{}}, true, ErrCloseFrame,
|
||||
}, {
|
||||
"PING must not fail",
|
||||
Message{true, PING, 0, []byte{}}, true, nil,
|
||||
Message{true, Ping, 0, []byte{}}, true, nil,
|
||||
}, {
|
||||
"PONG must not fail",
|
||||
Message{true, PONG, 0, []byte{}}, true, nil,
|
||||
Message{true, Pong, 0, []byte{}}, true, nil,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -351,13 +349,13 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CLOSE must not fail",
|
||||
Message{true, CLOSE, 125, []byte{0x03, 0xe8, 0}}, false, CloseFrame,
|
||||
Message{true, Close, 125, []byte{0x03, 0xe8, 0}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"PING must not fail",
|
||||
Message{true, PING, 125, []byte{}}, false, nil,
|
||||
Message{true, Ping, 125, []byte{}}, false, nil,
|
||||
}, {
|
||||
"PONG must not fail",
|
||||
Message{true, PONG, 125, []byte{}}, false, nil,
|
||||
Message{true, Pong, 125, []byte{}}, false, nil,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -365,13 +363,13 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CLOSE must fail",
|
||||
Message{true, CLOSE, 126, []byte{0x03, 0xe8, 0}}, false, ErrTooLongControlFrame,
|
||||
Message{true, Close, 126, []byte{0x03, 0xe8, 0}}, false, ErrTooLongControlFrame,
|
||||
}, {
|
||||
"PING must fail",
|
||||
Message{true, PING, 126, []byte{}}, false, ErrTooLongControlFrame,
|
||||
Message{true, Ping, 126, []byte{}}, false, ErrTooLongControlFrame,
|
||||
}, {
|
||||
"PONG must fail",
|
||||
Message{true, PONG, 126, []byte{}}, false, ErrTooLongControlFrame,
|
||||
Message{true, Pong, 126, []byte{}}, false, ErrTooLongControlFrame,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -379,13 +377,13 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CLOSE must fail",
|
||||
Message{false, CLOSE, 126, []byte{0x03, 0xe8, 0}}, false, ErrInvalidFragment,
|
||||
Message{false, Close, 126, []byte{0x03, 0xe8, 0}}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"PING must fail",
|
||||
Message{false, PING, 126, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Ping, 126, []byte{}}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"PONG must fail",
|
||||
Message{false, PONG, 126, []byte{}}, false, ErrInvalidFragment,
|
||||
Message{false, Pong, 126, []byte{}}, false, ErrInvalidFragment,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -393,10 +391,10 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"no waiting fragment final",
|
||||
Message{false, CONTINUATION, 126, nil}, false, ErrInvalidFragment,
|
||||
Message{false, Continuation, 126, nil}, false, ErrInvalidFragment,
|
||||
}, {
|
||||
"no waiting fragment non-final",
|
||||
Message{true, CONTINUATION, 126, nil}, false, ErrUnexpectedContinuation,
|
||||
Message{true, Continuation, 126, nil}, false, ErrUnexpectedContinuation,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -404,23 +402,23 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CLOSE valid reason",
|
||||
Message{true, CLOSE, 5, []byte{0x03, 0xe8, 0xe2, 0x82, 0xa1}}, false, CloseFrame,
|
||||
Message{true, Close, 5, []byte{0x03, 0xe8, 0xe2, 0x82, 0xa1}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"CLOSE invalid reason byte 2",
|
||||
Message{true, CLOSE, 5, []byte{0x03, 0xe8, 0xe2, 0x28, 0xa1}}, false, ErrInvalidPayload,
|
||||
Message{true, Close, 5, []byte{0x03, 0xe8, 0xe2, 0x28, 0xa1}}, false, ErrInvalidPayload,
|
||||
}, {
|
||||
"CLOSE invalid reason byte 3",
|
||||
Message{true, CLOSE, 5, []byte{0x03, 0xe8, 0xe2, 0x82, 0x28}}, false, ErrInvalidPayload,
|
||||
Message{true, Close, 5, []byte{0x03, 0xe8, 0xe2, 0x82, 0x28}}, false, ErrInvalidPayload,
|
||||
},
|
||||
{
|
||||
"TEXT valid reason",
|
||||
Message{true, TEXT, 3, []byte{0xe2, 0x82, 0xa1}}, false, nil,
|
||||
Message{true, Text, 3, []byte{0xe2, 0x82, 0xa1}}, false, nil,
|
||||
}, {
|
||||
"TEXT invalid reason byte 2",
|
||||
Message{true, TEXT, 3, []byte{0xe2, 0x28, 0xa1}}, false, ErrInvalidPayload,
|
||||
Message{true, Text, 3, []byte{0xe2, 0x28, 0xa1}}, false, ErrInvalidPayload,
|
||||
}, {
|
||||
"TEXT invalid reason byte 3",
|
||||
Message{true, TEXT, 3, []byte{0xe2, 0x82, 0x28}}, false, ErrInvalidPayload,
|
||||
Message{true, Text, 3, []byte{0xe2, 0x82, 0x28}}, false, ErrInvalidPayload,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -428,82 +426,82 @@ func TestMessageCheck(t *testing.T) {
|
|||
Cases: []Case{
|
||||
{
|
||||
"CLOSE only 1 byte",
|
||||
Message{true, CLOSE, 1, []byte{0x03}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 1, []byte{0x03}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 1000",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xe8}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xe8}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 999 under 1000",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xe7}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xe7}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 1001",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xe9}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xe9}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 1002",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xea}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xea}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 1003",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xeb}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xeb}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 1004",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xec}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xec}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1005",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xed}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xed}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1006",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xee}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xee}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 1007",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xef}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xef}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 1011",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf3}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf3}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 1012",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf4}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf4}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1013",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf5}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf5}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1014",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf6}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf6}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1015",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf7}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf7}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"invalid CLOSE status 1016",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf8}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf8}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 1017",
|
||||
Message{true, CLOSE, 2, []byte{0x03, 0xf9}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x03, 0xf9}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 1099",
|
||||
Message{true, CLOSE, 2, []byte{0x04, 0x4b}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x04, 0x4b}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 1100",
|
||||
Message{true, CLOSE, 2, []byte{0x04, 0x4c}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x04, 0x4c}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 1101",
|
||||
Message{true, CLOSE, 2, []byte{0x04, 0x4d}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x04, 0x4d}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 1999",
|
||||
Message{true, CLOSE, 2, []byte{0x07, 0xcf}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x07, 0xcf}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 2000",
|
||||
Message{true, CLOSE, 2, []byte{0x07, 0xd0}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x07, 0xd0}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 2001",
|
||||
Message{true, CLOSE, 2, []byte{0x07, 0xd1}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x07, 0xd1}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"valid CLOSE status 2998",
|
||||
Message{true, CLOSE, 2, []byte{0x0b, 0xb6}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x0b, 0xb6}}, false, ErrCloseFrame,
|
||||
}, {
|
||||
"invalid CLOSE status 2999",
|
||||
Message{true, CLOSE, 2, []byte{0x0b, 0xb7}}, false, ErrInvalidCloseStatus,
|
||||
Message{true, Close, 2, []byte{0x0b, 0xb7}}, false, ErrInvalidCloseStatus,
|
||||
}, {
|
||||
"valid CLOSE status 3000",
|
||||
Message{true, CLOSE, 2, []byte{0x0b, 0xb8}}, false, CloseFrame,
|
||||
Message{true, Close, 2, []byte{0x0b, 0xb8}}, false, ErrCloseFrame,
|
||||
},
|
||||
},
|
||||
}, {
|
||||
|
|
@ -517,7 +515,7 @@ func TestMessageCheck(t *testing.T) {
|
|||
{"5", Message{true, 5, 0, []byte{}}, false, ErrInvalidOpCode},
|
||||
{"6", Message{true, 6, 0, []byte{}}, false, ErrInvalidOpCode},
|
||||
{"7", Message{true, 7, 0, []byte{}}, false, ErrInvalidOpCode},
|
||||
{"8", Message{true, 8, 0, []byte{}}, false, CloseFrame},
|
||||
{"8", Message{true, 8, 0, []byte{}}, false, ErrCloseFrame},
|
||||
{"9", Message{true, 9, 0, []byte{}}, false, nil},
|
||||
{"10", Message{true, 10, 0, []byte{}}, false, nil},
|
||||
{"11", Message{true, 11, 0, []byte{}}, false, ErrInvalidOpCode},
|
||||
|
|
|
|||
85
server.go
85
server.go
|
|
@ -2,18 +2,19 @@ package websocket
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"git.xdrm.io/go/websocket/internal/uri/parser"
|
||||
"net"
|
||||
|
||||
"git.xdrm.io/go/ws/internal/uri"
|
||||
)
|
||||
|
||||
// Represents all channels that need a server
|
||||
// All channels that a server features
|
||||
type serverChannelSet struct {
|
||||
register chan *client
|
||||
unregister chan *client
|
||||
broadcast chan Message
|
||||
}
|
||||
|
||||
// Represents a websocket server
|
||||
// Server is a websocket server
|
||||
type Server struct {
|
||||
sock net.Listener // listen socket
|
||||
addr []byte // server listening ip/host
|
||||
|
|
@ -26,9 +27,8 @@ type Server struct {
|
|||
ch serverChannelSet
|
||||
}
|
||||
|
||||
// CreateServer creates a server for a specific HOST and PORT
|
||||
func CreateServer(host string, port uint16) *Server {
|
||||
|
||||
// NewServer creates a server
|
||||
func NewServer(host string, port uint16) *Server {
|
||||
return &Server{
|
||||
addr: []byte(host),
|
||||
port: port,
|
||||
|
|
@ -37,7 +37,7 @@ func CreateServer(host string, port uint16) *Server {
|
|||
|
||||
ctl: ControllerSet{
|
||||
Def: nil,
|
||||
Uri: make([]*Controller, 0),
|
||||
URI: make([]*Controller, 0),
|
||||
},
|
||||
|
||||
ch: serverChannelSet{
|
||||
|
|
@ -46,125 +46,84 @@ func CreateServer(host string, port uint16) *Server {
|
|||
broadcast: make(chan Message, 1),
|
||||
},
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// BindDefault binds a default controller
|
||||
// it will be called if the URI does not
|
||||
// match another controller
|
||||
func (s *Server) BindDefault(f ControllerFunc) {
|
||||
|
||||
s.ctl.Def = &Controller{
|
||||
URI: nil,
|
||||
Fun: f,
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Bind binds a controller to an URI scheme
|
||||
func (s *Server) Bind(uri string, f ControllerFunc) error {
|
||||
|
||||
/* (1) Build URI parser */
|
||||
uriScheme, err := parser.Build(uri)
|
||||
// Bind a controller to an URI scheme
|
||||
func (s *Server) Bind(uriStr string, f ControllerFunc) error {
|
||||
uriScheme, err := uri.FromString(uriStr)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Cannot build URI: %s", err)
|
||||
return fmt.Errorf("cannot build URI: %w", err)
|
||||
}
|
||||
|
||||
/* (2) Create controller */
|
||||
s.ctl.Uri = append(s.ctl.Uri, &Controller{
|
||||
s.ctl.URI = append(s.ctl.URI, &Controller{
|
||||
URI: uriScheme,
|
||||
Fun: f,
|
||||
})
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// Launch launches the websocket server
|
||||
// Launch the websocket server
|
||||
func (s *Server) Launch() error {
|
||||
var (
|
||||
err error
|
||||
url = fmt.Sprintf("%s:%d", s.addr, s.port)
|
||||
)
|
||||
|
||||
var err error
|
||||
|
||||
/* (1) Listen socket
|
||||
---------------------------------------------------------*/
|
||||
/* (1) Build full url */
|
||||
url := fmt.Sprintf("%s:%d", s.addr, s.port)
|
||||
|
||||
/* (2) Bind socket to listen */
|
||||
s.sock, err = net.Listen("tcp", url)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Listen socket: %s", err)
|
||||
return fmt.Errorf("listen: %w", err)
|
||||
}
|
||||
|
||||
defer s.sock.Close()
|
||||
|
||||
fmt.Printf("+ listening on %s\n", url)
|
||||
go s.schedule()
|
||||
|
||||
/* (3) Launch scheduler */
|
||||
go s.scheduler()
|
||||
|
||||
/* (2) For each incoming connection (client)
|
||||
---------------------------------------------------------*/
|
||||
for {
|
||||
|
||||
/* (1) Wait for client */
|
||||
sock, err := s.sock.Accept()
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
|
||||
go func() {
|
||||
|
||||
/* (2) Try to create client */
|
||||
cli, err := buildClient(sock, s.ctl, s.ch)
|
||||
cli, err := newClient(sock, s.ctl, s.ch)
|
||||
if err != nil {
|
||||
fmt.Printf(" - %s\n", err)
|
||||
return
|
||||
}
|
||||
|
||||
/* (3) Register client */
|
||||
s.ch.register <- cli
|
||||
|
||||
}()
|
||||
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// Scheduler schedules clients registration and broadcast
|
||||
func (s *Server) scheduler() {
|
||||
|
||||
// schedule client registration and broadcast
|
||||
func (s *Server) schedule() {
|
||||
for {
|
||||
|
||||
select {
|
||||
|
||||
/* (1) New client */
|
||||
case client := <-s.ch.register:
|
||||
|
||||
// fmt.Printf(" + client\n")
|
||||
s.clients[client.io.sock] = client
|
||||
|
||||
/* (2) New client */
|
||||
case client := <-s.ch.unregister:
|
||||
|
||||
// fmt.Printf(" - client\n")
|
||||
delete(s.clients, client.io.sock)
|
||||
|
||||
/* (3) Broadcast */
|
||||
case msg := <-s.ch.broadcast:
|
||||
|
||||
fmt.Printf(" + broadcast\n")
|
||||
|
||||
for _, c := range s.clients {
|
||||
c.ch.send <- msg
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fmt.Printf("+ server stopped\n")
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue