From da77deba78c8a7447b4a38324d2422a5df293b26 Mon Sep 17 00:00:00 2001 From: clsr Date: Fri, 18 Aug 2017 13:46:10 +0200 Subject: Initial commit --- client.go | 39 ++++++ cnp.go | 16 +++ common.go | 141 +++++++++++++++++++++ common_test.go | 76 ++++++++++++ error.go | 205 +++++++++++++++++++++++++++++++ header.go | 365 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ header_test.go | 200 ++++++++++++++++++++++++++++++ message.go | 176 +++++++++++++++++++++++++++ message_test.go | 204 +++++++++++++++++++++++++++++++ request.go | 260 +++++++++++++++++++++++++++++++++++++++ request_test.go | 341 +++++++++++++++++++++++++++++++++++++++++++++++++++ response.go | 249 +++++++++++++++++++++++++++++++++++++ response_test.go | 317 +++++++++++++++++++++++++++++++++++++++++++++++ server.go | 257 +++++++++++++++++++++++++++++++++++++++ 14 files changed, 2846 insertions(+) create mode 100644 client.go create mode 100644 cnp.go create mode 100644 common.go create mode 100644 common_test.go create mode 100644 error.go create mode 100644 header.go create mode 100644 header_test.go create mode 100644 message.go create mode 100644 message_test.go create mode 100644 request.go create mode 100644 request_test.go create mode 100644 response.go create mode 100644 response_test.go create mode 100644 server.go diff --git a/client.go b/client.go new file mode 100644 index 0000000..b208637 --- /dev/null +++ b/client.go @@ -0,0 +1,39 @@ +package cnp + +import ( + "net" + "strconv" + "strings" +) + +// TODO: make more modular and extensible like net/http + +// Send sends a CNP request to a server and returns the response. +// +// The TCP connection is made using net.Dial. +func Send(r *Request) (*Response, error) { + host := r.Host() + if strings.LastIndexByte(host, ':') <= strings.LastIndexByte(host, ']') { // missing/default port + host = net.JoinHostPort(host, strconv.Itoa(DefaultPort)) + } + conn, err := net.Dial("tcp", host) + if err != nil { + return nil, err + } + if err = r.Write(conn); err != nil { + return nil, err + } + if err = r.Close(); err != nil { + return nil, err + } + return ParseResponse(conn) +} + +// Get sends a body-less request to a given URL. +func Get(url string) (*Response, error) { + req, err := NewRequestURL(url, nil) + if err != nil { + return nil, err + } + return Send(req) +} diff --git a/cnp.go b/cnp.go new file mode 100644 index 0000000..9ba8444 --- /dev/null +++ b/cnp.go @@ -0,0 +1,16 @@ +// Package cnp provides CNP client and server implementations. +package cnp // import "contnet.org/lib/cnp-go" + +const ( + // DefaultPort represents the default port for the cnp:// schema. + DefaultPort = 25454 + + // MaxHeaderLength is the maximum byte size of the header. + MaxHeaderLength = 1 * 1024 * 1024 + + // VersionMajor is the major CNP version (X in cnp/X.Y). + VersionMajor = 0 + + // VersionMinor is the major CNP version (Y in cnp/X.Y). + VersionMinor = 3 +) diff --git a/common.go b/common.go new file mode 100644 index 0000000..e6173b0 --- /dev/null +++ b/common.go @@ -0,0 +1,141 @@ +package cnp + +import ( + "bufio" + "bytes" + "io" + "mime" + "strconv" + "strings" + "time" +) + +func readLimitedLine(br *bufio.Reader, length int) ([]byte, error) { + var buf bytes.Buffer + + for { + data, err := br.ReadSlice('\n') + if len(data) > 0 { + buf.Write(data) + } + if buf.Len() > length { + return nil, ErrorTooLarge{"header exceeds maximum permitted size"} + } + if err == nil || err == io.EOF { + return buf.Bytes(), nil + } + if err != bufio.ErrBufferFull { + return nil, ErrorSyntax{"invalid header: missing line feed"} + } + } +} + +func getInt(m *Message, param string) (int64, error) { + p := m.Param(param) + if p == "" { + return 0, nil + } + n, err := strconv.ParseUint(p, 10, 63) + if err != nil || (n != 0 && p[0] == '0') || (n == 0 && len(p) != 1) { + return int64(n), ErrorInvalid{"invalid parameter: " + param + " is not a valid integer"} + } + return int64(n), nil +} + +func setInt(m *Message, param string, n int64) { + if n < 0 { + n = 0 + } + m.SetParam(param, strconv.FormatInt(n, 10)) +} + +func getFilename(m *Message, param string) (string, error) { + name := m.Param(param) + if strings.ContainsAny(name, "/\x00") { + return name, ErrorInvalid{"invalid parameter: " + param + " contains invalid characters"} + } + return name, nil +} + +func setFilename(m *Message, param, name string) error { + if strings.ContainsAny(name, "/\x00") { + return ErrorInvalid{"invalid parameter: " + param + " contains invalid characters"} + } + m.SetParam(param, name) + return nil +} + +func getType(m *Message, param string) (typ string, err error) { + t := m.Param(param) + if t != "" { + var params map[string]string + typ, params, err = mime.ParseMediaType(t) + if err != nil || !validMimeType(t) || len(params) > 0 { // may not contain params + err = ErrorInvalid{"invalid parameter: " + param + " is not a valid mime type"} + } + } + if typ == "" { + typ = "application/octet-stream" + } + return +} + +func setType(m *Message, param, typ string) error { + if typ == "" { + m.SetParam(param, "") + return nil + } + + /*ss := strings.Split(typ, "/") + if len(ss) != 2 || len(ss[0]) == 0 || strings.ContainsAny(typ, "\x00 \n\t\r;,") { + return ErrorInvalid{…} + }*/ + + t := mime.FormatMediaType(typ, nil) + if t == "" || !validMimeType(typ) { + return ErrorInvalid{"invalid parameter: " + param + " is not a valid mime type"} + } + m.SetParam(param, t) + + return nil +} + +func validMimeType(typ string) bool { + ss := strings.Split(typ, "/") + if len(ss) != 2 || ss[0] == "" || ss[1] == "" { + return false + } + for _, r := range typ { + /*switch r { + case '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '[', ']', '?', '=': + // tspecials except / + return false + }*/ // handled by mime.ParseMediaType + if r <= ' ' || r >= '\x7f' { + // control codes, whitespace, null + return false + } + } + return true +} + +func getTime(m *Message, param string) (time.Time, error) { + t := m.Param(param) + var z time.Time + if t == "" { + return z, nil + } + ts, err := time.Parse(time.RFC3339, t) + if err != nil || !strings.HasSuffix(t, "Z") { + return z, ErrorInvalid{"invalid parameter: " + param + " is not a valid RFC3339 timestamp"} + } + return ts, nil +} + +func setTime(m *Message, param string, t time.Time) { + if t.IsZero() { + m.SetParam(param, "") + } else { + m.SetParam(param, t.UTC().Format(time.RFC3339)) + } +} diff --git a/common_test.go b/common_test.go new file mode 100644 index 0000000..8e8c673 --- /dev/null +++ b/common_test.go @@ -0,0 +1,76 @@ +package cnp + +import ( + "bytes" + "io" + "io/ioutil" + "reflect" + "strings" +) + +func headerEqual(a, b Header) bool { + return a.Intent == b.Intent && a.VersionMajor == b.VersionMajor && a.VersionMinor == b.VersionMinor && paramEqual(a.Parameters, b.Parameters) +} + +func paramEqual(a, b Parameters) bool { + if len(a) != len(b) { + return false + } + for k := range a { + if a[k] != b[k] { + return false + } + } + return true +} + +func errorEqual(a, b error) bool { + if a == nil && b == nil { + return true + } + return reflect.TypeOf(a) == reflect.TypeOf(b) +} + +func msgEqual(a, b *Message) bool { + return headerEqual(a.Header, b.Header) && bodyEqual(a.Body, b.Body) +} + +func bodyEqual(a, b io.Reader) bool { + if a == nil && b == nil { + return true + } + if a == nil { + a = strings.NewReader("") + } + if b == nil { + b = strings.NewReader("") + } + ba, err := ioutil.ReadAll(a) + if err != nil { + panic(err) + } + if s, ok := a.(io.Seeker); ok { + _, _ = s.Seek(0, io.SeekStart) + } + bb, err := ioutil.ReadAll(b) + if err != nil { + panic(err) + } + if s, ok := b.(io.Seeker); ok { + _, _ = s.Seek(0, io.SeekStart) + } + return bytes.Equal(ba, bb) +} + +type testStringReader struct { + s string +} + +func (r *testStringReader) Read(b []byte) (n int, err error) { + if r.s == "" { + return 0, io.EOF + } + n = copy(b, r.s) + r.s = r.s[n:] + return +} diff --git a/error.go b/error.go new file mode 100644 index 0000000..b6270b9 --- /dev/null +++ b/error.go @@ -0,0 +1,205 @@ +package cnp + +// Error represents an error as used in a CNP error response. +type Error interface { + // CNPError returns the value of the "error" parameter in a CNP error + // response. + CNPError() string + + Error() string +} + +const ( + // ReasonSyntax represents the "syntax" reason parameter value. + ReasonSyntax = "syntax" + // ReasonVersion represents the "version" reason parameter value. + ReasonVersion = "version" + // ReasonInvalid represents the "invalid" reason parameter value. + ReasonInvalid = "invalid" + // ReasonNotSupported represents the "not_supported" reason parameter value. + ReasonNotSupported = "not_supported" + // ReasonTooLarge represents the "too_large" reason parameter value. + ReasonTooLarge = "too_large" + // ReasonNotFound represents the "not_found" reason parameter value. + ReasonNotFound = "not_found" + // ReasonDenied represents the "denied" reason parameter value. + ReasonDenied = "denied" + // ReasonRejected represents the "rejected" reason parameter value. + ReasonRejected = "rejected" + // ReasonServerError represents the "server_error" reason parameter value. + ReasonServerError = "server_error" +) + +// NewError returns a new Error based on a reason parameter value. +// +// If the reason is blank, nil is returned. +// If the reason is unknown, ErrorServerError is returned. +func NewError(reason string) Error { + switch reason { + case ReasonSyntax: + return ErrorSyntax{"Invalid CNP Message Syntax"} + case ReasonVersion: + return ErrorVersion{"Unsupported CNP Protocol Version"} + case ReasonInvalid: + return ErrorInvalid{"Invalid CNP Message"} + case ReasonNotSupported: + return ErrorNotSupported{"CNP Feature Not Supported"} + case ReasonTooLarge: + return ErrorTooLarge{"CNP Message Too Large"} + case ReasonNotFound: + return ErrorNotFound{"Not Found"} + case ReasonDenied: + return ErrorDenied{"Denied"} + case ReasonRejected: + return ErrorRejected{"Rejected"} + case "": + return nil + default: + fallthrough + case ReasonServerError: + return ErrorServerError{"Internal Server Error"} + } +} + +// ErrorSyntax represents the CNP "syntax" error reason. +type ErrorSyntax struct { + Reason string +} + +// CNPError on ErrorSyntax returns the error parameter value "syntax". +func (e ErrorSyntax) CNPError() string { + return ReasonSyntax +} + +func (e ErrorSyntax) Error() string { + return "CNP syntax error: " + e.Reason +} + +// ErrorVersion represents the CNP "version" error reason. +type ErrorVersion struct { + Reason string +} + +// CNPError on ErrorVersion returns the error parameter value "version". +func (e ErrorVersion) CNPError() string { + return ReasonVersion +} + +func (e ErrorVersion) Error() string { + return "Unsupported CNP version: " + e.Reason +} + +// ErrorInvalid represents the CNP "invalid" error reason. +type ErrorInvalid struct { + Reason string +} + +// CNPError on ErrorInvalid returns the error parameter value "invalid". +func (e ErrorInvalid) CNPError() string { + return ReasonInvalid +} + +func (e ErrorInvalid) Error() string { + return "Invalid CNP message: " + e.Reason +} + +// ErrorNotSupported represents the CNP "not_supported" error reason. +type ErrorNotSupported struct { + Reason string +} + +// CNPError on ErrorNotSupported returns the error parameter value +// "not_supported". +func (e ErrorNotSupported) CNPError() string { + return ReasonNotSupported +} + +func (e ErrorNotSupported) Error() string { + return "Requested CNP feature is not supported: " + e.Reason +} + +// ErrorTooLarge represents the CNP "too_large" error reason. +type ErrorTooLarge struct { + Reason string +} + +// CNPError on ErrorTooLarge returns the error parameter value "too_large". +func (e ErrorTooLarge) CNPError() string { + return ReasonTooLarge +} + +func (e ErrorTooLarge) Error() string { + return "CNP message is too large: " + e.Reason +} + +// ErrorNotFound represents the CNP "not_found" error reason. +type ErrorNotFound struct { + Reason string +} + +// CNPError on ErrorNotFound returns the error parameter value "not_found". +func (e ErrorNotFound) CNPError() string { + return ReasonNotFound +} + +func (e ErrorNotFound) Error() string { + return "Requested path was not found: " + e.Reason +} + +// ErrorDenied represents the CNP "denied" error reason. +type ErrorDenied struct { + Reason string +} + +// CNPError on ErrorDenied returns the error parameter value "denied". +func (e ErrorDenied) CNPError() string { + return ReasonDenied +} + +func (e ErrorDenied) Error() string { + return "Server denied access: " + e.Reason +} + +// ErrorRejected represents the CNP "rejected" error reason. +type ErrorRejected struct { + Reason string +} + +// CNPError on ErrorRejected returns the error parameter value "rejected". +func (e ErrorRejected) CNPError() string { + return ReasonRejected +} + +func (e ErrorRejected) Error() string { + return "Server rejected request: " + e.Reason +} + +// ErrorServerError represents the CNP "server_error" error reason. +type ErrorServerError struct { + Reason string +} + +// CNPError on ErrorServerError returns the error parameter value +// "server_error". +func (e ErrorServerError) CNPError() string { + return ReasonServerError +} + +func (e ErrorServerError) Error() string { + return "Internal server error: " + e.Reason +} + +// ErrorURL is a non-CNPError that represents an invalid CNP URL. +type ErrorURL struct { + // Err represents the error reason. + Err error + // URL is the URL that triggered the error. + URL string +} + +func (e ErrorURL) Error() string { + if e.Err == nil { + return "CNP URL error" + } + return e.Err.Error() +} diff --git a/header.go b/header.go new file mode 100644 index 0000000..e185dca --- /dev/null +++ b/header.go @@ -0,0 +1,365 @@ +package cnp + +import ( + "bufio" + "bytes" + "io" + "sort" + "strconv" +) + +const ( + // IntentOK represents the "ok" response intent. + IntentOK = "ok" + // IntentNotModified represents the "not_modified" response intent. + IntentNotModified = "not_modified" + // IntentError represents the "error" response intent. + IntentError = "error" + // IntentRedirect represents the "redirect" response intent. + IntentRedirect = "redirect" +) + +// Header represents a CNP message header +type Header struct { + // VersionMajor is the major CNP version given in the header. + VersionMajor int + // VersionMinor is the minor CNP version given in the header. + VersionMinor int + // Intent is the intent string of the message. + Intent string + // Parameters is a decoded map of the message parameters. + Parameters Parameters +} + +// NewHeader creates a new CNP header from an intent and optional parameter +// map. +func NewHeader(intent string, params Parameters) Header { + if params == nil { + params = make(Parameters) + } + return Header{ + VersionMajor: VersionMajor, + VersionMinor: VersionMinor, + Intent: intent, + Parameters: params, + } +} + +// ParseHeader parses a CNP header from a bytestring. +// The line parameter must be a single line that ends with a line feed. +func ParseHeader(line []byte) (h Header, err error) { + if bytes.IndexByte(line, '\x00') >= 0 { + err = ErrorSyntax{"invalid header: NUL byte"} + return + } + + if !bytes.HasPrefix(line, []byte("cnp/")) { + err = ErrorSyntax{"invalid header: no version string"} + return + } + line = line[len("cnp/"):] + + var o int + + h.VersionMajor, o, err = parseHeaderNumber(line) + if err != nil { + return + } + line = line[o:] + + if len(line) == 0 || line[0] != '.' { + err = ErrorSyntax{"invalid header: invalid version number tuple"} + return + } + line = line[1:] + h.VersionMinor, o, err = parseHeaderNumber(line) + if err != nil { + return + } + line = line[o:] + + if len(line) == 0 || line[0] != ' ' { + err = ErrorSyntax{"invalid header: expected a space"} + return + } + line = line[1:] + + h.Intent, o, err = parseHeaderIntent(line) + if err != nil { + return + } + line = line[o:] + + h.Parameters, o, err = parseHeaderParameters(line) + if err != nil { + return + } + line = line[o:] + + if len(line) != 1 || line[0] != '\n' { + err = ErrorSyntax{"invalid header: expected line feed and end"} + return + } + + return +} + +func parseHeaderNumber(line []byte) (n int, length int, err error) { + i := 0 + for ; i < len(line); i++ { + b := line[i] + if '0' <= b && b <= '9' { + } else { + break + } + } + n, err = strconv.Atoi(string(line[:i])) + if err != nil || (i > 1 && line[0] == '0') { + err = ErrorSyntax{"invalid header: invalid version number format"} + return + } + length = i + return +} + +func parseHeaderIntent(line []byte) (intent string, length int, err error) { + p := bytes.IndexAny(line, " \n=\x00") + if p < 0 { + p = len(line) - 1 + } + if p == 0 { + err = ErrorSyntax{"invalid header: empty intent"} + return + } + intent, err = Unescape(line[:p]) + length = p + return +} + +func parseHeaderParameters(line []byte) (params Parameters, length int, err error) { + params = make(Parameters) + + for len(line) > 1 { + if line[0] == '\n' { + break + } else if line[0] != ' ' { + err = ErrorSyntax{"invalid header: expected a space"} + return + } + line = line[1:] + length++ + + var k, v string + var o int + k, v, o, err = parseHeaderParameter(line) + if err != nil { + return + } + if _, ok := params[k]; ok { + err = ErrorSyntax{"invalid header: duplicate parameter"} + return + } + params[k] = v + line = line[o:] + length += o + } + + return +} + +func parseHeaderParameter(line []byte) (key, value string, length int, err error) { + var o int + key, o, err = parseHeaderParamString(line) + if err != nil { + return + } + line = line[o:] + length += o + + if len(line) == 0 || line[0] != '=' { + err = ErrorSyntax{"invalid header: expected an equals sign"} + return + } + line = line[1:] + length++ + + value, o, err = parseHeaderParamString(line) + if err != nil { + return + } + length += o + + return +} + +func parseHeaderParamString(line []byte) (s string, length int, err error) { + for ; length < len(line); length++ { + b := line[length] + if b == '\n' || b == ' ' || b == '=' { + break + } + } + s, err = Unescape(line[:length]) + return +} + +// Version returns the message's CNP version as a "cnp/X.Y" string. +func (h Header) Version() string { + return "cnp/" + strconv.Itoa(h.VersionMajor) + "." + strconv.Itoa(h.VersionMinor) +} + +// Write writes the CNP message header line in the wire format. +// The written line ends with a line feed. +func (h Header) Write(w io.Writer) (err error) { + bw := bufio.NewWriter(w) + _, err = bw.WriteString(h.Version()) + if err != nil { + return + } + err = bw.WriteByte(' ') + if err != nil { + return + } + _, err = bw.Write(Escape(h.Intent)) + if err != nil { + return + } + err = h.Parameters.Write(bw) + if err != nil { + return + } + err = bw.WriteByte('\n') + if err != nil { + return + } + return bw.Flush() +} + +func (h Header) String() string { + var buf bytes.Buffer + _ = h.Write(&buf) + return buf.String() +} + +// Parameters represents CNP message parameter key=value pairs. +type Parameters map[string]string + +// Write writes the parameters encoded for inclusion in the wire format. +// Includes a leading space. +func (p Parameters) Write(w io.Writer) (err error) { + bw := bufio.NewWriter(w) + keys := []string{} + for k := range p { + keys = append(keys, k) + } + sort.Strings(keys) + for _, k := range keys { + err = bw.WriteByte(' ') + if err != nil { + return + } + _, err = bw.Write(Escape(k)) + if err != nil { + return + } + err = bw.WriteByte('=') + if err != nil { + return + } + _, err = bw.Write(Escape(p[k])) + if err != nil { + return + } + } + return +} + +// Escape CNP-escapes the bytestring s. +func Escape(s string) []byte { + el := escapeLength(s) + if el == len(s) { + return []byte(s) + } + bs := make([]byte, el) + bi := 0 + for i := 0; i < len(s); i++ { + switch s[i] { + case '\x00': + bs[bi] = '\\' + bs[bi+1] = '0' + bi += 2 + + case '\n': + bs[bi] = '\\' + bs[bi+1] = 'n' + bi += 2 + + case ' ': + bs[bi] = '\\' + bs[bi+1] = '_' + bi += 2 + + case '=': + bs[bi] = '\\' + bs[bi+1] = '-' + bi += 2 + + case '\\': + bs[bi] = '\\' + bs[bi+1] = '\\' + bi += 2 + + default: + bs[bi] = s[i] + bi++ + } + } + return bs +} + +func escapeLength(s string) (l int) { + for i := 0; i < len(s); i++ { + switch s[i] { + case '\x00', '\n', ' ', '=', '\\': + l += 2 + default: + l++ + } + } + return +} + +// Unescape unescapes the bs from wire format into a bytestring. +func Unescape(bs []byte) (string, error) { + buf := make([]byte, len(bs)) + bi := 0 + + for i := 0; i < len(bs); i++ { + switch bs[i] { + case '\\': + i++ + if i >= len(bs) { + return string(buf[:bi]), ErrorSyntax{"invalid escape sequence: unexpected end of string"} + } + switch bs[i] { + case '0': + buf[bi] = '\x00' + case 'n': + buf[bi] = '\n' + case '_': + buf[bi] = ' ' + case '-': + buf[bi] = '=' + case '\\': + buf[bi] = '\\' + default: + return string(buf[:bi]), ErrorSyntax{"invalid escape sequence: undefined sequence"} + } + default: + buf[bi] = bs[i] + } + bi++ + } + + return string(buf[:bi]), nil +} diff --git a/header_test.go b/header_test.go new file mode 100644 index 0000000..b035078 --- /dev/null +++ b/header_test.go @@ -0,0 +1,200 @@ +package cnp + +import "testing" + +var escapes = map[string]string{ + "": ``, + "ContNet": `ContNet`, + " ": `\_`, + "=": `\-`, + "\n": `\n`, + "\x00": `\0`, + "\\": `\\`, + "a\nb c=d\x00e\\f": `a\nb\_c\-d\0e\\f`, + "\n\n\n": `\n\n\n`, + "===": `\-\-\-`, + " ": `\_\_\_`, + "\x00\x00\x00": `\0\0\0`, + "\\\\\\": `\\\\\\`, + " =\n\x00\\": `\_\-\n\0\\`, + "\b5Ὂg̀9! ℃ᾭG": "\b5Ὂg̀9!\\_℃ᾭG", + "\xff\x00\xee\xaa\xee": "\xff\\0\xee\xaa\xee", + "\x00\x10\x20\x30\x40": "\\0\x10\\_\x30\x40", + "\x10\x50\x90\xe0": "\x10\x50\x90\xe0", + "Hello, 世界": `Hello,\_世界`, + "\xed\x9f\xbf": "\xed\x9f\xbf", + "\xee\x80\x80": "\xee\x80\x80", + "\xef\xbf\xbd": "\xef\xbf\xbd", + "\x80\x80\x80\x80": "\x80\x80\x80\x80", +} + +func TestEscape(t *testing.T) { + for k, v := range escapes { + e := string(Escape(k)) + if e != v { + t.Errorf("Escape(%q) -> %q, expected %q", k, e, v) + } + } + for i := 0; i <= 255; i++ { + switch i { + case '\x00', ' ', '=', '\n', '\\': + continue + default: + s := string([]byte{byte(i)}) + b := Escape(s) + if s != string(b) { + t.Errorf("Escape(%q) -> %q, expected %q", s, b, s) + } + } + } +} + +func TestUnEscape(t *testing.T) { + for k, v := range escapes { + u, err := Unescape([]byte(v)) + if err != nil { + t.Errorf("Unescape(%q): error: %s", v, err) + } else if u != k { + t.Errorf("Unescape(%q) -> %q, expected %q", v, u, k) + } + } + for i := 0; i <= 255; i++ { + switch i { + case '\x00', ' ', '=', '\n', '\\': + continue + default: + b := []byte{byte(i)} + s, err := Unescape(b) + if err != nil { + t.Errorf("Unescape(%q): error: %s", b, err) + } else if string(b) != s { + t.Errorf("Escape(%q) -> %q, expected %q", b, s, b) + } + } + } +} + +var headers = map[string]struct { + h Header + e error +}{ + // invalid version + "cnp/0.3ok\n": {e: ErrorSyntax{}}, + "cwp/0.3 ok\n": {e: ErrorSyntax{}}, + "cnp/0.03 ok\n": {e: ErrorSyntax{}}, + "cnp/00.3 ok\n": {e: ErrorSyntax{}}, + "cnp/0..3 ok\n": {e: ErrorSyntax{}}, + "cnp/.3 ok\n": {e: ErrorSyntax{}}, + "cnp/0. ok\n": {e: ErrorSyntax{}}, + "cnp/. ok\n": {e: ErrorSyntax{}}, + "cnp/0,3 ok\n": {e: ErrorSyntax{}}, + "/0.3 ok\n": {e: ErrorSyntax{}}, + "0.3 ok\n": {e: ErrorSyntax{}}, + "cnp/ ok\n": {e: ErrorSyntax{}}, + "cnp ok\n": {e: ErrorSyntax{}}, + "cnp.0.3 ok\n": {e: ErrorSyntax{}}, + "cnp/03 ok\n": {e: ErrorSyntax{}}, + "cnp/3 ok\n": {e: ErrorSyntax{}}, + "cnp/0 ok\n": {e: ErrorSyntax{}}, + "cnp/0 3 ok\n": {e: ErrorSyntax{}}, + "cnp/0/3 ok\n": {e: ErrorSyntax{}}, + + // missing/invalid intent + "cnp/0.3\n": {e: ErrorSyntax{}}, + "cnp/0.3 \n": {e: ErrorSyntax{}}, + "cnp/0.3 o\x00k\n": {e: ErrorSyntax{}}, + "cnp/0.3 foo=bar\n": {e: ErrorSyntax{}}, + + // missing/invalid line end + "cnp/0.3 ok \n": {e: ErrorSyntax{}}, + "cnp/0.3 ok\n\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok": {e: ErrorSyntax{}}, + "cnp/0.3 ok ": {e: ErrorSyntax{}}, + "cnp/0.3 ok foo=bar \n": {e: ErrorSyntax{}}, + "cnp/0.3 ok foo=bar": {e: ErrorSyntax{}}, + "cnp/0.3 ok = =\n": {e: ErrorSyntax{}}, + + // spaces + "cnp/0.3 ok foo=bar\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok\n": {e: ErrorSyntax{}}, + "cnp/0.3\tok\n": {e: ErrorSyntax{}}, + + // invalid params + "cnp/0.3 ok foo==bar\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok foo=bar=baz\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok foo=bar baz=quux \n": {e: ErrorSyntax{}}, + "cnp/0.3 ok foo\\-bar\n": {e: ErrorSyntax{}}, + + // invalid escape sequences + "cnp/0.3 o\\k\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok qwe=\\\n": {e: ErrorSyntax{}}, + "cnp/0.3 ok fo\\o=bar\n": {e: ErrorSyntax{}}, + + // valid + "cnp/0.0 ok\n": {h: Header{0, 0, "ok", nil}}, + "cnp/0.3 ok\n": {h: Header{0, 3, "ok", nil}}, + "cnp/1.0 ok\n": {h: Header{1, 0, "ok", nil}}, + "cnp/123456.987654 ok\n": {h: Header{123456, 987654, "ok", nil}}, + "cnp/0.1 ok\n": {h: Header{0, 1, "ok", nil}}, + "cnp/0.3 ok\r\n": {h: Header{0, 3, "ok\r", nil}}, + "cnp/0.3 foo\\nbar\n": {h: Header{0, 3, "foo\nbar", nil}}, + "cnp/0.3 \\-\\_\\n\\0\\\\\n": {h: Header{0, 3, "= \n\x00\\", nil}}, + + // valid with params + "cnp/0.3 ok type=text/plain\n": {h: Header{0, 3, "ok", Parameters{"type": "text/plain"}}}, + "cnp/0.3 ok baz=quux foo=bar qwe=asd\n": {h: Header{0, 3, "ok", Parameters{"foo": "bar", "baz": "quux", "qwe": "asd"}}}, + "cnp/0.3 ok = \\_=\\0 \\-=\\n\r\n": {h: Header{0, 3, "ok", Parameters{"": "", "=": "\n\r", " ": "\x00"}}}, +} + +func TestHeaderParse(t *testing.T) { + for raw, tst := range headers { + hdr, err := ParseHeader([]byte(raw)) + if err != nil || tst.e != nil { + if !errorEqual(err, tst.e) { + t.Errorf("ParseHeader(%q): expected error %+v, got %+v (%v)", raw, tst.e, err, err) + } + } else if !headerEqual(tst.h, hdr) { + t.Errorf("ParseHeader(%q): expected %+v, got %+v", raw, tst.h, hdr) + } + } +} + +func TestHeaderCompose(t *testing.T) { + for raw, tst := range headers { + if tst.e != nil { + continue + } + // Parameters.Write currently sorts parameter keys + /*if len(tst.h.Parameters) > 1 { + continue // can't depend on parameter order + }*/ + str := tst.h.String() + if raw != str { + t.Errorf("%+v.String(): expected %q, got %q", tst.h, raw, str) + } + } +} + +func TestNewHeader(t *testing.T) { + raw := "cnp/0.3 ok baz=quux foo=bar qwe=asd\n" + hdr := Header{0, 3, "ok", Parameters{"foo": "bar", "baz": "quux", "qwe": "asd"}} + h := NewHeader("ok", Parameters{"foo": "bar", "baz": "quux", "qwe": "asd"}) + if !headerEqual(hdr, h) { + t.Errorf("%+v: expected %+v", h, hdr) + } + s := h.String() + if raw != s { + t.Errorf("%q: expected %q", h, hdr) + } + + raw = "cnp/0.3 ok\n" + hdr = Header{0, 3, "ok", nil} + h = NewHeader("ok", nil) + if !headerEqual(hdr, h) { + t.Errorf("%+v: expected %+v", h, hdr) + } + s = h.String() + if raw != s { + t.Errorf("%q: expected %q", h, hdr) + } +} diff --git a/message.go b/message.go new file mode 100644 index 0000000..eb3d2b9 --- /dev/null +++ b/message.go @@ -0,0 +1,176 @@ +package cnp + +import ( + "bufio" + "bytes" + "io" + "io/ioutil" + "strings" +) + +// Message represents a CNP message. +type Message struct { + Header Header + Body io.Reader + closer io.Closer +} + +// NewMessage creates a new CNP message. +// +// This method also calls Message.TryComputeLength(). +func NewMessage(intent string, body io.Reader) *Message { + msg := &Message{ + Header: NewHeader(intent, nil), + Body: body, + } + + msg.TryComputeLength() + + return msg +} + +// ParseMessage parses a CNP message. +// +// The message's Body field is set to a bufio.Reader wrapping r. If r is a +// io.Closer, it is also stored separately for usage with Message.Close(). +func ParseMessage(r io.Reader) (*Message, error) { + br := bufio.NewReader(r) + + line, err := readLimitedLine(br, MaxHeaderLength) + if err != nil { + return nil, err + } + + h, err := ParseHeader(line) + if err != nil { + return nil, err + } + + msg := &Message{ + Header: h, + Body: br, + } + + if rc, ok := r.(io.Closer); ok { + msg.closer = rc + } + + return msg, nil +} + +// Close attempts to close the message body reader. +// +// If the message's Body field is an io.Closer, its Close() method is called. +// If Body is not an io.Closer and the message was created with ParseMessage +// provided with an io.Closer, the Close() method on the original reader will +// be called. +// Otherwise, this function does nothing. +func (msg *Message) Close() error { + if rc, ok := msg.Body.(io.Closer); ok { + return rc.Close() + } + if msg.closer != nil { + return msg.closer.Close() + } + return nil +} + +// ComputeLength sets the length header parameter based on the message body. +// First, msg.TryComputeLength() is attempted; if that fails, the request is +// fully read into a buffer and msg.Body is set to a bytes.Reader. +func (msg *Message) ComputeLength() error { + if !msg.TryComputeLength() { + buf, err := ioutil.ReadAll(msg.Body) + if len(buf) > 0 { + msg.Body = bytes.NewReader(buf) + msg.SetLength(int64(len(buf))) + } + if err != nil { + return err + } + } + + return nil +} + +// TryComputeLength sets the length header parameter to the length of the +// message body if it's one of *bytes.Buffer, *bytes.Reader or *strings.Reader +// and returns true. If msg.Body is nil, the length parameter is unset and the +// function returns true. Otherwise, false is returned. +func (msg *Message) TryComputeLength() bool { + switch v := msg.Body.(type) { + case *bytes.Buffer: + msg.SetLength(int64(v.Len())) + case *bytes.Reader: + msg.SetLength(int64(v.Len())) + case *strings.Reader: + msg.SetLength(int64(v.Len())) + case nil: + msg.SetLength(0) + default: + return false + } + return true +} + +// SetLength sets the length header parameter to n. +func (msg *Message) SetLength(n int64) { + if n == 0 { + msg.SetParam("length", "") + } else { + setInt(msg, "length", n) + } +} + +// Length gets the length header parameter (or 0 if it's not set or invalid). +func (msg *Message) Length() int64 { + n, err := getInt(msg, "length") + if err != nil { + return 0 + } + return n +} + +// Param retrieves a header parameter. +func (msg *Message) Param(key string) string { + return msg.Header.Parameters[key] +} + +// SetParam sets a header parameter. If the value is empty, the parameter is +// unset. +func (msg *Message) SetParam(key, value string) { + if len(value) == 0 { + delete(msg.Header.Parameters, key) + } else { + msg.Header.Parameters[key] = value + } +} + +// Intent retrieves the message header intent. +func (msg *Message) Intent() string { + return msg.Header.Intent +} + +// SetIntent sets the message header intent. +func (msg *Message) SetIntent(s string) { + msg.Header.Intent = s +} + +// Validate validates the message header parameter value format (length). +func (msg *Message) Validate() error { + _, err := getInt(msg, "length") + return err +} + +// Write writes the message header and body to w. +func (msg *Message) Write(w io.Writer) error { + if err := msg.Header.Write(w); err != nil { + return err + } + if msg.Body != nil { + if _, err := io.Copy(w, msg.Body); err != nil { + return err + } + } + return nil +} diff --git a/message_test.go b/message_test.go new file mode 100644 index 0000000..6955fc3 --- /dev/null +++ b/message_test.go @@ -0,0 +1,204 @@ +package cnp + +import ( + "bytes" + "io" + "strconv" + "strings" + "testing" +) + +var ( + messageTests = []messageTest{ + { + "qweasd", "text/plain", nil, nil, + "cnp/0.3 test1 length=6 type=text/plain\nqweasd", + &Message{ + Header: Header{ + VersionMajor: 0, + VersionMinor: 3, + Intent: "test1", + Parameters: Parameters{ + "type": "text/plain", + "length": "6", + }, + }, + Body: strings.NewReader("qweasd"), + }, + }, + + { + "qweasd", "text", nil, ErrorInvalid{}, + "cnp/0.3 test2 length=w type=text/plain\nqweasd", + &Message{ + Header: Header{ + VersionMajor: 0, + VersionMinor: 3, + Intent: "test2", + Parameters: Parameters{ + "type": "text/plain", + "length": "w", + }, + }, + Body: strings.NewReader("qweasd"), + }, + }, + + { + "", "text/plain", ErrorSyntax{}, nil, + "cnp/0.3 test3 type=text/plain", + nil, + }, + + { + "", "text/plain", nil, nil, + "cnp/0.3 test4 type=text/plain\n", + &Message{ + Header: Header{ + VersionMajor: 0, + VersionMinor: 3, + Intent: "test4", + Parameters: Parameters{ + "type": "text/plain", + }, + }, + Body: nil, + }, + }, + } +) + +type messageTest struct { + b, t string + p, v error + s string + m *Message +} + +func (tst *messageTest) Reset() { + if tst.m != nil && tst.b != "" { + tst.m.Body = strings.NewReader(tst.b) + } +} + +func TestParse(t *testing.T) { + for _, tst := range messageTests { + tst.Reset() + msg, err := ParseMessage(strings.NewReader(tst.s)) + if tst.p != nil || err != nil { + if !errorEqual(tst.p, err) { + t.Errorf("ParseMessage(%q): expected error %+v, got %+v (%v)", tst.s, tst.p, err, err) + continue + } + } else if !msgEqual(msg, tst.m) { + t.Errorf("\nexpected: %+v\ngot: %+v", tst.m, msg) + } else if l := msg.Length(); tst.v == nil && l != int64(len(tst.b)) { + t.Errorf("%+v: expected length %d, got %d", tst.m, len(tst.b), l) + } else if err = msg.Validate(); !errorEqual(err, tst.v) { + t.Errorf("%+v: expected validation error %+v, got %+v (%s)", msg, tst.v, err, err) + } + } +} + +func TestNew(t *testing.T) { + for i, tst := range messageTests { + if tst.v != nil || tst.p != nil { + continue // skip invalid messages + } + tst.Reset() + var r io.Reader + if tst.b != "" { + r = strings.NewReader(tst.b) + } + msg := NewMessage("test"+strconv.Itoa(i+1), r) + msg.SetParam("type", tst.t) + if !msgEqual(msg, tst.m) { + t.Errorf("\nexpected: %+v\ngot: %+v", tst.m, msg) + } + } +} + +func TestWrite(t *testing.T) { + for _, tst := range messageTests { + if tst.p != nil { + continue // skip invalid messages + } + tst.Reset() + var buf bytes.Buffer + err := tst.m.Write(&buf) + if err != nil { + t.Errorf("%+v: error writing message body: %s", tst.m, err) + } + if buf.String() != tst.s { + t.Errorf("%+v:\nexpected: %q\ngot: %q", tst.m, tst.s, buf.String()) + } + } +} + +func TestComputeLength(t *testing.T) { + s := "qweasd" + r := &testStringReader{"qweasd"} + msg := NewMessage("ok", r) + if _, ok := msg.Header.Parameters["length"]; msg.Length() != 0 || msg.Param("length") != "" || ok { + t.Fatalf("%+v: expected no length parameter", msg) + } + if err := msg.ComputeLength(); err != nil { + t.Fatalf("%+v.ComputeLength(): error: %s", msg, err) + } + if l := msg.Length(); l != int64(len(s)) { + t.Fatalf("%+v: invalid length %d, expected %d\n", msg, l, len(s)) + } + if _, ok := msg.Body.(*testStringReader); r.s != "" || ok || r == msg.Body { + t.Fatalf("%+v: did not buffer body correctly", msg) + } + if !bodyEqual(msg.Body, strings.NewReader(s)) { + t.Fatalf("%+v: incorrect buffered body", msg) + } +} + +func TestParseTooLarge(t *testing.T) { + s := "cnp/0.3 ok text=" + str := s + strings.Repeat(".", MaxHeaderLength-len(s)) + "\n" + _, err := ParseMessage(strings.NewReader(str)) + if _, ok := err.(ErrorTooLarge); !ok { + t.Errorf("\nexpected: ErrorTooLarge\ngot: %+v", err) + } +} + +type noopCloser struct { + r io.Reader + closed bool +} + +func (n *noopCloser) Close() error { + n.closed = true + return nil +} + +func (n *noopCloser) Read(b []byte) (int, error) { + return n.r.Read(b) +} + +func TestClose(t *testing.T) { + var r io.Reader = strings.NewReader("cnp/0.3 ok\nqweasd") + if msg, err := ParseMessage(r); err != nil { + t.Errorf("ParseMessage error: %v", err) + } else if err = msg.Close(); err != nil { + t.Errorf("Error closing message: %v", err) + } + r = &noopCloser{r: strings.NewReader("cnp/0.3 ok\nqweasd")} + if msg, err := ParseMessage(r); err != nil { + t.Errorf("ParseMessage error: %v", err) + } else if err = msg.Close(); err != nil { + t.Errorf("Error closing message: %v", err) + } else if !r.(*noopCloser).closed { + t.Errorf("Reader was not closed") + } + r = &noopCloser{r: strings.NewReader("qweasd")} + msg := NewMessage("ok", r) + if err := msg.Close(); err != nil { + t.Errorf("Error closing message: %v", err) + } else if !r.(*noopCloser).closed { + t.Errorf("Reader was not closed") + } +} diff --git a/request.go b/request.go new file mode 100644 index 0000000..8c5a34e --- /dev/null +++ b/request.go @@ -0,0 +1,260 @@ +package cnp + +import ( + "bytes" + "errors" + "io" + "net/url" + "path" + "strconv" + "strings" + "time" +) + +// Request represents a CNP request message. +type Request struct { + Message +} + +// NewRequest creates a new Request from a host, path and optional body data. +func NewRequest(host, pth string, body []byte) (*Request, error) { + var r io.Reader + if body != nil { + r = bytes.NewReader(body) + } + req := &Request{*NewMessage("/", r)} + if err := req.SetHostPath(host, pth); err != nil { + return nil, err + } + return req, nil +} + +// NewRequestURL creates a new Request from a URL and body data. +func NewRequestURL(urlStr string, body []byte) (*Request, error) { + // XXX: handle //example.com/path URLs + if strings.HasPrefix(urlStr, "//") { + urlStr = "cnp:" + urlStr + } + + u, err := url.ParseRequestURI(urlStr) + if err != nil { + return nil, ErrorURL{err, urlStr} + } + + if u.Scheme != "cnp" && u.Scheme != "" { + return nil, ErrorURL{errors.New("NewRequestURL: URL is not a cnp:// URL"), urlStr} + } + if u.Opaque != "" { + return nil, ErrorURL{errors.New("NewRequestURL: CNP URL may not contain opaque data"), urlStr} + } + if u.User != nil { + return nil, ErrorURL{errors.New("NewRequestURL: CNP URL cannot may not contain userinfo"), urlStr} + } + + host := u.Hostname() + if strings.ContainsRune(host, ':') { // IPv6 + host = "[" + host + "]" + } + port := DefaultPort + if sp := u.Port(); sp != "" { + port, err = strconv.Atoi(sp) + if err != nil { + return nil, ErrorURL{err, urlStr} + } + } + if port != DefaultPort { + host = host + ":" + strconv.Itoa(port) + } + + pth := u.Path + if pth == "" { + pth = "/" + } + /*if u.RawQuery != "" { + q, err := url.QueryUnescape(u.RawQuery) + if err != nil { + return nil, ErrorURL{err, urlStr} + } + pth = pth + "?" + q + }*/ + + return NewRequest(host, pth, body) +} + +// ParseRequest parses a request message. +func ParseRequest(r io.Reader) (*Request, error) { + msg, err := ParseMessage(r) + if err != nil { + return nil, err + } + + if err = validateRequestIntent(msg.Intent()); err != nil { + return nil, err + } + + return &Request{*msg}, nil +} + +// SetHost sets the host part of the request intent, leaving path unchanged. +func (r *Request) SetHost(host string) error { + return r.SetHostPath(host, r.Path()) +} + +// SetPath sets the path part of the request intent, leaving host unchanged. +func (r *Request) SetPath(pth string) error { + return r.SetHostPath(r.Host(), pth) +} + +// SetHostPath sets the request intent. +func (r *Request) SetHostPath(host, pth string) error { + if len(pth) < 1 || pth[0] != '/' { + return ErrorInvalid{"invalid request: invalid path"} + } + if strings.ContainsRune(host, '/') { + return ErrorInvalid{"invalid request: invalid host"} + } + r.SetIntent(host + Clean(pth)) + return nil +} + +// Host returns the host part of the request intent. +func (r *Request) Host() string { + host, _ := r.HostPath() + return host +} + +// Path returns the path part of the request intent. +func (r *Request) Path() string { + _, pth := r.HostPath() + return pth +} + +// HostPath returns the host and path parts of the request intent. +func (r *Request) HostPath() (host string, pth string) { + ss := strings.SplitN(r.Intent(), "/", 2) + if len(ss) != 2 { + return "", "/" + } + host = ss[0] + pth = "/" + ss[1] + return +} + +// URL returns a cnp:// URL based on this request's intent. +func (r *Request) URL() *url.URL { + var u url.URL + u.Scheme = "cnp" + u.Host = r.Host() + u.Path = r.Path() + return &u +} + +// Name retrieves the name request parameter. +// +// If the name request parameter is not a valid filename, an empty string is +// returned. +func (r *Request) Name() string { + name, err := getFilename(&r.Message, "name") + if err != nil { + return "" + } + return name +} + +// SetName sets the name request parameter. +// +// An error is raised if the name includes characters not valid in a filename +// (slash, null byte). +func (r *Request) SetName(name string) error { + return setFilename(&r.Message, "name", name) +} + +// Type retrieves the type request parameter. +// +// If the type request parameter is invalid or empty, the default value +// "application/octet-stream" is returned. +func (r *Request) Type() string { + typ, _ := getType(&r.Message, "type") + return typ +} + +// SetType sets the type request parameter. +// +// An error is raised if typ is not a valid format for a MIME type. +func (r *Request) SetType(typ string) error { + return setType(&r.Message, "type", typ) +} + +// IfModified retrieves the if_modified request parameter. +// +// If the parameter isn't a valid RFC3339 timestamp, a zero time.Time is +// returned. +func (r *Request) IfModified() time.Time { + t, err := getTime(&r.Message, "if_modified") + if err != nil { + return time.Time{} + } + return t +} + +// SetIfModified sets the if_modified request parameter. +// +// If t is the zero time value, the if_modified parameter is unset. +func (r *Request) SetIfModified(t time.Time) { + setTime(&r.Message, "if_modified", t) +} + +// Validate validates the request header intent and parameter value format +// (length, name, type, if_modified) +func (r *Request) Validate() error { + if err := validateRequestIntent(r.Intent()); err != nil { + return err + } + if err := r.Message.Validate(); err != nil { + return err + } + if _, err := getFilename(&r.Message, "name"); err != nil { + return err + } + if _, err := getType(&r.Message, "type"); err != nil { + return err + } + if _, err := getTime(&r.Message, "if_modified"); err != nil { + return err + } + return nil +} + +func validateRequestIntent(intent string) error { + ss := strings.SplitN(intent, "/", 2) + if len(ss) != 2 { + return ErrorInvalid{"invalid request: invalid intent"} + } + host, pth := ss[0], ss[1] + + if strings.ContainsAny(host, "\x00 ") || strings.ContainsRune(pth, '\x00') { + return ErrorInvalid{"invalid request: invalid intent"} + } + + return nil +} + +// Write ensures that the request's length parameter is set if it has body and +// then writes it to w. +func (r *Request) Write(w io.Writer) error { + if _, ok := r.Header.Parameters["length"]; !ok { + if err := r.ComputeLength(); err != nil { + return err + } + } + return r.Message.Write(w) +} + +// Clean cleans a CNP intent path. +func Clean(s string) string { + c := path.Clean(s) + if len(s) > 0 && len(c) > 0 && s[len(s)-1] == '/' && c[len(c)-1] != '/' { + return c + "/" + } + return c +} diff --git a/request_test.go b/request_test.go new file mode 100644 index 0000000..bb4aa9b --- /dev/null +++ b/request_test.go @@ -0,0 +1,341 @@ +package cnp + +import ( + "bytes" + "strconv" + "strings" + "testing" + "time" +) + +type requestTest struct { + h, s string + p Parameters + e, v error +} + +var requestTests = []requestTest{ + // invalid intent + {"", "", nil, ErrorInvalid{}, nil}, + {"", "foo/bar", nil, ErrorInvalid{}, nil}, + {"foo/", "bar", nil, ErrorInvalid{}, nil}, + {"foo/", "/bar", nil, ErrorInvalid{}, nil}, + + // invalid request params + {"", "/", Parameters{"length": "w"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"length": "-1"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"length": "03"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"name": "foo/bar"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"name": "foo\x00bar"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "\x00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "text/plain\x00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo/bar "}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": " foo/bar"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo /bar"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo/ bar"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo/bar\n"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"type": "foo/b(r"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "now"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "today"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "Thu Jan 1 00:00:00 UTC 1970"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01 00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01 00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01 00:00:00+0000"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01 00:00:00+00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01T00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01T00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01T00:00:00+0000"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1970-01-01T00:00:00+00"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-00-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-01-00T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-01-01T24:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-01-01T00:60:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-01-01T00:00:60Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0000-11-31T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0001-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0002-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0003-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0005-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "0100-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "1000-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "123-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "12345-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "-5-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"", "/", Parameters{"if_modified": "-2005-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + + // valid simple requests + {"", "/", nil, nil, nil}, + {"", "/foo/bar", nil, nil, nil}, + {"cnp.example.com", "/", nil, nil, nil}, + {"foo", "/bar", nil, nil, nil}, + {"example.com", "/ f=#\\oo///.././.../~/\x01/\xff/ba\nr", nil, nil, nil}, + + // valid request params + {"", "/", Parameters{"length": "", "name": "", "type": "", "if_modified": "", "": "", "q\x00we": "=a s\nd"}, nil, nil}, + {"", "/", Parameters{"length": "0"}, nil, nil}, + {"", "/", Parameters{"length": "1"}, nil, nil}, + {"", "/", Parameters{"length": "12345670089000000"}, nil, nil}, + {"", "/", Parameters{"name": "foobar"}, nil, nil}, + {"", "/", Parameters{"name": "x"}, nil, nil}, + {"", "/", Parameters{"name": "..-~!foo bar\nbaz\rquux=qwe\\asd"}, nil, nil}, + {"", "/", Parameters{"name": strings.Repeat("w", 1024*8)}, nil, nil}, + {"", "/", Parameters{"type": "qwe/asd"}, nil, nil}, + {"", "/", Parameters{"type": "qwe+asd/foo"}, nil, nil}, + {"", "/", Parameters{"type": "qwe-asd/foo"}, nil, nil}, + {"", "/", Parameters{"if_modified": "1970-01-01T00:00:00Z"}, nil, nil}, + {"", "/", Parameters{"if_modified": "0000-01-01T00:00:00Z"}, nil, nil}, + {"", "/", Parameters{"if_modified": "9999-12-31T23:59:59Z"}, nil, nil}, + {"", "/", Parameters{"if_modified": "0123-05-06T07:08:09Z"}, nil, nil}, + {"", "/", Parameters{"if_modified": "0000-02-29T00:00:00Z"}, nil, nil}, + {"", "/", Parameters{"if_modified": "2000-02-29T00:00:00Z"}, nil, nil}, +} + +func TestNewRequest(t *testing.T) { + for _, tst := range requestTests { + req, err := NewRequest(tst.h, tst.s, []byte{}) + if !errorEqual(tst.e, err) { + t.Errorf("NewRequest(%q, %q): expected error %+v, got %+v (%v)", tst.h, tst.s, tst.e, err, err) + continue + } + if tst.e == nil { + if tst.h != req.Host() { + t.Errorf("NewRequest(%q: %q): got unexpected host %q", tst.h, tst.s, req.Host()) + } else if Clean(tst.s) != req.Path() { + t.Errorf("NewRequest(%q: %q): got unexpected path %q", tst.h, tst.s, req.Path()) + } + } + } +} + +type requestURLTest struct { + u string + h, p string + e error +} + +var requestURLTests = []requestURLTest{ + // invalid + {"cnp:example.com/path/to/file", "", "", ErrorURL{}}, + {"http://example.com/path/to/file", "", "", ErrorURL{}}, + {"cnp://foo@bar:example.com/path/to/file", "", "", ErrorURL{}}, + {"cnp://foo:example.com/path/to/file", "", "", ErrorURL{}}, + {"", "", "/", ErrorURL{}}, + {"cnp://example.com/%5", "", "", ErrorURL{}}, + //{"cnp://example.com/?%5", "", "", ErrorURL{}}, + + // valid + {"cnp://example.com/path/to/file", "example.com", "/path/to/file", nil}, + {"cnp://2130706433/", "2130706433", "/", nil}, + //{"cnp://02130706433/", "2130706433", "/", nil}, + {"cnp://127.0.0.1/", "127.0.0.1", "/", nil}, + //{"cnp://0127.0.00.01/", "127.0.0.1", "/", nil}, + {"cnp://localhost", "localhost", "/", nil}, + {"cnp://[::1]/foo%20bar", "[::1]", "/foo bar", nil}, + {"cnp://[2001:db8::7334]/foo%0abar", "[2001:db8::7334]", "/foo\nbar", nil}, + //{"cnp://[2001:0db8:0000::7334]/foo%0abar", "[2001:db8::7334]", "/foo\nbar", nil}, + //{"cnp://example.com/qwe%20asd?foo=bar&baz=qu%20ux", "example.com", "/qwe asd?foo=bar&baz=qu ux", nil}, + {"cnp://example.com/qwe%20asd?foo=bar&baz=qu%20ux", "example.com", "/qwe asd", nil}, + {"cnp://localhost:25454", "localhost", "/", nil}, + {"cnp://localhost:12345/foo/bar", "localhost:12345", "/foo/bar", nil}, + {"cnp://localhost:25454/foo/bar", "localhost", "/foo/bar", nil}, + {"cnp://2130706433:12345/foo/bar", "2130706433:12345", "/foo/bar", nil}, + {"cnp://2130706433:25454/foo/bar", "2130706433", "/foo/bar", nil}, + {"cnp://127.0.0.1:12345/foo/bar", "127.0.0.1:12345", "/foo/bar", nil}, + {"cnp://127.0.0.1:25454/foo/bar", "127.0.0.1", "/foo/bar", nil}, + {"cnp://[::1]:12345/foo/bar", "[::1]:12345", "/foo/bar", nil}, + {"cnp://[::1]:25454/foo/bar", "[::1]", "/foo/bar", nil}, + {"//example.com/path/", "example.com", "/path/", nil}, + {"/example.com/path/", "", "/example.com/path/", nil}, + {"/foo/bar", "", "/foo/bar", nil}, + {"/", "", "/", nil}, + {"cnp://example.com/ ™☺)\n", "example.com", "/ ™☺)\n", nil}, + {"cnp://œ¤å₥¶ḹə.©°ɱ/baz/../foo/.//bar////.//../bar//", "œ¤å₥¶ḹə.©°ɱ", "/foo/bar/", nil}, + {"cnp://foo/bar/", "foo", "/bar/", nil}, + {"cnp:///foo/bar/", "", "/foo/bar/", nil}, + {"cnp:////////foo/bar/", "", "/foo/bar/", nil}, +} + +func TestNewRequestURL(t *testing.T) { + for _, tst := range requestURLTests { + req, err := NewRequestURL(tst.u, nil) + if !errorEqual(tst.e, err) { + t.Errorf("NewRequestURL(%q, nil): expected error %+v, got %+v (%v)", tst.u, tst.e, err, err) + continue + } + if tst.e == nil { + if req.Host() != tst.h { + t.Errorf("NewRequestURL(%q, nil): expected host %q, got %q", tst.u, tst.h, req.Host()) + } else if req.Path() != tst.p { + t.Errorf("NewRequestURL(%q, nil): expected path %q, got %q", tst.u, tst.p, req.Path()) + } + } + } +} + +func TestWriteParseRequest(t *testing.T) { + for _, tst := range requestTests { + if tst.e != nil { + continue // skip syntax errors but not invalid params + } + req := &Request{Message{Header{0, 3, "/", Parameters{}}, nil, nil}} + if err := req.SetHost(tst.h); err != nil { + t.Errorf("SetHost(%q) error: %v", tst.h, err) + continue + } + if err := req.SetPath(tst.s); err != nil { + t.Errorf("SetPath(%q) error: %v", tst.s, err) + continue + } + for k, v := range tst.p { + req.SetParam(k, v) + } + + var buf bytes.Buffer + if err := req.Write(&buf); err != nil { + t.Errorf("%+v.Write: error %v", req, err) + continue + } + + s := buf.String() + req2, err := ParseRequest(strings.NewReader(s)) + if err != nil { + t.Errorf("ParseRequest(%q) error: %v", s, err) + continue + } + if !msgEqual(&req.Message, &req2.Message) { + t.Errorf("Write/Parse: expected %+v, got %+v", req, req2) + continue + } + } +} + +func TestRequestValidate(t *testing.T) { + for _, tst := range requestTests { + if tst.e != nil { + continue + } + req := &Request{Message{Header{Intent: tst.h + tst.s, Parameters: tst.p}, nil, nil}} + if err := req.Validate(); !errorEqual(tst.v, err) { + t.Errorf("%+v.Validate(): expected error %+v, got %+v (%v)", req, tst.v, err, err) + } + } +} + +func TestRequestGetSet(t *testing.T) { + e := func(k, v string, expect, err error) { + if !errorEqual(err, expect) { + t.Errorf("setting param %q to %q: expected %+v, got %+v (%v)", k, v, expect, err, err) + } + } + c := func(k, v string, expect error, p string) { + if expect == nil && v != p { + t.Errorf("getting param %q: expected %q, got %q", k, v, p) + } + } + + for _, tst := range requestTests { + if tst.e != nil { + continue + } + req, _ := NewRequest(tst.h, tst.s, nil) + for k, v := range tst.p { + switch k { + case "length": + n, _ := strconv.ParseUint(v, 10, 63) + req.SetLength(int64(n)) + s := strconv.FormatInt(req.Length(), 10) + if s == "0" && v == "" { + s = "" + } + c(k, v, tst.v, s) + case "name": + e(k, v, tst.v, req.SetName(v)) + c(k, v, tst.v, req.Name()) + case "type": + e(k, v, tst.v, req.SetType(v)) + t := req.Type() + if t == "application/octet-stream" && v == "" { + t = "" + } + c(k, v, tst.v, t) + case "if_modified": + if tst.v != nil { + continue // invalid time format, can't even parse + } + var tm time.Time + if v != "" { + tm, _ = time.Parse(time.RFC3339, v) + } + req.SetIfModified(tm) + tm2 := "" + if !req.IfModified().IsZero() { + tm2 = req.IfModified().Format(time.RFC3339) + } + c(k, v, tst.v, tm2) + default: + req.SetParam(k, v) + c(k, v, tst.v, req.Param(k)) + } + } + } +} + +var urlTests = map[string]string{ + "œ¤å₥¶ḹə.©°ɱ/foo/bar": "cnp://%C5%93%C2%A4%C3%A5%E2%82%A5%C2%B6%E1%B8%B9%C9%99.%C2%A9%C2%B0%C9%B1/foo/bar", + "2130706433/": "cnp://2130706433/", + "example.com/path/to/file/": "cnp://example.com/path/to/file/", + "[::1]/foo bar": "cnp://[::1]/foo%20bar", + "[2001:db8::7334]/foo\nbar": "cnp://[2001:db8::7334]/foo%0Abar", + "example.com/qwe asd": "cnp://example.com/qwe%20asd", + "example.com/ ™☺)\n": "cnp://example.com/%20%E2%84%A2%E2%98%BA%29%0A", +} + +func TestRequestURL(t *testing.T) { + for k, v := range urlTests { + t.Run(v, func(t *testing.T) { + req, err := NewRequestURL(v, nil) + if err != nil { + t.Fatalf("NewRequestURL(%q): error: %v", v, err) + } + if req.Intent() != k { + t.Fatalf("NewRequestURL(%q).Intent(): expected %q, got %q", v, k, req.Intent()) + } + if req.URL().String() != v { + t.Fatalf("NewRequestURL(%q).URL(): expected %q, got %q", v, v, req.URL()) + } + }) + } +} + +var cleanTests = map[string]string{ + "/../.././//foo/bar/..": "/foo", + "//foo/bar/../": "/foo/", + "/": "/", + "//": "/", + "/..": "/", + "/../..": "/", + "/../": "/", + "/.": "/", + "/./": "/", + "/./.": "/", + "/././": "/", + "/./../": "/", + "/.././": "/", + "/foo/bar/../baz": "/foo/baz", + "/foo/bar/../baz/": "/foo/baz/", + "/foo/../foo/bar/../bar/baz/quux/../": "/foo/bar/baz/", + "/foo/../foo/bar/../bar/baz/quux/..": "/foo/bar/baz", +} + +func TestClean(t *testing.T) { + for k, v := range cleanTests { + t.Run(k, func(t *testing.T) { + c := Clean(k) + if c != v { + t.Fatalf("Clean(%q): expected %q, got %q", k, v, c) + } + }) + } +} diff --git a/response.go b/response.go new file mode 100644 index 0000000..bf23f20 --- /dev/null +++ b/response.go @@ -0,0 +1,249 @@ +package cnp + +import ( + "bytes" + "io" + "strings" + "time" +) + +// Response represents a CNP response message. +type Response struct { + Message +} + +// NewResponse creates a new Response from a response intent and optional body +// data. +func NewResponse(intent string, body []byte) (resp *Response, err error) { + var r io.Reader + if body != nil { + r = bytes.NewReader(body) + } + resp = &Response{*NewMessage("", r)} + err = resp.SetResponseIntent(intent) + return +} + +var responseIntents = map[string]bool{ + IntentOK: true, + IntentNotModified: true, + IntentRedirect: true, + IntentError: true, +} + +// ParseResponse parses a response message. +func ParseResponse(r io.Reader) (*Response, error) { + msg, err := ParseMessage(r) + if msg == nil { + return nil, err + } + return &Response{*msg}, err +} + +// ResponseIntent retrieves the response intent. +// If the intent is unknown, the "error" intent is returned. +func (r *Response) ResponseIntent() string { + s := r.Intent() + if !responseIntents[s] { + return IntentError + } + return s +} + +// SetResponseIntent sets the response intent. +// If the provided intent is not a known response intent, an error is returned +// and the intent is set to "error". +func (r *Response) SetResponseIntent(intent string) error { + if !responseIntents[intent] { + r.SetIntent(IntentError) + return ErrorInvalid{"invalid response: unknown response intent"} + } + r.SetIntent(intent) + return nil +} + +// Name retrieves the name response parameter. +// +// If the name response parameter is not a valid filename, an empty string is +// returned. +func (r *Response) Name() string { + name, err := getFilename(&r.Message, "name") + if err != nil { + return "" + } + return name +} + +// SetName sets the name response parameter. +// +// An error is raised if the name includes characters not valid in a filename +// (slash, null byte). +func (r *Response) SetName(name string) error { + return setFilename(&r.Message, "name", name) +} + +// Type retrieves the type response parameter. +// +// If the type response parameter is invalid or empty, the default value +// "application/octet-stream" is returned. +func (r *Response) Type() string { + typ, _ := getType(&r.Message, "type") + return typ +} + +// SetType sets the type response parameter. +// +// An error is raised if typ is not a valid format for a MIME type. +func (r *Response) SetType(typ string) error { + return setType(&r.Message, "type", typ) +} + +// Time retrieves the time response parameter. +// +// If the parameter isn't a valid RFC3339 timestamp, a zero time.Time is +// returned. +func (r *Response) Time() time.Time { + t, err := getTime(&r.Message, "time") + if err != nil { + return time.Time{} + } + return t +} + +// SetTime sets the time response parameter. +// +// If t is the zero time value, the time parameter is unset. +func (r *Response) SetTime(t time.Time) { + setTime(&r.Message, "time", t) +} + +// Modified retrieves the modified Response parameter. +// +// If the parameter isn't a valid RFC3339 timestamp, a zero time.Time is +// returned. +func (r *Response) Modified() time.Time { + t, err := getTime(&r.Message, "modified") + if err != nil { + return time.Time{} + } + return t +} + +// SetModified sets the modified response parameter. +// +// If the time response parameter is empty, it's set to the current time. +// If t is the zero time value, the modified parameter is unset. +func (r *Response) SetModified(t time.Time) { + setTime(&r.Message, "modified", t) + if r.Time().IsZero() { + r.SetTime(time.Now()) + } +} + +// Location retrieves the host and path from the location response +// parameter. +// +// If the location parameter is empty, it returns empty host and path. If the +// location parameter is invalid, an error is returned. +func (r *Response) Location() (host, path string, err error) { + l := r.Param("location") + if l == "" { + return "", "", nil + } + if err := validateRequestIntent(l); err != nil { + return "", "", err + } + ss := strings.SplitN(l, "/", 2) + return ss[0], "/" + ss[1], nil +} + +// SetLocation sets the location response parameter to host and path. +// +// If the host or path are invalid +func (r *Response) SetLocation(host, path string) error { + if strings.ContainsRune(host, '/') { + return ErrorInvalid{"invalid response: invalid location parameter"} + } + l := host + path + if err := validateRequestIntent(l); err != nil { + return ErrorInvalid{"invalid response: invalid location parameter"} + } + r.SetParam("location", l) + return nil +} + +var responseErrorReasons = map[string]bool{ + ReasonSyntax: true, + ReasonVersion: true, + ReasonInvalid: true, + ReasonNotSupported: true, + ReasonTooLarge: true, + ReasonNotFound: true, + ReasonDenied: true, + ReasonRejected: true, + ReasonServerError: true, + "": true, +} + +// Reason retrieves the reason response parameter. +// +// If the reason is nonempty and unknown, "server_error" is returned. +func (r *Response) Reason() string { + reason := r.Param("reason") + if _, ok := responseErrorReasons[reason]; ok { + return reason + } + return ReasonServerError +} + +// SetReason sets the reason response parameter. +// +// If the reason is nonempty and unknown, it sets "server_error" instead. +func (r *Response) SetReason(reason string) error { + if _, ok := responseErrorReasons[reason]; !ok { + r.SetParam("reason", ReasonServerError) + return ErrorInvalid{"invalid response: unknown error reason"} + } + r.SetParam("reason", reason) + return nil +} + +// Validate validates the response intent and header parameter value format +// (length, name, type, time, modified, location, reason) +func (r *Response) Validate() error { + if !responseIntents[r.Intent()] { + return ErrorInvalid{"invalid response: unknown response intent"} + } + if err := r.Message.Validate(); err != nil { + return err + } + if _, err := getFilename(&r.Message, "name"); err != nil { + return err + } + if _, err := getType(&r.Message, "type"); err != nil { + return err + } + if _, err := getTime(&r.Message, "time"); err != nil { + return err + } + if _, err := getTime(&r.Message, "modified"); err != nil { + return err + } + if h, p, err := r.Location(); err != nil { + return err + } else if r.ResponseIntent() == IntentRedirect && h == "" && p == "" { + return ErrorInvalid{"invalid response: redirect response needs location parameter"} + } + if !responseErrorReasons[r.Param("reason")] { + return ErrorInvalid{"invalid response: unknown error reason"} + } + return nil +} + +// Write writes the response to w. +func (r *Response) Write(w io.Writer) error { + if _, ok := r.Header.Parameters["length"]; !ok { + r.TryComputeLength() + } + return r.Message.Write(w) +} diff --git a/response_test.go b/response_test.go new file mode 100644 index 0000000..8033335 --- /dev/null +++ b/response_test.go @@ -0,0 +1,317 @@ +package cnp + +import ( + "bytes" + "strconv" + "strings" + "testing" + "time" +) + +var ( + responseTests = []responseTest{ + // invalid intent + {"", nil, ErrorInvalid{}, ErrorInvalid{}}, + {"foo", nil, ErrorInvalid{}, ErrorInvalid{}}, + {"example.com/path", nil, ErrorInvalid{}, ErrorInvalid{}}, + {"errors", nil, ErrorInvalid{}, ErrorInvalid{}}, + {" ok", nil, ErrorInvalid{}, ErrorInvalid{}}, + {"ok ", nil, ErrorInvalid{}, ErrorInvalid{}}, + {"оk", nil, ErrorInvalid{}, ErrorInvalid{}}, + + // invalid response params + {"ok", Parameters{"length": "w"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"length": "-1"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"length": "03"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"name": "/.."}, nil, ErrorInvalid{}}, + {"ok", Parameters{"name": "/"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"name": "foo/bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"name": "foo/bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"name": "foo\x00bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "\x00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "text/plain\x00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo/bar "}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": " foo/bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo /bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo/ bar"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo/bar\n"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"type": "foo/b(r"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "now"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "today"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "Thu Jan 1 00:00:00 UTC 1970"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01 00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01 00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01 00:00:00+0000"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01 00:00:00+00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01T00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01T00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01T00:00:00+0000"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1970-01-01T00:00:00+00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-00-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-01-00T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-01-01T24:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-01-01T00:60:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-01-01T00:00:60Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0000-11-31T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0001-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0002-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0003-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0005-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "0100-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "1000-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "123-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "12345-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "-5-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"time": "-2005-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "now"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "today"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "Thu Jan 1 00:00:00 UTC 1970"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01 00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01 00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01 00:00:00+0000"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01 00:00:00+00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01T00:00:00+00:00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01T00:00:00 UTC"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01T00:00:00+0000"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1970-01-01T00:00:00+00"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-00-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-01-00T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-01-01T24:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-01-01T00:60:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-01-01T00:00:60Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0000-11-31T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0001-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0002-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0003-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0005-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "0100-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "1000-02-29T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "123-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "12345-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "-5-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"ok", Parameters{"modified": "-2005-01-01T00:00:00Z"}, nil, ErrorInvalid{}}, + {"redirect", Parameters{"location": "foo"}, nil, ErrorInvalid{}}, + {"redirect", Parameters{"location": "foo bar/baz quux"}, nil, ErrorInvalid{}}, + {"redirect", Parameters{"location": "/foo\x00bar"}, nil, ErrorInvalid{}}, + {"error", Parameters{"reason": "ok"}, nil, ErrorInvalid{}}, + {"error", Parameters{"reason": "not supported"}, nil, ErrorInvalid{}}, + {"error", Parameters{"reason": "syntax\n"}, nil, ErrorInvalid{}}, + {"error", Parameters{"reason": " server_error"}, nil, ErrorInvalid{}}, + {"error", Parameters{"reason": "invalid "}, nil, ErrorInvalid{}}, + + // invalid: redirect *requires* the location parameter + {"redirect", nil, nil, ErrorInvalid{}}, + {"redirect", Parameters{"location": ""}, nil, ErrorInvalid{}}, + + // valid simple responses + {"ok", nil, nil, nil}, + {"not_modified", nil, nil, nil}, + {"error", nil, nil, nil}, + + // valid responses with parameters + {"ok", Parameters{"length": "", "name": "", "type": "", "time": "", "reason": "", "location": "", "modified": "", "": "", "q\x00we": "=a s\nd"}, nil, nil}, + + {"ok", Parameters{"length": "0"}, nil, nil}, + {"ok", Parameters{"length": "1"}, nil, nil}, + {"ok", Parameters{"length": "12345670089000000"}, nil, nil}, + {"ok", Parameters{"length": "12345678900"}, nil, nil}, + + {"ok", Parameters{"name": "foobar"}, nil, nil}, + {"ok", Parameters{"name": "foo bar"}, nil, nil}, + {"ok", Parameters{"name": "foo=bar\nbaz\rquux"}, nil, nil}, + {"ok", Parameters{"name": "..-~!foo bar\nbaz\rquux=qwe\\asd"}, nil, nil}, + {"ok", Parameters{"name": strings.Repeat("w", 1024*8)}, nil, nil}, + {"ok", Parameters{"name": " "}, nil, nil}, + {"ok", Parameters{"name": ".."}, nil, nil}, + {"ok", Parameters{"name": "."}, nil, nil}, + + {"ok", Parameters{"type": "foo/bar"}, nil, nil}, + {"ok", Parameters{"type": "application/octet-stream"}, nil, nil}, + {"ok", Parameters{"type": "x-test/x-testing"}, nil, nil}, + {"ok", Parameters{"type": "application/vnd.testing.test-test.5+xml"}, nil, nil}, + + {"ok", Parameters{"modified": "1970-01-01T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"modified": "0000-01-01T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"modified": "9999-12-31T23:59:59Z"}, nil, nil}, + {"ok", Parameters{"modified": "0123-05-06T07:08:09Z"}, nil, nil}, + {"ok", Parameters{"modified": "0000-02-29T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"modified": "2000-02-29T00:00:00Z"}, nil, nil}, + + {"ok", Parameters{"time": "1970-01-01T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"time": "0000-01-01T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"time": "9999-12-31T23:59:59Z"}, nil, nil}, + {"ok", Parameters{"time": "0123-05-06T07:08:09Z"}, nil, nil}, + {"ok", Parameters{"time": "0000-02-29T00:00:00Z"}, nil, nil}, + {"ok", Parameters{"time": "2000-02-29T00:00:00Z"}, nil, nil}, + + {"error", Parameters{"reason": "syntax"}, nil, nil}, + {"error", Parameters{"reason": "version"}, nil, nil}, + {"error", Parameters{"reason": "invalid"}, nil, nil}, + {"error", Parameters{"reason": "not_supported"}, nil, nil}, + {"error", Parameters{"reason": "too_large"}, nil, nil}, + {"error", Parameters{"reason": "not_found"}, nil, nil}, + {"error", Parameters{"reason": "denied"}, nil, nil}, + {"error", Parameters{"reason": "rejected"}, nil, nil}, + {"error", Parameters{"reason": "server_error"}, nil, nil}, + + {"redirect", Parameters{"location": "/"}, nil, nil}, + {"redirect", Parameters{"location": "foo/bar"}, nil, nil}, + {"redirect", Parameters{"location": "foo/"}, nil, nil}, + {"redirect", Parameters{"location": "/bar"}, nil, nil}, + {"redirect", Parameters{"location": "[::1]:12345/ foo\n\x01\xff/"}, nil, nil}, + {"redirect", Parameters{"location": "/../../////././.."}, nil, nil}, + } +) + +type responseTest struct { + i string + p Parameters + e, v error +} + +func TestNewResponse(t *testing.T) { + for _, tst := range responseTests { + resp, err := NewResponse(tst.i, []byte{}) + if !errorEqual(tst.e, err) { + t.Errorf("NewResponse(%q): expected error %+v, got %+v (%v)", tst.i, tst.e, err, err) + continue + } + if tst.e == nil { + if tst.i != resp.ResponseIntent() { + t.Errorf("NewResponse(%q): got unexpected intent %q", tst.i, resp.ResponseIntent()) + } + } + } +} + +func TestWriteParseResponse(t *testing.T) { + for _, tst := range responseTests { + if tst.e != nil { + continue // skip invalid intents + } + resp := &Response{Message{Header{0, 3, "ok", Parameters{}}, nil, nil}} + if err := resp.SetResponseIntent(tst.i); err != nil { + t.Errorf("SetResponseIntent(%q) error: %v", tst.i, err) + continue + } + for k, v := range tst.p { + resp.SetParam(k, v) + } + + var buf bytes.Buffer + if err := resp.Write(&buf); err != nil { + t.Errorf("%+v.Write: error %v", resp, err) + continue + } + + s := buf.String() + resp2, err := ParseResponse(strings.NewReader(s)) + if err != nil { + t.Errorf("ParseResponse(%q) error: %v", s, err) + continue + } + if !msgEqual(&resp.Message, &resp2.Message) { + t.Errorf("Write/Parse: expected %+v, got %+v", resp, resp2) + continue + } + } +} + +func TestResponseValidate(t *testing.T) { + for _, tst := range responseTests { + resp := &Response{Message{Header{Intent: tst.i, Parameters: tst.p}, nil, nil}} + if err := resp.Validate(); !errorEqual(tst.v, err) { + t.Errorf("%+v.Validate(): expected error %+v, got %+v (%v)", resp, tst.v, err, err) + } + } +} + +func TestResponseGetSet(t *testing.T) { + e := func(k, v string, expect, err error) { + if !errorEqual(err, expect) { + t.Errorf("setting param %q to %q: expected %+v, got %+v (%v)", k, v, expect, err, err) + } + } + c := func(k, v string, expect error, p string) { + if expect == nil && v != p { + t.Errorf("getting param %q: expected %q, got %q", k, v, p) + } + } + + for _, tst := range responseTests { + resp, _ := NewResponse("ok", nil) + if err := resp.SetResponseIntent(tst.i); !errorEqual(err, tst.e) { + t.Errorf("setting response intent to %q: expected %+v, got %+v (%v)", tst.i, tst.e, err, err) + continue + } + if tst.e == nil && resp.ResponseIntent() != tst.i { + t.Errorf("getting response intent: expected %q, got %q", tst.i, resp.ResponseIntent()) + continue + } + for k, v := range tst.p { + switch k { + case "length": + n, _ := strconv.ParseUint(v, 10, 63) + resp.SetLength(int64(n)) + s := strconv.FormatInt(resp.Length(), 10) + if s == "0" && v == "" { + s = "" + } + c(k, v, tst.v, s) + case "name": + e(k, v, tst.v, resp.SetName(v)) + c(k, v, tst.v, resp.Name()) + case "type": + e(k, v, tst.v, resp.SetType(v)) + t := resp.Type() + if t == "application/octet-stream" && v == "" { + t = "" + } + c(k, v, tst.v, t) + case "time": + var tm time.Time + if v != "" { + tm, _ = time.Parse(time.RFC3339, v) + } + resp.SetTime(tm) + tm2 := "" + if !resp.Time().IsZero() { + tm2 = resp.Time().Format(time.RFC3339) + } + c(k, v, tst.v, tm2) + case "modified": + var tm time.Time + if v != "" { + tm, _ = time.Parse(time.RFC3339, v) + } + resp.SetModified(tm) + tm2 := "" + if !resp.Modified().IsZero() { + tm2 = resp.Modified().Format(time.RFC3339) + } + c(k, v, tst.v, tm2) + case "location": + ss := strings.SplitN(v, "/", 2) + if len(ss) != 2 { + continue // invalid location + } + e(k, v, tst.v, resp.SetLocation(ss[0], "/"+ss[1])) + host, path, err := resp.Location() + if err != nil { + t.Errorf("getting parameter location: error %v", err) + } else { + c(k, v, tst.v, host+path) + } + case "reason": + e(k, v, tst.v, resp.SetReason(v)) + c(k, v, tst.v, resp.Reason()) + default: + resp.SetParam(k, v) + c(k, v, tst.v, resp.Param(k)) + } + } + } +} diff --git a/server.go b/server.go new file mode 100644 index 0000000..3413923 --- /dev/null +++ b/server.go @@ -0,0 +1,257 @@ +package cnp + +import ( + "bytes" + "errors" + "io" + "log" + "net" + "os" + "strconv" + "strings" + "time" +) + +// TODO: make more modular and extensible like net/http + +// Server represents a CNP server. +type Server struct { + // LogAccess is called for every finished response if it's non-nil. + LogAccess func(resp ResponseWriter, req *Request, respIntent string, respBytes int64) + + // LogError is called when an error happens if it's non-nil. + LogError func(err interface{}) + + // AccessLog is used to log finished responses if LogAccess is nil. + AccessLogger *log.Logger + + // ErrorLogger is used to log errors if LogError is nil. + ErrorLogger *log.Logger + + // Address is the host:port that the server listens on. + Address string + + // Handler is used to handle received requests. + Handler Handler + + // Validate enables request parameter value validation; invalid requests + // are responded with errors. + Validate bool + + sock net.Conn +} + +// NewServer creates a new Server with default access and errors logs and sets +// the listen address to "localhost". +func NewServer() *Server { + return &Server{ + AccessLogger: log.New(os.Stdout, "", 0), + ErrorLogger: log.New(os.Stderr, "error: ", log.LstdFlags), + Validate: true, + Address: "localhost", + } +} + +// ListenAndServe uses net.Listen to listen on TCP srv.Address for new +// requests, then calls srv.Serve. +func (srv *Server) ListenAndServe() error { + addr := srv.Address + if strings.LastIndexByte(addr, ':') <= strings.LastIndexByte(addr, ']') || + strings.Count(addr, ":") > 1 && !strings.HasPrefix(addr, "[") { // missing/default port + addr = net.JoinHostPort(addr, strconv.Itoa(DefaultPort)) + } + l, err := net.Listen("tcp", addr) + if err != nil { + return err + } + return srv.Serve(l) +} + +// Serve listens on l for new connections and dispatches HandleConn goroutines. +func (srv *Server) Serve(l net.Listener) error { + defer l.Close() + + for { + conn, err := l.Accept() + if err != nil { + return err + } + go srv.HandleConn(conn) + } +} + +func (srv *Server) sendError(conn net.Conn, req *Request, err Error) { + er, _ := NewResponse(IntentError, []byte(err.Error()+"\n")) + er.SetParam("reason", err.CNPError()) + er.SetParam("type", "text/plain") + var buf bytes.Buffer + er.Write(&buf) + er.SetLength(int64(buf.Len())) + l, e2 := io.Copy(conn, &buf) + if e2 != nil { + srv.logError(e2) + } + srv.logAccess(&responseWriter{addr: conn.RemoteAddr()}, req, er.Intent(), l) +} + +// HandleConn reads a CNP request from conn and runs a handler to respond. +func (srv *Server) HandleConn(conn net.Conn) { + var rw *responseWriter + var req *Request + + defer func() { + /*_, err := io.Copy(ioutil.Discard, req.Body) + if err != nil { + srv.ErrorLog.Print(err) + }*/ + + if rw != nil && rw.headerWritten { + srv.logAccess(rw, req, rw.resp.Header.Intent, rw.n) + } + + if rec := recover(); rec != nil { + srv.logError(rec) + if err, ok := rec.(Error); ok && rw != nil && !rw.headerWritten { + srv.sendError(conn, req, err) + } + } + + if req != nil { + req.Close() + } + }() + + req, err := ParseRequest(conn) + req.Body = io.LimitReader(req.Body, req.Length()) + if err != nil { + if e, ok := err.(Error); ok { + resp, _ := NewResponse(IntentError, nil) + resp.SetParam("reason", e.CNPError()) + resp.Write(conn) + return + } + panic(err) + } + + if srv.Validate { + err = req.Validate() + if err != nil { + srv.sendError(conn, req, err.(Error)) + return + } + } + + if srv.Handler != nil { + resp, _ := NewResponse(IntentOK, nil) + rw = &responseWriter{ + w: conn, + resp: resp, + addr: conn.RemoteAddr(), + } + srv.Handler.ServeCNP(rw, req) + if !rw.headerWritten { + rw.WriteHeader() + } + } +} + +func (srv *Server) logAccess(resp ResponseWriter, req *Request, respIntent string, respBytes int64) { + if srv.LogAccess != nil { + srv.LogAccess(resp, req, respIntent, respBytes) + } else if srv.AccessLogger != nil { + srv.AccessLogger.Printf("%s - - %s %q %s %d", + resp.RemoteAddr(), + time.Now().Format("[02/Jan/2006:03:04:05 -0700]"), + req.Header.Version()+" "+string(Escape(req.Host()))+string(Escape(req.Path())), + respIntent, + respBytes, + ) + } +} + +func (srv *Server) logError(err interface{}) { + if srv.LogError != nil { + srv.LogError(err) + } else if srv.ErrorLogger != nil { + srv.ErrorLogger.Println(err) + } +} + +// Handler handles CNP requests accepted by the server. +type Handler interface { + // ServeCNP responds to a CNP request. + // + // This function must be safe for concurrent use. + ServeCNP(resp ResponseWriter, req *Request) +} + +// HandlerFunc allows using raw functions as handlers. +type HandlerFunc func(resp ResponseWriter, req *Request) + +// ServeCNP calls h(resp, req). +func (h HandlerFunc) ServeCNP(resp ResponseWriter, req *Request) { + h(resp, req) +} + +// ResponseWriter is used by a CNP server to write responses to CNP requests. +type ResponseWriter interface { + // Response returns a Response object whose header will be written to the + // socket. The body is nil and should be ignored. + Response() *Response + + // RemoteAddr returns the network address of the client. + RemoteAddr() net.Addr + + // WriteHeader sends a CNP header with an intent. + WriteHeader() error + + // Write sends data in the CNP response body. + // + // If WriteHeader has not been called yet, it also calls WriteHeader("ok"). + Write(data []byte) (int, error) +} + +type responseWriter struct { + w io.Writer + addr net.Addr + resp *Response + srv *Server + n int64 + headerWritten bool +} + +func (r *responseWriter) Response() *Response { + return r.resp +} + +func (r *responseWriter) RemoteAddr() net.Addr { + return r.addr +} + +func (r *responseWriter) WriteHeader() error { + if r.headerWritten { + err := errors.New("multiple WriteHeader calls") + r.srv.logError(err) + return err + } + r.headerWritten = true + return r.resp.Header.Write(r) +} + +func (r *responseWriter) Write(data []byte) (int, error) { + if !r.headerWritten { + r.WriteHeader() + } + n, err := r.w.Write(data) + r.n += int64(n) + return n, err +} + +// ListenAndServe creates a new Server with a listen address and a handler and +// calls its ListenAndServe method. +func ListenAndServe(addr string, handler Handler) error { + srv := NewServer() + srv.Address = addr + srv.Handler = handler + return srv.ListenAndServe() +} -- cgit