diff --git a/protocol/rtsp/client.go b/protocol/rtsp/client.go new file mode 100644 index 00000000..26e539db --- /dev/null +++ b/protocol/rtsp/client.go @@ -0,0 +1,134 @@ +/* +NAME + client.go + +DESCRIPTION + client.go provides a Client type providing functionality to send RTSP requests + of methods DESCRIBE, OPTIONS, SETUP and PLAY to an RTSP server. + +AUTHORS + Saxon A. Nelson-Milton + +LICENSE + This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean). + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + in gpl.txt. If not, see http://www.gnu.org/licenses. +*/ + +package rtsp + +import ( + "net" + "net/url" + "strconv" +) + +// Client describes an RTSP Client. +type Client struct { + cSeq int + addr string + url *url.URL + conn net.Conn + sessionID string +} + +// NewClient returns a pointer to a new Client. The address addr will be parsed and +// a connection to the RTSP server will be made. +func NewClient(addr string) (*Client, error) { + c := &Client{addr: addr} + var err error + c.url, err = url.Parse(addr) + if err != nil { + return nil, err + } + c.conn, err = net.Dial("tcp", c.url.Host) + if err != nil { + return nil, err + } + return c, nil +} + +// Describe forms and sends an RTSP request of method DESCRIBE to the RTSP server. +func (c *Client) Describe() (*Response, error) { + req, err := NewRequest("DESCRIBE", c.nextCSeq(), c.url, nil) + if err != nil { + return nil, err + } + req.Header.Add("Accept", "application/sdp") + return c.Do(req) +} + +// Options forms and sends an RTSP request of method OPTIONS to the RTSP server. +func (c *Client) Options() (*Response, error) { + req, err := NewRequest("OPTIONS", c.nextCSeq(), c.url, nil) + if err != nil { + return nil, err + } + return c.Do(req) +} + +// Setup forms and sends an RTSP request of method SETUP to the RTSP server. +func (c *Client) Setup(track, transport string) (*Response, error) { + u, err := url.Parse(c.addr + "/" + track) + if err != nil { + return nil, err + } + + req, err := NewRequest("SETUP", c.nextCSeq(), u, nil) + if err != nil { + return nil, err + } + req.Header.Add("Transport", transport) + + resp, err := c.Do(req) + if err != nil { + return nil, err + } + c.sessionID = resp.Header.Get("Session") + + return resp, err +} + +// Play forms and sends an RTSP request of method PLAY to the RTSP server +func (c *Client) Play() (*Response, error) { + req, err := NewRequest("PLAY", c.nextCSeq(), c.url, nil) + if err != nil { + return nil, err + } + req.Header.Add("Session", c.sessionID) + + return c.Do(req) +} + +// Do sends the given RTSP request req, reads any responses and returns the response +// and any errors. +func (c *Client) Do(req *Request) (*Response, error) { + err := req.Write(c.conn) + if err != nil { + return nil, err + } + + resp, err := ReadResponse(c.conn) + if err != nil { + return nil, err + } + + return resp, nil +} + +// nextCSeq provides the next CSeq number for the next RTSP request. +func (c *Client) nextCSeq() string { + c.cSeq++ + return strconv.Itoa(c.cSeq) +} diff --git a/protocol/rtsp/cmd/record/main.go b/protocol/rtsp/cmd/record/main.go new file mode 100644 index 00000000..536e0068 --- /dev/null +++ b/protocol/rtsp/cmd/record/main.go @@ -0,0 +1,78 @@ +/* +NAME + record + +DESCRIPTION + record provides a program to connect to an RTSP server, request for an + RTP stream and then save the RTP payload to file. + +AUTHORS + Saxon A. Nelson-Milton + +LICENSE + This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean). + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + in gpl.txt. If not, see http://www.gnu.org/licenses. +*/ + +package main + +import ( + "flag" + "fmt" + "log" + + "bitbucket.org/ausocean/av/protocol/rtsp" +) + +func main() { + rtspServerPtr := flag.String("rtsp-server", "", "The RTSP server we would like to get video from.") + clientPortPtr := flag.Uint("port", 6870, "The port on the client we would like to receive RTP on.") + trackPtr := flag.String("track", "track1", "The track that we would like to receive media from.") + flag.Parse() + + clt, err := rtsp.NewClient(*rtspServerPtr) + if err != nil { + panic(fmt.Sprintf("creating RTSP client failed with error: %v", err)) + } + + resp, err := clt.Options() + if err != nil { + log.Fatalln(err) + } + fmt.Println("Options:") + fmt.Println(resp) + + resp, err = clt.Describe() + if err != nil { + log.Fatalln(err) + } + fmt.Println("Describe:") + fmt.Println(resp) + + resp, err = clt.Setup(*trackPtr, fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", *clientPortPtr, *clientPortPtr+1)) + if err != nil { + log.Fatalln(err) + } + log.Println(resp) + + resp, err = clt.Play() + if err != nil { + log.Fatalln(err) + } + log.Println(resp) + + // TODO(saxon): use RTCP client here to maintain stream. + select {} +} diff --git a/protocol/rtsp/rtsp.go b/protocol/rtsp/rtsp.go new file mode 100644 index 00000000..9e0995c8 --- /dev/null +++ b/protocol/rtsp/rtsp.go @@ -0,0 +1,182 @@ +/* +NAME + rtsp.go + +DESCRIPTION + rtsp.go provides functionality for forming and sending RTSP requests for + methods, DESCRIBE, OPTIONS, SETUP and PLAY, as described by + the RTSP standards, see https://tools.ietf.org/html/rfc7826 + +AUTHORS + Saxon A. Nelson-Milton + +LICENSE + This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean). + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + in gpl.txt. If not, see http://www.gnu.org/licenses. +*/ + +// Package rtsp provides an RTSP client implementation and methods for +// communication with an RTSP server to request video. +package rtsp + +import ( + "bufio" + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "strconv" + "strings" +) + +// Minimum response size to be considered valid in bytes. +const minResponse = 12 + +var errInvalidResponse = errors.New("invalid response") + +// Request describes an RTSP request. +type Request struct { + Method string + URL *url.URL + Proto string + ProtoMajor int + ProtoMinor int + Header http.Header + ContentLength int + Body io.ReadCloser +} + +// NewRequest returns a pointer to a new Request. +func NewRequest(method, cSeq string, u *url.URL, body io.ReadCloser) (*Request, error) { + req := &Request{ + Method: method, + URL: u, + Proto: "RTSP", + ProtoMajor: 1, + ProtoMinor: 0, + Header: map[string][]string{"CSeq": []string{cSeq}}, + Body: body, + } + return req, nil +} + +// Write writes the request r to the given io.Writer w. +func (r *Request) Write(w io.Writer) error { + _, err := w.Write([]byte(r.String())) + return err +} + +// String returns a formatted string of the Request. +func (r Request) String() string { + var b strings.Builder + fmt.Fprintf(&b, "%s %s %s/%d.%d\r\n", r.Method, r.URL.String(), r.Proto, r.ProtoMajor, r.ProtoMinor) + for k, v := range r.Header { + for _, v := range v { + fmt.Fprintf(&b, "%s: %s\r\n", k, v) + } + } + b.WriteString("\r\n") + if r.Body != nil { + s, _ := ioutil.ReadAll(r.Body) + b.WriteString(string(s)) + } + return b.String() +} + +// Response describes an RTSP response. +type Response struct { + Proto string + ProtoMajor int + ProtoMinor int + StatusCode int + ContentLength int + Header http.Header + Body io.ReadCloser +} + +// String returns a formatted string of the Response. +func (r Response) String() string { + var b strings.Builder + fmt.Fprintf(&b, "%s/%d.%d %d\n", r.Proto, r.ProtoMajor, r.ProtoMinor, r.StatusCode) + for k, v := range r.Header { + for _, v := range v { + fmt.Fprintf(&b, "%s: %s", k, v) + } + } + return b.String() +} + +// ReadResponse will read the response of the RTSP request from the connection, +// and return a pointer to a new Response. +func ReadResponse(r io.Reader) (*Response, error) { + resp := &Response{Header: make(map[string][]string)} + + scanner := bufio.NewScanner(r) + + // Read the first line. + scanner.Scan() + err := scanner.Err() + if err != nil { + return nil, err + } + s := scanner.Text() + + if len(s) < minResponse || !strings.HasPrefix(s, "RTSP/") { + return nil, errInvalidResponse + } + resp.Proto = "RTSP" + + n, err := fmt.Sscanf(s[5:], "%d.%d %d", &resp.ProtoMajor, &resp.ProtoMinor, &resp.StatusCode) + if err != nil || n != 3 { + return nil, fmt.Errorf("could not Sscanf response, error: %v", err) + } + + // Read headers. + for scanner.Scan() { + err = scanner.Err() + if err != nil { + return nil, err + } + parts := strings.SplitN(scanner.Text(), ":", 2) + if len(parts) < 2 { + break + } + resp.Header.Add(strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1])) + } + // Get the content length from the header. + resp.ContentLength, _ = strconv.Atoi(resp.Header.Get("Content-Length")) + + resp.Body = closer{r} + return resp, nil +} + +type closer struct { + io.Reader +} + +func (c closer) Close() error { + if c.Reader == nil { + return nil + } + defer func() { + c.Reader = nil + }() + if r, ok := c.Reader.(io.ReadCloser); ok { + return r.Close() + } + return nil +} diff --git a/protocol/rtsp/rtsp_test.go b/protocol/rtsp/rtsp_test.go new file mode 100644 index 00000000..104f6b63 --- /dev/null +++ b/protocol/rtsp/rtsp_test.go @@ -0,0 +1,344 @@ +/* +NAME + 0x r,tsp_test.go + +DESCRIPTION + rtsp_test.go provides a test to check functionality provided in rtsp.go. + +AUTHORS + Saxon A. Nelson-Milton + +LICENSE + This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean). + + It is free software: you can redistribute it and/or modify them + under the terms of the GNU General Public License as published by the + Free Software Foundation, either version 3 of the License, or (at your + option) any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + in gpl.txt. If not, see http://www.gnu.org/licenses. +*/ + +package rtsp + +import ( + "bytes" + "errors" + "fmt" + "io" + "net" + "net/url" + "strings" + "testing" + "time" + "unicode" +) + +// The max request size we should get in bytes. +const maxRequest = 1024 + +// TestMethods checks that we can correctly form requests for each of the RTSP +// methods supported in the rtsp pkg. This test also checks that communication +// over a TCP connection is performed correctly. +func TestMethods(t *testing.T) { + const dummyURL = "rtsp://admin:admin@192.168.0.50:8554/CH001.sdp" + url, err := url.Parse(dummyURL) + if err != nil { + t.Fatalf("could not parse dummy address, failed with err: %v", err) + } + + // tests holds tests which consist of a function used to create and write a + // request of a particular method, and also the expected request bytes + // to be received on the server side. The bytes in these tests have been + // obtained from a valid RTSP communication cltion.. + tests := []struct { + method func(c *Client) (*Response, error) + expected []byte + }{ + { + method: func(c *Client) (*Response, error) { + req, err := NewRequest("DESCRIBE", c.nextCSeq(), url, nil) + if err != nil { + return nil, err + } + req.Header.Add("Accept", "application/sdp") + return c.Do(req) + }, + expected: []byte{ + 0x44, 0x45, 0x53, 0x43, 0x52, 0x49, 0x42, 0x45, 0x20, 0x72, 0x74, 0x73, 0x70, 0x3a, 0x2f, 0x2f, // |DESCRIBE rtsp://| + 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x3a, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x40, 0x31, 0x39, 0x32, 0x2e, // |admin:admin@192.| + 0x31, 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x35, 0x30, 0x3a, 0x38, 0x35, 0x35, 0x34, 0x2f, 0x43, 0x48, // |168.0.50:8554/CH| + 0x30, 0x30, 0x31, 0x2e, 0x73, 0x64, 0x70, 0x20, 0x52, 0x54, 0x53, 0x50, 0x2f, 0x31, 0x2e, 0x30, // |001.sdp RTSP/1.0| + 0x0d, 0x0a, 0x43, 0x53, 0x65, 0x71, 0x3a, 0x20, 0x32, 0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, // |..CSeq: 2..Accep| + 0x74, 0x3a, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x73, // |t: application/s| + 0x64, 0x70, 0x0d, 0x0a, 0x0d, 0x0a, /* */ // |dp....| + }, + }, + { + method: func(c *Client) (*Response, error) { + req, err := NewRequest("OPTIONS", c.nextCSeq(), url, nil) + if err != nil { + return nil, err + } + return c.Do(req) + }, + expected: []byte{ + 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20, 0x72, 0x74, 0x73, 0x70, 0x3a, 0x2f, 0x2f, 0x61, // |OPTIONS rtsp://a| + 0x64, 0x6d, 0x69, 0x6e, 0x3a, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x40, 0x31, 0x39, 0x32, 0x2e, 0x31, // |dmin:admin@192.1| + 0x36, 0x38, 0x2e, 0x30, 0x2e, 0x35, 0x30, 0x3a, 0x38, 0x35, 0x35, 0x34, 0x2f, 0x43, 0x48, 0x30, // |68.0.50:8554/CH0| + 0x30, 0x31, 0x2e, 0x73, 0x64, 0x70, 0x20, 0x52, 0x54, 0x53, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x0d, // |01.sdp RTSP/1.0.| + 0x0a, 0x43, 0x53, 0x65, 0x71, 0x3a, 0x20, 0x31, 0x0d, 0x0a, 0x0d, 0x0a, /* */ // |.CSeq: 1....| + }, + }, + { + method: func(c *Client) (*Response, error) { + u, err := url.Parse(dummyURL + "/track1") + if err != nil { + return nil, err + } + + req, err := NewRequest("SETUP", c.nextCSeq(), u, nil) + if err != nil { + return nil, err + } + req.Header.Add("Transport", fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", 6870, 6871)) + + return c.Do(req) + }, + expected: []byte{ + 0x53, 0x45, 0x54, 0x55, 0x50, 0x20, 0x72, 0x74, 0x73, 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x64, 0x6d, // |SETUP rtsp://adm| + 0x69, 0x6e, 0x3a, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x40, 0x31, 0x39, 0x32, 0x2e, 0x31, 0x36, 0x38, // |in:admin@192.168| + 0x2e, 0x30, 0x2e, 0x35, 0x30, 0x3a, 0x38, 0x35, 0x35, 0x34, 0x2f, 0x43, 0x48, 0x30, 0x30, 0x31, // |.0.50:8554/CH001| + 0x2e, 0x73, 0x64, 0x70, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x31, 0x20, 0x52, 0x54, 0x53, 0x50, // |.sdp/track1 RTSP| + 0x2f, 0x31, 0x2e, 0x30, 0x0d, 0x0a, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x3a, // |/1.0..Transport:| + 0x20, 0x52, 0x54, 0x50, 0x2f, 0x41, 0x56, 0x50, 0x3b, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, // | RTP/AVP;unicast| + 0x3b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x3d, 0x36, 0x38, 0x37, // |;client_port=687| + 0x30, 0x2d, 0x36, 0x38, 0x37, 0x31, 0x0d, 0x0a, 0x43, 0x53, 0x65, 0x71, 0x3a, 0x20, 0x33, 0x0d, // |0-6871..CSeq: 3.| + 0x0a, 0x0d, 0x0a, /* */ // |...| + }, + }, + { + method: func(c *Client) (*Response, error) { + req, err := NewRequest("PLAY", c.nextCSeq(), url, nil) + if err != nil { + return nil, err + } + req.Header.Add("Session", "00000021") + + return c.Do(req) + }, + expected: []byte{ + 0x50, 0x4c, 0x41, 0x59, 0x20, 0x72, 0x74, 0x73, 0x70, 0x3a, 0x2f, 0x2f, 0x61, 0x64, 0x6d, 0x69, // |PLAY rtsp://admi| + 0x6e, 0x3a, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x40, 0x31, 0x39, 0x32, 0x2e, 0x31, 0x36, 0x38, 0x2e, // |n:admin@192.168.| + 0x30, 0x2e, 0x35, 0x30, 0x3a, 0x38, 0x35, 0x35, 0x34, 0x2f, 0x43, 0x48, 0x30, 0x30, 0x31, 0x2e, // |0.50:8554/CH001.| + 0x73, 0x64, 0x70, 0x20, 0x52, 0x54, 0x53, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x0d, 0x0a, 0x43, 0x53, // |sdp RTSP/1.0..CS| + 0x65, 0x71, 0x3a, 0x20, 0x34, 0x0d, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x3a, 0x20, // |eq: 4..Session: | + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x0d, 0x0a, 0x0d, 0x0a, /* */ // |00000021....| + }, + }, + } + + const serverAddr = "rtsp://localhost:8005" + const retries = 10 + + clientErr := make(chan error) + serverErr := make(chan error) + done := make(chan struct{}) + + // This routine acts as the server. + go func() { + l, err := net.Listen("tcp", strings.TrimLeft(serverAddr, "rtsp://")) + if err != nil { + serverErr <- errors.New(fmt.Sprintf("server could not listen, error: %v", err)) + } + + conn, err := l.Accept() + if err != nil { + serverErr <- errors.New(fmt.Sprintf("server could not accept connection, error: %v", err)) + } + + buf := make([]byte, maxRequest) + var n int + for i, test := range tests { + loop: + for { + n, err = conn.Read(buf) + err, ok := err.(net.Error) + + switch { + case err == nil: + break loop + case err == io.EOF: + case ok && err.Timeout(): + default: + serverErr <- errors.New(fmt.Sprintf("server could not read conn, error: %v", err)) + return + } + } + + // Write a dummy response, client won't care. + conn.Write([]byte{'\n'}) + + want := test.expected + got := buf[:n] + if !equal(got, want) { + serverErr <- errors.New(fmt.Sprintf("unexpected result for test: %v. \nGot: %v\n Want: %v\n", i, got, want)) + } + } + close(done) + }() + + // This routine acts as the client. + go func() { + var clt *Client + var err error + + // Keep trying to connect to server. + // TODO: use generalised retry utility when available. + for retry := 0; ; retry++ { + clt, err = NewClient(serverAddr) + if err == nil { + break + } + + if retry > retries { + clientErr <- errors.New(fmt.Sprintf("client could not connect to server, error: %v", err)) + } + time.Sleep(10 * time.Millisecond) + } + + for i, test := range tests { + _, err = test.method(clt) + if err != nil && err != io.EOF && err != errInvalidResponse { + clientErr <- errors.New(fmt.Sprintf("error request for: %v err: %v", i, err)) + } + } + }() + + // We check for errors or a done signal from the server and client routines. + for { + select { + case err := <-clientErr: + t.Fatalf("client error: %v", err) + case err := <-serverErr: + t.Fatalf("server error: %v", err) + case <-done: + return + default: + } + } +} + +// equal checks that the got slice is considered equivalent to the want slice, +// neglecting unimportant differences such as order of items in header and the +// CSeq number. +func equal(got, want []byte) bool { + const eol = "\r\n" + gotParts := strings.Split(strings.TrimRight(string(got), eol), eol) + wantParts := strings.Split(strings.TrimRight(string(want), eol), eol) + gotParts, ok := rmSeqNum(gotParts) + if !ok { + return false + } + wantParts, ok = rmSeqNum(wantParts) + if !ok { + return false + } + for _, gotStr := range gotParts { + for i, wantStr := range wantParts { + if gotStr == wantStr { + wantParts = append(wantParts[:i], wantParts[i+1:]...) + } + } + } + return len(wantParts) == 0 +} + +// rmSeqNum removes the CSeq number from a string in []string that contains it. +// If a CSeq field is not found nil and false is returned. +func rmSeqNum(s []string) ([]string, bool) { + for i, _s := range s { + if strings.Contains(_s, "CSeq") { + s[i] = strings.TrimFunc(s[i], func(r rune) bool { return unicode.IsNumber(r) }) + return s, true + } + } + return nil, false +} + +// TestReadResponse checks that ReadResponse behaves as expected. +func TestReadResponse(t *testing.T) { + // input has been obtained from a valid RTSP response. + input := []byte{ + 0x52, 0x54, 0x53, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d, // |RTSP/1.0 200 OK.| + 0x0a, 0x43, 0x53, 0x65, 0x71, 0x3a, 0x20, 0x32, 0x0d, 0x0a, 0x44, 0x61, 0x74, 0x65, 0x3a, 0x20, // |.CSeq: 2..Date: | + 0x57, 0x65, 0x64, 0x2c, 0x20, 0x4a, 0x61, 0x6e, 0x20, 0x32, 0x31, 0x20, 0x31, 0x39, 0x37, 0x30, // |Wed, Jan 21 1970| + 0x20, 0x30, 0x32, 0x3a, 0x33, 0x37, 0x3a, 0x31, 0x34, 0x20, 0x47, 0x4d, 0x54, 0x0d, 0x0a, 0x50, // | 02:37:14 GMT..P| + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x3a, 0x20, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x2c, 0x20, // |ublic: OPTIONS, | + 0x44, 0x45, 0x53, 0x43, 0x52, 0x49, 0x42, 0x45, 0x2c, 0x20, 0x53, 0x45, 0x54, 0x55, 0x50, 0x2c, // |DESCRIBE, SETUP,| + 0x20, 0x54, 0x45, 0x41, 0x52, 0x44, 0x4f, 0x57, 0x4e, 0x2c, 0x20, 0x50, 0x4c, 0x41, 0x59, 0x2c, // | TEARDOWN, PLAY,| + 0x20, 0x47, 0x45, 0x54, 0x5f, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x45, 0x54, 0x45, 0x52, 0x2c, 0x20, // | GET_PARAMETER, | + 0x53, 0x45, 0x54, 0x5f, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x45, 0x54, 0x45, 0x52, 0x0d, 0x0a, 0x0d, // |SET_PARAMETER...| + 0x0a, + } + + expect := Response{ + Proto: "RTSP", + ProtoMajor: 1, + ProtoMinor: 0, + StatusCode: 200, + ContentLength: 0, + Header: map[string][]string{ + "Cseq": []string{"2"}, + "Date": []string{"Wed, Jan 21 1970 02:37:14 GMT"}, + "Public": []string{"OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, GET_PARAMETER, SET_PARAMETER"}, + }, + } + + got, err := ReadResponse(bytes.NewReader(input)) + if err != nil { + t.Fatalf("should not have got error: %v", err) + } + + if !respEqual(*got, expect) { + t.Errorf("did not get expected result.\nGot: %+v\n Want: %+v\n", got, expect) + } +} + +// respEqual checks the equality of two Responses. +func respEqual(got, want Response) bool { + for _, f := range [][2]interface{}{ + {got.Proto, want.Proto}, + {got.ProtoMajor, want.ProtoMajor}, + {got.ProtoMinor, want.ProtoMinor}, + {got.StatusCode, want.StatusCode}, + {got.ContentLength, want.ContentLength}, + } { + if f[0] != f[1] { + return false + } + } + + if len(got.Header) != len(want.Header) { + return false + } + + for k, v := range got.Header { + if len(v) != len(want.Header[k]) { + return false + } + + for i, _v := range v { + if _v != want.Header[k][i] { + return false + } + } + } + return true +}