19 |
37 | 
30 |
38 |
65 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | // The MIT License (MIT)
2 | //
3 | // Copyright (c) 2025 Winlin
4 | //
5 | // Permission is hereby granted, free of charge, to any person obtaining a copy of
6 | // this software and associated documentation files (the "Software"), to deal in
7 | // the Software without restriction, including without limitation the rights to
8 | // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 | // the Software, and to permit persons to whom the Software is furnished to do so,
10 | // subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | // FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | package main
22 |
23 | import (
24 | "context"
25 | "encoding/json"
26 | "flag"
27 | "fmt"
28 | "net/http"
29 | "os"
30 | "path"
31 | "strings"
32 | "sync"
33 |
34 | "github.com/ossrs/go-oryx-lib/errors"
35 | "github.com/ossrs/go-oryx-lib/logger"
36 | "golang.org/x/net/websocket"
37 | )
38 |
39 | type Participant struct {
40 | Room *Room `json:"-"`
41 | Display string `json:"display"`
42 | Publishing bool `json:"publishing"`
43 | Out chan []byte `json:"-"`
44 | }
45 |
46 | func (v *Participant) String() string {
47 | return fmt.Sprintf("display=%v, room=%v", v.Display, v.Room.Name)
48 | }
49 |
50 | type Room struct {
51 | Name string `json:"room"`
52 | Participants []*Participant `json:"participants"`
53 | lock sync.RWMutex `json:"-"`
54 | }
55 |
56 | func (v *Room) String() string {
57 | return fmt.Sprintf("room=%v, participants=%v", v.Name, len(v.Participants))
58 | }
59 |
60 | func (v *Room) Add(p *Participant) error {
61 | v.lock.Lock()
62 | defer v.lock.Unlock()
63 |
64 | for _, r := range v.Participants {
65 | if r.Display == p.Display {
66 | return errors.Errorf("Participant %v exists in room %v", p.Display, v.Name)
67 | }
68 | }
69 |
70 | v.Participants = append(v.Participants, p)
71 | return nil
72 | }
73 |
74 | func (v *Room) Get(display string) *Participant {
75 | v.lock.RLock()
76 | defer v.lock.RUnlock()
77 |
78 | for _, r := range v.Participants {
79 | if r.Display == display {
80 | return r
81 | }
82 | }
83 |
84 | return nil
85 | }
86 |
87 | func (v *Room) Remove(p *Participant) {
88 | v.lock.Lock()
89 | defer v.lock.Unlock()
90 |
91 | for i, r := range v.Participants {
92 | if p == r {
93 | v.Participants = append(v.Participants[:i], v.Participants[i+1:]...)
94 | return
95 | }
96 | }
97 | }
98 |
99 | func (v *Room) Notify(ctx context.Context, peer *Participant, event, param, data string) {
100 | var participants []*Participant
101 | func() {
102 | v.lock.RLock()
103 | defer v.lock.RUnlock()
104 | participants = append(participants, v.Participants...)
105 | }()
106 |
107 | for _, r := range participants {
108 | if r == peer {
109 | continue
110 | }
111 |
112 | res := struct {
113 | Action string `json:"action"`
114 | Event string `json:"event"`
115 | Param string `json:"param,omitempty"`
116 | Data string `json:"data,omitempty"`
117 | Room string `json:"room"`
118 | Self *Participant `json:"self"`
119 | Peer *Participant `json:"peer"`
120 | Participants []*Participant `json:"participants"`
121 | }{
122 | "notify", event, param, data,
123 | v.Name, r, peer, participants,
124 | }
125 |
126 | b, err := json.Marshal(struct {
127 | Message interface{} `json:"msg"`
128 | }{
129 | res,
130 | })
131 | if err != nil {
132 | return
133 | }
134 |
135 | select {
136 | case <-ctx.Done():
137 | return
138 | case r.Out <- b:
139 | }
140 |
141 | logger.Tf(ctx, "Notify %v about %v %v", r, peer, event)
142 | }
143 | }
144 |
145 | func main() {
146 | var listen string
147 | flag.StringVar(&listen, "listen", "1989", "The TCP listen port")
148 |
149 | var html string
150 | flag.StringVar(&html, "root", "./www", "The www web root")
151 |
152 | flag.Usage = func() {
153 | fmt.Println(fmt.Sprintf("Usage: %v [Options]", os.Args[0]))
154 | fmt.Println(fmt.Sprintf("Options:"))
155 | fmt.Println(fmt.Sprintf(" -listen The TCP listen port. Default: %v", listen))
156 | fmt.Println(fmt.Sprintf(" -root The www web root. Default: %v", html))
157 | fmt.Println(fmt.Sprintf("For example:"))
158 | fmt.Println(fmt.Sprintf(" %v -listen %v -html %v", os.Args[0], listen, html))
159 | }
160 | flag.Parse()
161 |
162 | if !strings.Contains(listen, ":") {
163 | listen = ":" + listen
164 | }
165 |
166 | ctx := context.Background()
167 |
168 | home := listen
169 | if strings.HasPrefix(home, ":") {
170 | home = "http://localhost" + listen
171 | }
172 |
173 | if !path.IsAbs(html) && path.IsAbs(os.Args[0]) {
174 | html = path.Join(path.Dir(os.Args[0]), html)
175 | }
176 | logger.Tf(ctx, "Signaling ok, root=%v, home page is %v", html, home)
177 |
178 | http.Handle("/", http.FileServer(http.Dir(html)))
179 |
180 | http.Handle("/sig/v1/versions", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
181 | w.Write([]byte("1.0"))
182 | }))
183 |
184 | // Key is name of room, value is Room
185 | var rooms sync.Map
186 | http.Handle("/sig/v1/rtc", websocket.Handler(func(c *websocket.Conn) {
187 | ctx, cancel := context.WithCancel(logger.WithContext(ctx))
188 | defer cancel()
189 |
190 | r := c.Request()
191 | logger.Tf(ctx, "Serve client %v at %v", r.RemoteAddr, r.RequestURI)
192 | defer c.Close()
193 |
194 | var self *Participant
195 | go func() {
196 | <-ctx.Done()
197 | if self == nil {
198 | return
199 | }
200 |
201 | // Notify other peers that we're quiting.
202 | // @remark The ctx(of self) is done, so we must use a new context.
203 | go self.Room.Notify(context.Background(), self, "leave", "", "")
204 |
205 | self.Room.Remove(self)
206 | logger.Tf(ctx, "Remove client %v", self)
207 | }()
208 |
209 | inMessages := make(chan []byte, 0)
210 | go func() {
211 | defer cancel()
212 |
213 | buf := make([]byte, 16384)
214 | for {
215 | n, err := c.Read(buf)
216 | if err != nil {
217 | logger.Wf(ctx, "Ignore err %v for %v", err, r.RemoteAddr)
218 | break
219 | }
220 |
221 | select {
222 | case <-ctx.Done():
223 | case inMessages <- buf[:n]:
224 | }
225 | }
226 | }()
227 |
228 | outMessages := make(chan []byte, 0)
229 | go func() {
230 | defer cancel()
231 |
232 | handleMessage := func(m []byte) error {
233 | action := struct {
234 | TID string `json:"tid"`
235 | Message struct {
236 | Action string `json:"action"`
237 | } `json:"msg"`
238 | }{}
239 | if err := json.Unmarshal(m, &action); err != nil {
240 | return errors.Wrapf(err, "Unmarshal %s", m)
241 | }
242 |
243 | var res interface{}
244 | if action.Message.Action == "join" {
245 | obj := struct {
246 | Message struct {
247 | Room string `json:"room"`
248 | Display string `json:"display"`
249 | } `json:"msg"`
250 | }{}
251 | if err := json.Unmarshal(m, &obj); err != nil {
252 | return errors.Wrapf(err, "Unmarshal %s", m)
253 | }
254 |
255 | r, _ := rooms.LoadOrStore(obj.Message.Room, &Room{Name: obj.Message.Room})
256 | p := &Participant{Room: r.(*Room), Display: obj.Message.Display, Out: outMessages}
257 | if err := r.(*Room).Add(p); err != nil {
258 | return errors.Wrapf(err, "join")
259 | }
260 |
261 | self = p
262 | logger.Tf(ctx, "Join %v ok", self)
263 |
264 | res = struct {
265 | Action string `json:"action"`
266 | Room string `json:"room"`
267 | Self *Participant `json:"self"`
268 | Participants []*Participant `json:"participants"`
269 | }{
270 | action.Message.Action, obj.Message.Room, p, r.(*Room).Participants,
271 | }
272 |
273 | go r.(*Room).Notify(ctx, p, action.Message.Action, "", "")
274 | } else if action.Message.Action == "publish" {
275 | obj := struct {
276 | Message struct {
277 | Room string `json:"room"`
278 | Display string `json:"display"`
279 | } `json:"msg"`
280 | }{}
281 | if err := json.Unmarshal(m, &obj); err != nil {
282 | return errors.Wrapf(err, "Unmarshal %s", m)
283 | }
284 |
285 | r, _ := rooms.LoadOrStore(obj.Message.Room, &Room{Name: obj.Message.Room})
286 | p := r.(*Room).Get(obj.Message.Display)
287 |
288 | // Now, the peer is publishing.
289 | p.Publishing = true
290 |
291 | go r.(*Room).Notify(ctx, p, action.Message.Action, "", "")
292 | } else if action.Message.Action == "control" {
293 | obj := struct {
294 | Message struct {
295 | Room string `json:"room"`
296 | Display string `json:"display"`
297 | Call string `json:"call"`
298 | Data string `json:"data"`
299 | } `json:"msg"`
300 | }{}
301 | if err := json.Unmarshal(m, &obj); err != nil {
302 | return errors.Wrapf(err, "Unmarshal %s", m)
303 | }
304 |
305 | r, _ := rooms.LoadOrStore(obj.Message.Room, &Room{Name: obj.Message.Room})
306 | p := r.(*Room).Get(obj.Message.Display)
307 |
308 | go r.(*Room).Notify(ctx, p, action.Message.Action, obj.Message.Call, obj.Message.Data)
309 | } else {
310 | return errors.Errorf("Invalid message %s", m)
311 | }
312 |
313 | if b, err := json.Marshal(struct {
314 | TID string `json:"tid"`
315 | Message interface{} `json:"msg"`
316 | }{
317 | action.TID, res,
318 | }); err != nil {
319 | return errors.Wrapf(err, "marshal")
320 | } else {
321 | select {
322 | case <-ctx.Done():
323 | return ctx.Err()
324 | case outMessages <- b:
325 | }
326 | }
327 |
328 | return nil
329 | }
330 |
331 | for m := range inMessages {
332 | if err := handleMessage(m); err != nil {
333 | logger.Wf(ctx, "Handle %s err %v", m, err)
334 | break
335 | }
336 | }
337 | }()
338 |
339 | for m := range outMessages {
340 | if _, err := c.Write(m); err != nil {
341 | logger.Wf(ctx, "Ignore err %v for %v", err, r.RemoteAddr)
342 | break
343 | }
344 | }
345 | }))
346 |
347 | http.ListenAndServe(listen, nil)
348 | }
349 |
--------------------------------------------------------------------------------
/www/demos/one2one.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
39 | SRS:
40 |
41 | Room:
42 |
43 | Display:
44 |
45 |
46 |
47 |
48 |
49 |
56 |
63 |
64 | 
19 |
37 |
38 |
121 |
126 |
304 |
305 |
306 |
307 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/websocket/websocket.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // Package websocket implements a client and server for the WebSocket protocol
6 | // as specified in RFC 6455.
7 | //
8 | // This package currently lacks some features found in alternative
9 | // and more actively maintained WebSocket packages:
10 | //
11 | // https://godoc.org/github.com/gorilla/websocket
12 | // https://godoc.org/nhooyr.io/websocket
13 | package websocket // import "golang.org/x/net/websocket"
14 |
15 | import (
16 | "bufio"
17 | "crypto/tls"
18 | "encoding/json"
19 | "errors"
20 | "io"
21 | "io/ioutil"
22 | "net"
23 | "net/http"
24 | "net/url"
25 | "sync"
26 | "time"
27 | )
28 |
29 | const (
30 | ProtocolVersionHybi13 = 13
31 | ProtocolVersionHybi = ProtocolVersionHybi13
32 | SupportedProtocolVersion = "13"
33 |
34 | ContinuationFrame = 0
35 | TextFrame = 1
36 | BinaryFrame = 2
37 | CloseFrame = 8
38 | PingFrame = 9
39 | PongFrame = 10
40 | UnknownFrame = 255
41 |
42 | DefaultMaxPayloadBytes = 32 << 20 // 32MB
43 | )
44 |
45 | // ProtocolError represents WebSocket protocol errors.
46 | type ProtocolError struct {
47 | ErrorString string
48 | }
49 |
50 | func (err *ProtocolError) Error() string { return err.ErrorString }
51 |
52 | var (
53 | ErrBadProtocolVersion = &ProtocolError{"bad protocol version"}
54 | ErrBadScheme = &ProtocolError{"bad scheme"}
55 | ErrBadStatus = &ProtocolError{"bad status"}
56 | ErrBadUpgrade = &ProtocolError{"missing or bad upgrade"}
57 | ErrBadWebSocketOrigin = &ProtocolError{"missing or bad WebSocket-Origin"}
58 | ErrBadWebSocketLocation = &ProtocolError{"missing or bad WebSocket-Location"}
59 | ErrBadWebSocketProtocol = &ProtocolError{"missing or bad WebSocket-Protocol"}
60 | ErrBadWebSocketVersion = &ProtocolError{"missing or bad WebSocket Version"}
61 | ErrChallengeResponse = &ProtocolError{"mismatch challenge/response"}
62 | ErrBadFrame = &ProtocolError{"bad frame"}
63 | ErrBadFrameBoundary = &ProtocolError{"not on frame boundary"}
64 | ErrNotWebSocket = &ProtocolError{"not websocket protocol"}
65 | ErrBadRequestMethod = &ProtocolError{"bad method"}
66 | ErrNotSupported = &ProtocolError{"not supported"}
67 | )
68 |
69 | // ErrFrameTooLarge is returned by Codec's Receive method if payload size
70 | // exceeds limit set by Conn.MaxPayloadBytes
71 | var ErrFrameTooLarge = errors.New("websocket: frame payload size exceeds limit")
72 |
73 | // Addr is an implementation of net.Addr for WebSocket.
74 | type Addr struct {
75 | *url.URL
76 | }
77 |
78 | // Network returns the network type for a WebSocket, "websocket".
79 | func (addr *Addr) Network() string { return "websocket" }
80 |
81 | // Config is a WebSocket configuration
82 | type Config struct {
83 | // A WebSocket server address.
84 | Location *url.URL
85 |
86 | // A Websocket client origin.
87 | Origin *url.URL
88 |
89 | // WebSocket subprotocols.
90 | Protocol []string
91 |
92 | // WebSocket protocol version.
93 | Version int
94 |
95 | // TLS config for secure WebSocket (wss).
96 | TlsConfig *tls.Config
97 |
98 | // Additional header fields to be sent in WebSocket opening handshake.
99 | Header http.Header
100 |
101 | // Dialer used when opening websocket connections.
102 | Dialer *net.Dialer
103 |
104 | handshakeData map[string]string
105 | }
106 |
107 | // serverHandshaker is an interface to handle WebSocket server side handshake.
108 | type serverHandshaker interface {
109 | // ReadHandshake reads handshake request message from client.
110 | // Returns http response code and error if any.
111 | ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error)
112 |
113 | // AcceptHandshake accepts the client handshake request and sends
114 | // handshake response back to client.
115 | AcceptHandshake(buf *bufio.Writer) (err error)
116 |
117 | // NewServerConn creates a new WebSocket connection.
118 | NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) (conn *Conn)
119 | }
120 |
121 | // frameReader is an interface to read a WebSocket frame.
122 | type frameReader interface {
123 | // Reader is to read payload of the frame.
124 | io.Reader
125 |
126 | // PayloadType returns payload type.
127 | PayloadType() byte
128 |
129 | // HeaderReader returns a reader to read header of the frame.
130 | HeaderReader() io.Reader
131 |
132 | // TrailerReader returns a reader to read trailer of the frame.
133 | // If it returns nil, there is no trailer in the frame.
134 | TrailerReader() io.Reader
135 |
136 | // Len returns total length of the frame, including header and trailer.
137 | Len() int
138 | }
139 |
140 | // frameReaderFactory is an interface to creates new frame reader.
141 | type frameReaderFactory interface {
142 | NewFrameReader() (r frameReader, err error)
143 | }
144 |
145 | // frameWriter is an interface to write a WebSocket frame.
146 | type frameWriter interface {
147 | // Writer is to write payload of the frame.
148 | io.WriteCloser
149 | }
150 |
151 | // frameWriterFactory is an interface to create new frame writer.
152 | type frameWriterFactory interface {
153 | NewFrameWriter(payloadType byte) (w frameWriter, err error)
154 | }
155 |
156 | type frameHandler interface {
157 | HandleFrame(frame frameReader) (r frameReader, err error)
158 | WriteClose(status int) (err error)
159 | }
160 |
161 | // Conn represents a WebSocket connection.
162 | //
163 | // Multiple goroutines may invoke methods on a Conn simultaneously.
164 | type Conn struct {
165 | config *Config
166 | request *http.Request
167 |
168 | buf *bufio.ReadWriter
169 | rwc io.ReadWriteCloser
170 |
171 | rio sync.Mutex
172 | frameReaderFactory
173 | frameReader
174 |
175 | wio sync.Mutex
176 | frameWriterFactory
177 |
178 | frameHandler
179 | PayloadType byte
180 | defaultCloseStatus int
181 |
182 | // MaxPayloadBytes limits the size of frame payload received over Conn
183 | // by Codec's Receive method. If zero, DefaultMaxPayloadBytes is used.
184 | MaxPayloadBytes int
185 | }
186 |
187 | // Read implements the io.Reader interface:
188 | // it reads data of a frame from the WebSocket connection.
189 | // if msg is not large enough for the frame data, it fills the msg and next Read
190 | // will read the rest of the frame data.
191 | // it reads Text frame or Binary frame.
192 | func (ws *Conn) Read(msg []byte) (n int, err error) {
193 | ws.rio.Lock()
194 | defer ws.rio.Unlock()
195 | again:
196 | if ws.frameReader == nil {
197 | frame, err := ws.frameReaderFactory.NewFrameReader()
198 | if err != nil {
199 | return 0, err
200 | }
201 | ws.frameReader, err = ws.frameHandler.HandleFrame(frame)
202 | if err != nil {
203 | return 0, err
204 | }
205 | if ws.frameReader == nil {
206 | goto again
207 | }
208 | }
209 | n, err = ws.frameReader.Read(msg)
210 | if err == io.EOF {
211 | if trailer := ws.frameReader.TrailerReader(); trailer != nil {
212 | io.Copy(ioutil.Discard, trailer)
213 | }
214 | ws.frameReader = nil
215 | goto again
216 | }
217 | return n, err
218 | }
219 |
220 | // Write implements the io.Writer interface:
221 | // it writes data as a frame to the WebSocket connection.
222 | func (ws *Conn) Write(msg []byte) (n int, err error) {
223 | ws.wio.Lock()
224 | defer ws.wio.Unlock()
225 | w, err := ws.frameWriterFactory.NewFrameWriter(ws.PayloadType)
226 | if err != nil {
227 | return 0, err
228 | }
229 | n, err = w.Write(msg)
230 | w.Close()
231 | return n, err
232 | }
233 |
234 | // Close implements the io.Closer interface.
235 | func (ws *Conn) Close() error {
236 | err := ws.frameHandler.WriteClose(ws.defaultCloseStatus)
237 | err1 := ws.rwc.Close()
238 | if err != nil {
239 | return err
240 | }
241 | return err1
242 | }
243 |
244 | // IsClientConn reports whether ws is a client-side connection.
245 | func (ws *Conn) IsClientConn() bool { return ws.request == nil }
246 |
247 | // IsServerConn reports whether ws is a server-side connection.
248 | func (ws *Conn) IsServerConn() bool { return ws.request != nil }
249 |
250 | // LocalAddr returns the WebSocket Origin for the connection for client, or
251 | // the WebSocket location for server.
252 | func (ws *Conn) LocalAddr() net.Addr {
253 | if ws.IsClientConn() {
254 | return &Addr{ws.config.Origin}
255 | }
256 | return &Addr{ws.config.Location}
257 | }
258 |
259 | // RemoteAddr returns the WebSocket location for the connection for client, or
260 | // the Websocket Origin for server.
261 | func (ws *Conn) RemoteAddr() net.Addr {
262 | if ws.IsClientConn() {
263 | return &Addr{ws.config.Location}
264 | }
265 | return &Addr{ws.config.Origin}
266 | }
267 |
268 | var errSetDeadline = errors.New("websocket: cannot set deadline: not using a net.Conn")
269 |
270 | // SetDeadline sets the connection's network read & write deadlines.
271 | func (ws *Conn) SetDeadline(t time.Time) error {
272 | if conn, ok := ws.rwc.(net.Conn); ok {
273 | return conn.SetDeadline(t)
274 | }
275 | return errSetDeadline
276 | }
277 |
278 | // SetReadDeadline sets the connection's network read deadline.
279 | func (ws *Conn) SetReadDeadline(t time.Time) error {
280 | if conn, ok := ws.rwc.(net.Conn); ok {
281 | return conn.SetReadDeadline(t)
282 | }
283 | return errSetDeadline
284 | }
285 |
286 | // SetWriteDeadline sets the connection's network write deadline.
287 | func (ws *Conn) SetWriteDeadline(t time.Time) error {
288 | if conn, ok := ws.rwc.(net.Conn); ok {
289 | return conn.SetWriteDeadline(t)
290 | }
291 | return errSetDeadline
292 | }
293 |
294 | // Config returns the WebSocket config.
295 | func (ws *Conn) Config() *Config { return ws.config }
296 |
297 | // Request returns the http request upgraded to the WebSocket.
298 | // It is nil for client side.
299 | func (ws *Conn) Request() *http.Request { return ws.request }
300 |
301 | // Codec represents a symmetric pair of functions that implement a codec.
302 | type Codec struct {
303 | Marshal func(v interface{}) (data []byte, payloadType byte, err error)
304 | Unmarshal func(data []byte, payloadType byte, v interface{}) (err error)
305 | }
306 |
307 | // Send sends v marshaled by cd.Marshal as single frame to ws.
308 | func (cd Codec) Send(ws *Conn, v interface{}) (err error) {
309 | data, payloadType, err := cd.Marshal(v)
310 | if err != nil {
311 | return err
312 | }
313 | ws.wio.Lock()
314 | defer ws.wio.Unlock()
315 | w, err := ws.frameWriterFactory.NewFrameWriter(payloadType)
316 | if err != nil {
317 | return err
318 | }
319 | _, err = w.Write(data)
320 | w.Close()
321 | return err
322 | }
323 |
324 | // Receive receives single frame from ws, unmarshaled by cd.Unmarshal and stores
325 | // in v. The whole frame payload is read to an in-memory buffer; max size of
326 | // payload is defined by ws.MaxPayloadBytes. If frame payload size exceeds
327 | // limit, ErrFrameTooLarge is returned; in this case frame is not read off wire
328 | // completely. The next call to Receive would read and discard leftover data of
329 | // previous oversized frame before processing next frame.
330 | func (cd Codec) Receive(ws *Conn, v interface{}) (err error) {
331 | ws.rio.Lock()
332 | defer ws.rio.Unlock()
333 | if ws.frameReader != nil {
334 | _, err = io.Copy(ioutil.Discard, ws.frameReader)
335 | if err != nil {
336 | return err
337 | }
338 | ws.frameReader = nil
339 | }
340 | again:
341 | frame, err := ws.frameReaderFactory.NewFrameReader()
342 | if err != nil {
343 | return err
344 | }
345 | frame, err = ws.frameHandler.HandleFrame(frame)
346 | if err != nil {
347 | return err
348 | }
349 | if frame == nil {
350 | goto again
351 | }
352 | maxPayloadBytes := ws.MaxPayloadBytes
353 | if maxPayloadBytes == 0 {
354 | maxPayloadBytes = DefaultMaxPayloadBytes
355 | }
356 | if hf, ok := frame.(*hybiFrameReader); ok && hf.header.Length > int64(maxPayloadBytes) {
357 | // payload size exceeds limit, no need to call Unmarshal
358 | //
359 | // set frameReader to current oversized frame so that
360 | // the next call to this function can drain leftover
361 | // data before processing the next frame
362 | ws.frameReader = frame
363 | return ErrFrameTooLarge
364 | }
365 | payloadType := frame.PayloadType()
366 | data, err := ioutil.ReadAll(frame)
367 | if err != nil {
368 | return err
369 | }
370 | return cd.Unmarshal(data, payloadType, v)
371 | }
372 |
373 | func marshal(v interface{}) (msg []byte, payloadType byte, err error) {
374 | switch data := v.(type) {
375 | case string:
376 | return []byte(data), TextFrame, nil
377 | case []byte:
378 | return data, BinaryFrame, nil
379 | }
380 | return nil, UnknownFrame, ErrNotSupported
381 | }
382 |
383 | func unmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
384 | switch data := v.(type) {
385 | case *string:
386 | *data = string(msg)
387 | return nil
388 | case *[]byte:
389 | *data = msg
390 | return nil
391 | }
392 | return ErrNotSupported
393 | }
394 |
395 | /*
396 | Message is a codec to send/receive text/binary data in a frame on WebSocket connection.
397 | To send/receive text frame, use string type.
398 | To send/receive binary frame, use []byte type.
399 |
400 | Trivial usage:
401 |
402 | import "websocket"
403 |
404 | // receive text frame
405 | var message string
406 | websocket.Message.Receive(ws, &message)
407 |
408 | // send text frame
409 | message = "hello"
410 | websocket.Message.Send(ws, message)
411 |
412 | // receive binary frame
413 | var data []byte
414 | websocket.Message.Receive(ws, &data)
415 |
416 | // send binary frame
417 | data = []byte{0, 1, 2}
418 | websocket.Message.Send(ws, data)
419 |
420 | */
421 | var Message = Codec{marshal, unmarshal}
422 |
423 | func jsonMarshal(v interface{}) (msg []byte, payloadType byte, err error) {
424 | msg, err = json.Marshal(v)
425 | return msg, TextFrame, err
426 | }
427 |
428 | func jsonUnmarshal(msg []byte, payloadType byte, v interface{}) (err error) {
429 | return json.Unmarshal(msg, v)
430 | }
431 |
432 | /*
433 | JSON is a codec to send/receive JSON data in a frame from a WebSocket connection.
434 |
435 | Trivial usage:
436 |
437 | import "websocket"
438 |
439 | type T struct {
440 | Msg string
441 | Count int
442 | }
443 |
444 | // receive JSON type T
445 | var data T
446 | websocket.JSON.Receive(ws, &data)
447 |
448 | // send JSON type T
449 | websocket.JSON.Send(ws, data)
450 | */
451 | var JSON = Codec{jsonMarshal, jsonUnmarshal}
452 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/websocket/hybi.go:
--------------------------------------------------------------------------------
1 | // Copyright 2011 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package websocket
6 |
7 | // This file implements a protocol of hybi draft.
8 | // http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
9 |
10 | import (
11 | "bufio"
12 | "bytes"
13 | "crypto/rand"
14 | "crypto/sha1"
15 | "encoding/base64"
16 | "encoding/binary"
17 | "fmt"
18 | "io"
19 | "io/ioutil"
20 | "net/http"
21 | "net/url"
22 | "strings"
23 | )
24 |
25 | const (
26 | websocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
27 |
28 | closeStatusNormal = 1000
29 | closeStatusGoingAway = 1001
30 | closeStatusProtocolError = 1002
31 | closeStatusUnsupportedData = 1003
32 | closeStatusFrameTooLarge = 1004
33 | closeStatusNoStatusRcvd = 1005
34 | closeStatusAbnormalClosure = 1006
35 | closeStatusBadMessageData = 1007
36 | closeStatusPolicyViolation = 1008
37 | closeStatusTooBigData = 1009
38 | closeStatusExtensionMismatch = 1010
39 |
40 | maxControlFramePayloadLength = 125
41 | )
42 |
43 | var (
44 | ErrBadMaskingKey = &ProtocolError{"bad masking key"}
45 | ErrBadPongMessage = &ProtocolError{"bad pong message"}
46 | ErrBadClosingStatus = &ProtocolError{"bad closing status"}
47 | ErrUnsupportedExtensions = &ProtocolError{"unsupported extensions"}
48 | ErrNotImplemented = &ProtocolError{"not implemented"}
49 |
50 | handshakeHeader = map[string]bool{
51 | "Host": true,
52 | "Upgrade": true,
53 | "Connection": true,
54 | "Sec-Websocket-Key": true,
55 | "Sec-Websocket-Origin": true,
56 | "Sec-Websocket-Version": true,
57 | "Sec-Websocket-Protocol": true,
58 | "Sec-Websocket-Accept": true,
59 | }
60 | )
61 |
62 | // A hybiFrameHeader is a frame header as defined in hybi draft.
63 | type hybiFrameHeader struct {
64 | Fin bool
65 | Rsv [3]bool
66 | OpCode byte
67 | Length int64
68 | MaskingKey []byte
69 |
70 | data *bytes.Buffer
71 | }
72 |
73 | // A hybiFrameReader is a reader for hybi frame.
74 | type hybiFrameReader struct {
75 | reader io.Reader
76 |
77 | header hybiFrameHeader
78 | pos int64
79 | length int
80 | }
81 |
82 | func (frame *hybiFrameReader) Read(msg []byte) (n int, err error) {
83 | n, err = frame.reader.Read(msg)
84 | if frame.header.MaskingKey != nil {
85 | for i := 0; i < n; i++ {
86 | msg[i] = msg[i] ^ frame.header.MaskingKey[frame.pos%4]
87 | frame.pos++
88 | }
89 | }
90 | return n, err
91 | }
92 |
93 | func (frame *hybiFrameReader) PayloadType() byte { return frame.header.OpCode }
94 |
95 | func (frame *hybiFrameReader) HeaderReader() io.Reader {
96 | if frame.header.data == nil {
97 | return nil
98 | }
99 | if frame.header.data.Len() == 0 {
100 | return nil
101 | }
102 | return frame.header.data
103 | }
104 |
105 | func (frame *hybiFrameReader) TrailerReader() io.Reader { return nil }
106 |
107 | func (frame *hybiFrameReader) Len() (n int) { return frame.length }
108 |
109 | // A hybiFrameReaderFactory creates new frame reader based on its frame type.
110 | type hybiFrameReaderFactory struct {
111 | *bufio.Reader
112 | }
113 |
114 | // NewFrameReader reads a frame header from the connection, and creates new reader for the frame.
115 | // See Section 5.2 Base Framing protocol for detail.
116 | // http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17#section-5.2
117 | func (buf hybiFrameReaderFactory) NewFrameReader() (frame frameReader, err error) {
118 | hybiFrame := new(hybiFrameReader)
119 | frame = hybiFrame
120 | var header []byte
121 | var b byte
122 | // First byte. FIN/RSV1/RSV2/RSV3/OpCode(4bits)
123 | b, err = buf.ReadByte()
124 | if err != nil {
125 | return
126 | }
127 | header = append(header, b)
128 | hybiFrame.header.Fin = ((header[0] >> 7) & 1) != 0
129 | for i := 0; i < 3; i++ {
130 | j := uint(6 - i)
131 | hybiFrame.header.Rsv[i] = ((header[0] >> j) & 1) != 0
132 | }
133 | hybiFrame.header.OpCode = header[0] & 0x0f
134 |
135 | // Second byte. Mask/Payload len(7bits)
136 | b, err = buf.ReadByte()
137 | if err != nil {
138 | return
139 | }
140 | header = append(header, b)
141 | mask := (b & 0x80) != 0
142 | b &= 0x7f
143 | lengthFields := 0
144 | switch {
145 | case b <= 125: // Payload length 7bits.
146 | hybiFrame.header.Length = int64(b)
147 | case b == 126: // Payload length 7+16bits
148 | lengthFields = 2
149 | case b == 127: // Payload length 7+64bits
150 | lengthFields = 8
151 | }
152 | for i := 0; i < lengthFields; i++ {
153 | b, err = buf.ReadByte()
154 | if err != nil {
155 | return
156 | }
157 | if lengthFields == 8 && i == 0 { // MSB must be zero when 7+64 bits
158 | b &= 0x7f
159 | }
160 | header = append(header, b)
161 | hybiFrame.header.Length = hybiFrame.header.Length*256 + int64(b)
162 | }
163 | if mask {
164 | // Masking key. 4 bytes.
165 | for i := 0; i < 4; i++ {
166 | b, err = buf.ReadByte()
167 | if err != nil {
168 | return
169 | }
170 | header = append(header, b)
171 | hybiFrame.header.MaskingKey = append(hybiFrame.header.MaskingKey, b)
172 | }
173 | }
174 | hybiFrame.reader = io.LimitReader(buf.Reader, hybiFrame.header.Length)
175 | hybiFrame.header.data = bytes.NewBuffer(header)
176 | hybiFrame.length = len(header) + int(hybiFrame.header.Length)
177 | return
178 | }
179 |
180 | // A HybiFrameWriter is a writer for hybi frame.
181 | type hybiFrameWriter struct {
182 | writer *bufio.Writer
183 |
184 | header *hybiFrameHeader
185 | }
186 |
187 | func (frame *hybiFrameWriter) Write(msg []byte) (n int, err error) {
188 | var header []byte
189 | var b byte
190 | if frame.header.Fin {
191 | b |= 0x80
192 | }
193 | for i := 0; i < 3; i++ {
194 | if frame.header.Rsv[i] {
195 | j := uint(6 - i)
196 | b |= 1 << j
197 | }
198 | }
199 | b |= frame.header.OpCode
200 | header = append(header, b)
201 | if frame.header.MaskingKey != nil {
202 | b = 0x80
203 | } else {
204 | b = 0
205 | }
206 | lengthFields := 0
207 | length := len(msg)
208 | switch {
209 | case length <= 125:
210 | b |= byte(length)
211 | case length < 65536:
212 | b |= 126
213 | lengthFields = 2
214 | default:
215 | b |= 127
216 | lengthFields = 8
217 | }
218 | header = append(header, b)
219 | for i := 0; i < lengthFields; i++ {
220 | j := uint((lengthFields - i - 1) * 8)
221 | b = byte((length >> j) & 0xff)
222 | header = append(header, b)
223 | }
224 | if frame.header.MaskingKey != nil {
225 | if len(frame.header.MaskingKey) != 4 {
226 | return 0, ErrBadMaskingKey
227 | }
228 | header = append(header, frame.header.MaskingKey...)
229 | frame.writer.Write(header)
230 | data := make([]byte, length)
231 | for i := range data {
232 | data[i] = msg[i] ^ frame.header.MaskingKey[i%4]
233 | }
234 | frame.writer.Write(data)
235 | err = frame.writer.Flush()
236 | return length, err
237 | }
238 | frame.writer.Write(header)
239 | frame.writer.Write(msg)
240 | err = frame.writer.Flush()
241 | return length, err
242 | }
243 |
244 | func (frame *hybiFrameWriter) Close() error { return nil }
245 |
246 | type hybiFrameWriterFactory struct {
247 | *bufio.Writer
248 | needMaskingKey bool
249 | }
250 |
251 | func (buf hybiFrameWriterFactory) NewFrameWriter(payloadType byte) (frame frameWriter, err error) {
252 | frameHeader := &hybiFrameHeader{Fin: true, OpCode: payloadType}
253 | if buf.needMaskingKey {
254 | frameHeader.MaskingKey, err = generateMaskingKey()
255 | if err != nil {
256 | return nil, err
257 | }
258 | }
259 | return &hybiFrameWriter{writer: buf.Writer, header: frameHeader}, nil
260 | }
261 |
262 | type hybiFrameHandler struct {
263 | conn *Conn
264 | payloadType byte
265 | }
266 |
267 | func (handler *hybiFrameHandler) HandleFrame(frame frameReader) (frameReader, error) {
268 | if handler.conn.IsServerConn() {
269 | // The client MUST mask all frames sent to the server.
270 | if frame.(*hybiFrameReader).header.MaskingKey == nil {
271 | handler.WriteClose(closeStatusProtocolError)
272 | return nil, io.EOF
273 | }
274 | } else {
275 | // The server MUST NOT mask all frames.
276 | if frame.(*hybiFrameReader).header.MaskingKey != nil {
277 | handler.WriteClose(closeStatusProtocolError)
278 | return nil, io.EOF
279 | }
280 | }
281 | if header := frame.HeaderReader(); header != nil {
282 | io.Copy(ioutil.Discard, header)
283 | }
284 | switch frame.PayloadType() {
285 | case ContinuationFrame:
286 | frame.(*hybiFrameReader).header.OpCode = handler.payloadType
287 | case TextFrame, BinaryFrame:
288 | handler.payloadType = frame.PayloadType()
289 | case CloseFrame:
290 | return nil, io.EOF
291 | case PingFrame, PongFrame:
292 | b := make([]byte, maxControlFramePayloadLength)
293 | n, err := io.ReadFull(frame, b)
294 | if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
295 | return nil, err
296 | }
297 | io.Copy(ioutil.Discard, frame)
298 | if frame.PayloadType() == PingFrame {
299 | if _, err := handler.WritePong(b[:n]); err != nil {
300 | return nil, err
301 | }
302 | }
303 | return nil, nil
304 | }
305 | return frame, nil
306 | }
307 |
308 | func (handler *hybiFrameHandler) WriteClose(status int) (err error) {
309 | handler.conn.wio.Lock()
310 | defer handler.conn.wio.Unlock()
311 | w, err := handler.conn.frameWriterFactory.NewFrameWriter(CloseFrame)
312 | if err != nil {
313 | return err
314 | }
315 | msg := make([]byte, 2)
316 | binary.BigEndian.PutUint16(msg, uint16(status))
317 | _, err = w.Write(msg)
318 | w.Close()
319 | return err
320 | }
321 |
322 | func (handler *hybiFrameHandler) WritePong(msg []byte) (n int, err error) {
323 | handler.conn.wio.Lock()
324 | defer handler.conn.wio.Unlock()
325 | w, err := handler.conn.frameWriterFactory.NewFrameWriter(PongFrame)
326 | if err != nil {
327 | return 0, err
328 | }
329 | n, err = w.Write(msg)
330 | w.Close()
331 | return n, err
332 | }
333 |
334 | // newHybiConn creates a new WebSocket connection speaking hybi draft protocol.
335 | func newHybiConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
336 | if buf == nil {
337 | br := bufio.NewReader(rwc)
338 | bw := bufio.NewWriter(rwc)
339 | buf = bufio.NewReadWriter(br, bw)
340 | }
341 | ws := &Conn{config: config, request: request, buf: buf, rwc: rwc,
342 | frameReaderFactory: hybiFrameReaderFactory{buf.Reader},
343 | frameWriterFactory: hybiFrameWriterFactory{
344 | buf.Writer, request == nil},
345 | PayloadType: TextFrame,
346 | defaultCloseStatus: closeStatusNormal}
347 | ws.frameHandler = &hybiFrameHandler{conn: ws}
348 | return ws
349 | }
350 |
351 | // generateMaskingKey generates a masking key for a frame.
352 | func generateMaskingKey() (maskingKey []byte, err error) {
353 | maskingKey = make([]byte, 4)
354 | if _, err = io.ReadFull(rand.Reader, maskingKey); err != nil {
355 | return
356 | }
357 | return
358 | }
359 |
360 | // generateNonce generates a nonce consisting of a randomly selected 16-byte
361 | // value that has been base64-encoded.
362 | func generateNonce() (nonce []byte) {
363 | key := make([]byte, 16)
364 | if _, err := io.ReadFull(rand.Reader, key); err != nil {
365 | panic(err)
366 | }
367 | nonce = make([]byte, 24)
368 | base64.StdEncoding.Encode(nonce, key)
369 | return
370 | }
371 |
372 | // removeZone removes IPv6 zone identifer from host.
373 | // E.g., "[fe80::1%en0]:8080" to "[fe80::1]:8080"
374 | func removeZone(host string) string {
375 | if !strings.HasPrefix(host, "[") {
376 | return host
377 | }
378 | i := strings.LastIndex(host, "]")
379 | if i < 0 {
380 | return host
381 | }
382 | j := strings.LastIndex(host[:i], "%")
383 | if j < 0 {
384 | return host
385 | }
386 | return host[:j] + host[i:]
387 | }
388 |
389 | // getNonceAccept computes the base64-encoded SHA-1 of the concatenation of
390 | // the nonce ("Sec-WebSocket-Key" value) with the websocket GUID string.
391 | func getNonceAccept(nonce []byte) (expected []byte, err error) {
392 | h := sha1.New()
393 | if _, err = h.Write(nonce); err != nil {
394 | return
395 | }
396 | if _, err = h.Write([]byte(websocketGUID)); err != nil {
397 | return
398 | }
399 | expected = make([]byte, 28)
400 | base64.StdEncoding.Encode(expected, h.Sum(nil))
401 | return
402 | }
403 |
404 | // Client handshake described in draft-ietf-hybi-thewebsocket-protocol-17
405 | func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
406 | bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")
407 |
408 | // According to RFC 6874, an HTTP client, proxy, or other
409 | // intermediary must remove any IPv6 zone identifier attached
410 | // to an outgoing URI.
411 | bw.WriteString("Host: " + removeZone(config.Location.Host) + "\r\n")
412 | bw.WriteString("Upgrade: websocket\r\n")
413 | bw.WriteString("Connection: Upgrade\r\n")
414 | nonce := generateNonce()
415 | if config.handshakeData != nil {
416 | nonce = []byte(config.handshakeData["key"])
417 | }
418 | bw.WriteString("Sec-WebSocket-Key: " + string(nonce) + "\r\n")
419 | bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")
420 |
421 | if config.Version != ProtocolVersionHybi13 {
422 | return ErrBadProtocolVersion
423 | }
424 |
425 | bw.WriteString("Sec-WebSocket-Version: " + fmt.Sprintf("%d", config.Version) + "\r\n")
426 | if len(config.Protocol) > 0 {
427 | bw.WriteString("Sec-WebSocket-Protocol: " + strings.Join(config.Protocol, ", ") + "\r\n")
428 | }
429 | // TODO(ukai): send Sec-WebSocket-Extensions.
430 | err = config.Header.WriteSubset(bw, handshakeHeader)
431 | if err != nil {
432 | return err
433 | }
434 |
435 | bw.WriteString("\r\n")
436 | if err = bw.Flush(); err != nil {
437 | return err
438 | }
439 |
440 | resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
441 | if err != nil {
442 | return err
443 | }
444 | if resp.StatusCode != 101 {
445 | return ErrBadStatus
446 | }
447 | if strings.ToLower(resp.Header.Get("Upgrade")) != "websocket" ||
448 | strings.ToLower(resp.Header.Get("Connection")) != "upgrade" {
449 | return ErrBadUpgrade
450 | }
451 | expectedAccept, err := getNonceAccept(nonce)
452 | if err != nil {
453 | return err
454 | }
455 | if resp.Header.Get("Sec-WebSocket-Accept") != string(expectedAccept) {
456 | return ErrChallengeResponse
457 | }
458 | if resp.Header.Get("Sec-WebSocket-Extensions") != "" {
459 | return ErrUnsupportedExtensions
460 | }
461 | offeredProtocol := resp.Header.Get("Sec-WebSocket-Protocol")
462 | if offeredProtocol != "" {
463 | protocolMatched := false
464 | for i := 0; i < len(config.Protocol); i++ {
465 | if config.Protocol[i] == offeredProtocol {
466 | protocolMatched = true
467 | break
468 | }
469 | }
470 | if !protocolMatched {
471 | return ErrBadWebSocketProtocol
472 | }
473 | config.Protocol = []string{offeredProtocol}
474 | }
475 |
476 | return nil
477 | }
478 |
479 | // newHybiClientConn creates a client WebSocket connection after handshake.
480 | func newHybiClientConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser) *Conn {
481 | return newHybiConn(config, buf, rwc, nil)
482 | }
483 |
484 | // A HybiServerHandshaker performs a server handshake using hybi draft protocol.
485 | type hybiServerHandshaker struct {
486 | *Config
487 | accept []byte
488 | }
489 |
490 | func (c *hybiServerHandshaker) ReadHandshake(buf *bufio.Reader, req *http.Request) (code int, err error) {
491 | c.Version = ProtocolVersionHybi13
492 | if req.Method != "GET" {
493 | return http.StatusMethodNotAllowed, ErrBadRequestMethod
494 | }
495 | // HTTP version can be safely ignored.
496 |
497 | if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
498 | !strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
499 | return http.StatusBadRequest, ErrNotWebSocket
500 | }
501 |
502 | key := req.Header.Get("Sec-Websocket-Key")
503 | if key == "" {
504 | return http.StatusBadRequest, ErrChallengeResponse
505 | }
506 | version := req.Header.Get("Sec-Websocket-Version")
507 | switch version {
508 | case "13":
509 | c.Version = ProtocolVersionHybi13
510 | default:
511 | return http.StatusBadRequest, ErrBadWebSocketVersion
512 | }
513 | var scheme string
514 | if req.TLS != nil {
515 | scheme = "wss"
516 | } else {
517 | scheme = "ws"
518 | }
519 | c.Location, err = url.ParseRequestURI(scheme + "://" + req.Host + req.URL.RequestURI())
520 | if err != nil {
521 | return http.StatusBadRequest, err
522 | }
523 | protocol := strings.TrimSpace(req.Header.Get("Sec-Websocket-Protocol"))
524 | if protocol != "" {
525 | protocols := strings.Split(protocol, ",")
526 | for i := 0; i < len(protocols); i++ {
527 | c.Protocol = append(c.Protocol, strings.TrimSpace(protocols[i]))
528 | }
529 | }
530 | c.accept, err = getNonceAccept([]byte(key))
531 | if err != nil {
532 | return http.StatusInternalServerError, err
533 | }
534 | return http.StatusSwitchingProtocols, nil
535 | }
536 |
537 | // Origin parses the Origin header in req.
538 | // If the Origin header is not set, it returns nil and nil.
539 | func Origin(config *Config, req *http.Request) (*url.URL, error) {
540 | var origin string
541 | switch config.Version {
542 | case ProtocolVersionHybi13:
543 | origin = req.Header.Get("Origin")
544 | }
545 | if origin == "" {
546 | return nil, nil
547 | }
548 | return url.ParseRequestURI(origin)
549 | }
550 |
551 | func (c *hybiServerHandshaker) AcceptHandshake(buf *bufio.Writer) (err error) {
552 | if len(c.Protocol) > 0 {
553 | if len(c.Protocol) != 1 {
554 | // You need choose a Protocol in Handshake func in Server.
555 | return ErrBadWebSocketProtocol
556 | }
557 | }
558 | buf.WriteString("HTTP/1.1 101 Switching Protocols\r\n")
559 | buf.WriteString("Upgrade: websocket\r\n")
560 | buf.WriteString("Connection: Upgrade\r\n")
561 | buf.WriteString("Sec-WebSocket-Accept: " + string(c.accept) + "\r\n")
562 | if len(c.Protocol) > 0 {
563 | buf.WriteString("Sec-WebSocket-Protocol: " + c.Protocol[0] + "\r\n")
564 | }
565 | // TODO(ukai): send Sec-WebSocket-Extensions.
566 | if c.Header != nil {
567 | err := c.Header.WriteSubset(buf, handshakeHeader)
568 | if err != nil {
569 | return err
570 | }
571 | }
572 | buf.WriteString("\r\n")
573 | return buf.Flush()
574 | }
575 |
576 | func (c *hybiServerHandshaker) NewServerConn(buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
577 | return newHybiServerConn(c.Config, buf, rwc, request)
578 | }
579 |
580 | // newHybiServerConn returns a new WebSocket connection speaking hybi draft protocol.
581 | func newHybiServerConn(config *Config, buf *bufio.ReadWriter, rwc io.ReadWriteCloser, request *http.Request) *Conn {
582 | return newHybiConn(config, buf, rwc, request)
583 | }
584 |
--------------------------------------------------------------------------------
/www/demos/js/srs.sdk.js:
--------------------------------------------------------------------------------
1 |
2 | /**
3 | * The MIT License (MIT)
4 | *
5 | * Copyright (c) 2013-2025 Winlin
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 | * this software and associated documentation files (the "Software"), to deal in
9 | * the Software without restriction, including without limitation the rights to
10 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 | * the Software, and to permit persons to whom the Software is furnished to do so,
12 | * subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in all
15 | * copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 | * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 | * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 | * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | 'use strict';
26 |
27 | // Depends on adapter-7.4.0.min.js from https://github.com/webrtc/adapter
28 | // Async-awat-prmise based SRS RTC Publisher.
29 | function SrsRtcPublisherAsync() {
30 | var self = {};
31 |
32 | // https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia
33 | self.constraints = {
34 | audio: true,
35 | video: {
36 | width: {ideal: 320, max: 576}
37 | }
38 | };
39 |
40 | // @see https://github.com/rtcdn/rtcdn-draft
41 | // @url The WebRTC url to play with, for example:
42 | // webrtc://r.ossrs.net/live/livestream
43 | // or specifies the API port:
44 | // webrtc://r.ossrs.net:11985/live/livestream
45 | // or autostart the publish:
46 | // webrtc://r.ossrs.net/live/livestream?autostart=true
47 | // or change the app from live to myapp:
48 | // webrtc://r.ossrs.net:11985/myapp/livestream
49 | // or change the stream from livestream to mystream:
50 | // webrtc://r.ossrs.net:11985/live/mystream
51 | // or set the api server to myapi.domain.com:
52 | // webrtc://myapi.domain.com/live/livestream
53 | // or set the candidate(ip) of answer:
54 | // webrtc://r.ossrs.net/live/livestream?eip=39.107.238.185
55 | // or force to access https API:
56 | // webrtc://r.ossrs.net/live/livestream?schema=https
57 | // or use plaintext, without SRTP:
58 | // webrtc://r.ossrs.net/live/livestream?encrypt=false
59 | // or any other information, will pass-by in the query:
60 | // webrtc://r.ossrs.net/live/livestream?vhost=xxx
61 | // webrtc://r.ossrs.net/live/livestream?token=xxx
62 | self.publish = async function (url) {
63 | var conf = self.__internal.prepareUrl(url);
64 | self.pc.addTransceiver("audio", {direction: "sendonly"});
65 | self.pc.addTransceiver("video", {direction: "sendonly"});
66 |
67 | var stream = await navigator.mediaDevices.getUserMedia(self.constraints);
68 |
69 | // @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addStream#Migrating_to_addTrack
70 | stream.getTracks().forEach(function (track) {
71 | self.pc.addTrack(track);
72 |
73 | // Notify about local track when stream is ok.
74 | self.ontrack && self.ontrack({track: track});
75 | });
76 |
77 | var offer = await self.pc.createOffer();
78 | await self.pc.setLocalDescription(offer);
79 | var session = await new Promise(function (resolve, reject) {
80 | // @see https://github.com/rtcdn/rtcdn-draft
81 | var data = {
82 | api: conf.apiUrl, tid: conf.tid, streamurl: conf.streamUrl,
83 | clientip: null, sdp: offer.sdp
84 | };
85 | console.log("Generated offer: ", data);
86 |
87 | $.ajax({
88 | type: "POST", url: conf.apiUrl, data: JSON.stringify(data),
89 | contentType: 'application/json', dataType: 'json'
90 | }).done(function (data) {
91 | console.log("Got answer: ", data);
92 | if (data.code) {
93 | reject(data);
94 | return;
95 | }
96 |
97 | resolve(data);
98 | }).fail(function (reason) {
99 | reject(reason);
100 | });
101 | });
102 | await self.pc.setRemoteDescription(
103 | new RTCSessionDescription({type: 'answer', sdp: session.sdp})
104 | );
105 | session.simulator = conf.schema + '//' + conf.urlObject.server + ':' + conf.port + '/rtc/v1/nack/';
106 |
107 | return session;
108 | };
109 |
110 | // Close the publisher.
111 | self.close = function () {
112 | self.pc && self.pc.close();
113 | self.pc = null;
114 | };
115 |
116 | // The callback when got local stream.
117 | // @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addStream#Migrating_to_addTrack
118 | self.ontrack = function (event) {
119 | // Add track to stream of SDK.
120 | self.stream.addTrack(event.track);
121 | };
122 |
123 | // Internal APIs.
124 | self.__internal = {
125 | defaultPath: '/rtc/v1/publish/',
126 | prepareUrl: function (webrtcUrl) {
127 | var urlObject = self.__internal.parse(webrtcUrl);
128 |
129 | // If user specifies the schema, use it as API schema.
130 | var schema = urlObject.user_query.schema;
131 | schema = schema ? schema + ':' : window.location.protocol;
132 |
133 | var port = urlObject.port || 1985;
134 | if (schema === 'https:') {
135 | port = urlObject.port || 443;
136 | }
137 |
138 | // @see https://github.com/rtcdn/rtcdn-draft
139 | var api = urlObject.user_query.play || self.__internal.defaultPath;
140 | if (api.lastIndexOf('/') !== api.length - 1) {
141 | api += '/';
142 | }
143 |
144 | apiUrl = schema + '//' + urlObject.server + ':' + port + api;
145 | for (var key in urlObject.user_query) {
146 | if (key !== 'api' && key !== 'play') {
147 | apiUrl += '&' + key + '=' + urlObject.user_query[key];
148 | }
149 | }
150 | // Replace /rtc/v1/play/&k=v to /rtc/v1/play/?k=v
151 | var apiUrl = apiUrl.replace(api + '&', api + '?');
152 |
153 | var streamUrl = urlObject.url;
154 |
155 | return {
156 | apiUrl: apiUrl, streamUrl: streamUrl, schema: schema, urlObject: urlObject, port: port,
157 | tid: Number(parseInt(new Date().getTime()*Math.random()*100)).toString(16).slice(0, 7)
158 | };
159 | },
160 | parse: function (url) {
161 | // @see: http://stackoverflow.com/questions/10469575/how-to-use-location-object-to-parse-url-without-redirecting-the-page-in-javascri
162 | var a = document.createElement("a");
163 | a.href = url.replace("rtmp://", "http://")
164 | .replace("webrtc://", "http://")
165 | .replace("rtc://", "http://");
166 |
167 | var vhost = a.hostname;
168 | var app = a.pathname.substring(1, a.pathname.lastIndexOf("/"));
169 | var stream = a.pathname.slice(a.pathname.lastIndexOf("/") + 1);
170 |
171 | // parse the vhost in the params of app, that srs supports.
172 | app = app.replace("...vhost...", "?vhost=");
173 | if (app.indexOf("?") >= 0) {
174 | var params = app.slice(app.indexOf("?"));
175 | app = app.slice(0, app.indexOf("?"));
176 |
177 | if (params.indexOf("vhost=") > 0) {
178 | vhost = params.slice(params.indexOf("vhost=") + "vhost=".length);
179 | if (vhost.indexOf("&") > 0) {
180 | vhost = vhost.slice(0, vhost.indexOf("&"));
181 | }
182 | }
183 | }
184 |
185 | // when vhost equals to server, and server is ip,
186 | // the vhost is __defaultVhost__
187 | if (a.hostname === vhost) {
188 | var re = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;
189 | if (re.test(a.hostname)) {
190 | vhost = "__defaultVhost__";
191 | }
192 | }
193 |
194 | // parse the schema
195 | var schema = "rtmp";
196 | if (url.indexOf("://") > 0) {
197 | schema = url.slice(0, url.indexOf("://"));
198 | }
199 |
200 | var port = a.port;
201 | if (!port) {
202 | if (schema === 'http') {
203 | port = 80;
204 | } else if (schema === 'https') {
205 | port = 443;
206 | } else if (schema === 'rtmp') {
207 | port = 1935;
208 | }
209 | }
210 |
211 | var ret = {
212 | url: url,
213 | schema: schema,
214 | server: a.hostname, port: port,
215 | vhost: vhost, app: app, stream: stream
216 | };
217 | self.__internal.fill_query(a.search, ret);
218 |
219 | // For webrtc API, we use 443 if page is https, or schema specified it.
220 | if (!ret.port) {
221 | if (schema === 'webrtc' || schema === 'rtc') {
222 | if (ret.user_query.schema === 'https') {
223 | ret.port = 443;
224 | } else if (window.location.href.indexOf('https://') === 0) {
225 | ret.port = 443;
226 | } else {
227 | // For WebRTC, SRS use 1985 as default API port.
228 | ret.port = 1985;
229 | }
230 | }
231 | }
232 |
233 | return ret;
234 | },
235 | fill_query: function (query_string, obj) {
236 | // pure user query object.
237 | obj.user_query = {};
238 |
239 | if (query_string.length === 0) {
240 | return;
241 | }
242 |
243 | // split again for angularjs.
244 | if (query_string.indexOf("?") >= 0) {
245 | query_string = query_string.split("?")[1];
246 | }
247 |
248 | var queries = query_string.split("&");
249 | for (var i = 0; i < queries.length; i++) {
250 | var elem = queries[i];
251 |
252 | var query = elem.split("=");
253 | obj[query[0]] = query[1];
254 | obj.user_query[query[0]] = query[1];
255 | }
256 |
257 | // alias domain for vhost.
258 | if (obj.domain) {
259 | obj.vhost = obj.domain;
260 | }
261 | }
262 | };
263 |
264 | self.pc = new RTCPeerConnection(null);
265 |
266 | // To keep api consistent between player and publisher.
267 | // @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addStream#Migrating_to_addTrack
268 | // @see https://webrtc.org/getting-started/media-devices
269 | self.stream = new MediaStream();
270 |
271 | return self;
272 | }
273 |
274 | // Depends on adapter-7.4.0.min.js from https://github.com/webrtc/adapter
275 | // Async-await-promise based SRS RTC Player.
276 | function SrsRtcPlayerAsync() {
277 | var self = {};
278 |
279 | // @see https://github.com/rtcdn/rtcdn-draft
280 | // @url The WebRTC url to play with, for example:
281 | // webrtc://r.ossrs.net/live/livestream
282 | // or specifies the API port:
283 | // webrtc://r.ossrs.net:11985/live/livestream
284 | // or autostart the play:
285 | // webrtc://r.ossrs.net/live/livestream?autostart=true
286 | // or change the app from live to myapp:
287 | // webrtc://r.ossrs.net:11985/myapp/livestream
288 | // or change the stream from livestream to mystream:
289 | // webrtc://r.ossrs.net:11985/live/mystream
290 | // or set the api server to myapi.domain.com:
291 | // webrtc://myapi.domain.com/live/livestream
292 | // or set the candidate(ip) of answer:
293 | // webrtc://r.ossrs.net/live/livestream?eip=39.107.238.185
294 | // or force to access https API:
295 | // webrtc://r.ossrs.net/live/livestream?schema=https
296 | // or use plaintext, without SRTP:
297 | // webrtc://r.ossrs.net/live/livestream?encrypt=false
298 | // or any other information, will pass-by in the query:
299 | // webrtc://r.ossrs.net/live/livestream?vhost=xxx
300 | // webrtc://r.ossrs.net/live/livestream?token=xxx
301 | self.play = async function(url) {
302 | var conf = self.__internal.prepareUrl(url);
303 | self.pc.addTransceiver("audio", {direction: "recvonly"});
304 | self.pc.addTransceiver("video", {direction: "recvonly"});
305 |
306 | var offer = await self.pc.createOffer();
307 | await self.pc.setLocalDescription(offer);
308 | var session = await new Promise(function(resolve, reject) {
309 | // @see https://github.com/rtcdn/rtcdn-draft
310 | var data = {
311 | api: conf.apiUrl, tid: conf.tid, streamurl: conf.streamUrl,
312 | clientip: null, sdp: offer.sdp
313 | };
314 | console.log("Generated offer: ", data);
315 |
316 | $.ajax({
317 | type: "POST", url: conf.apiUrl, data: JSON.stringify(data),
318 | contentType:'application/json', dataType: 'json'
319 | }).done(function(data) {
320 | console.log("Got answer: ", data);
321 | if (data.code) {
322 | reject(data); return;
323 | }
324 |
325 | resolve(data);
326 | }).fail(function(reason){
327 | reject(reason);
328 | });
329 | });
330 | await self.pc.setRemoteDescription(
331 | new RTCSessionDescription({type: 'answer', sdp: session.sdp})
332 | );
333 | session.simulator = conf.schema + '//' + conf.urlObject.server + ':' + conf.port + '/rtc/v1/nack/';
334 | return session;
335 | };
336 |
337 | // Close the player.
338 | self.close = function() {
339 | self.pc && self.pc.close();
340 | self.pc = null;
341 | };
342 |
343 | // The callback when got remote track.
344 | // Note that the onaddstream is deprecated, @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/onaddstream
345 | self.ontrack = function (event) {
346 | // https://webrtc.org/getting-started/remote-streams
347 | self.stream.addTrack(event.track);
348 | };
349 |
350 | // Internal APIs.
351 | self.__internal = {
352 | defaultPath: '/rtc/v1/play/',
353 | prepareUrl: function (webrtcUrl) {
354 | var urlObject = self.__internal.parse(webrtcUrl);
355 |
356 | // If user specifies the schema, use it as API schema.
357 | var schema = urlObject.user_query.schema;
358 | schema = schema ? schema + ':' : window.location.protocol;
359 |
360 | var port = urlObject.port || 1985;
361 | if (schema === 'https:') {
362 | port = urlObject.port || 443;
363 | }
364 |
365 | // @see https://github.com/rtcdn/rtcdn-draft
366 | var api = urlObject.user_query.play || self.__internal.defaultPath;
367 | if (api.lastIndexOf('/') !== api.length - 1) {
368 | api += '/';
369 | }
370 |
371 | apiUrl = schema + '//' + urlObject.server + ':' + port + api;
372 | for (var key in urlObject.user_query) {
373 | if (key !== 'api' && key !== 'play') {
374 | apiUrl += '&' + key + '=' + urlObject.user_query[key];
375 | }
376 | }
377 | // Replace /rtc/v1/play/&k=v to /rtc/v1/play/?k=v
378 | var apiUrl = apiUrl.replace(api + '&', api + '?');
379 |
380 | var streamUrl = urlObject.url;
381 |
382 | return {
383 | apiUrl: apiUrl, streamUrl: streamUrl, schema: schema, urlObject: urlObject, port: port,
384 | tid: Number(parseInt(new Date().getTime()*Math.random()*100)).toString(16).slice(0, 7)
385 | };
386 | },
387 | parse: function (url) {
388 | // @see: http://stackoverflow.com/questions/10469575/how-to-use-location-object-to-parse-url-without-redirecting-the-page-in-javascri
389 | var a = document.createElement("a");
390 | a.href = url.replace("rtmp://", "http://")
391 | .replace("webrtc://", "http://")
392 | .replace("rtc://", "http://");
393 |
394 | var vhost = a.hostname;
395 | var app = a.pathname.substring(1, a.pathname.lastIndexOf("/"));
396 | var stream = a.pathname.slice(a.pathname.lastIndexOf("/") + 1);
397 |
398 | // parse the vhost in the params of app, that srs supports.
399 | app = app.replace("...vhost...", "?vhost=");
400 | if (app.indexOf("?") >= 0) {
401 | var params = app.slice(app.indexOf("?"));
402 | app = app.slice(0, app.indexOf("?"));
403 |
404 | if (params.indexOf("vhost=") > 0) {
405 | vhost = params.slice(params.indexOf("vhost=") + "vhost=".length);
406 | if (vhost.indexOf("&") > 0) {
407 | vhost = vhost.slice(0, vhost.indexOf("&"));
408 | }
409 | }
410 | }
411 |
412 | // when vhost equals to server, and server is ip,
413 | // the vhost is __defaultVhost__
414 | if (a.hostname === vhost) {
415 | var re = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;
416 | if (re.test(a.hostname)) {
417 | vhost = "__defaultVhost__";
418 | }
419 | }
420 |
421 | // parse the schema
422 | var schema = "rtmp";
423 | if (url.indexOf("://") > 0) {
424 | schema = url.slice(0, url.indexOf("://"));
425 | }
426 |
427 | var port = a.port;
428 | if (!port) {
429 | if (schema === 'http') {
430 | port = 80;
431 | } else if (schema === 'https') {
432 | port = 443;
433 | } else if (schema === 'rtmp') {
434 | port = 1935;
435 | }
436 | }
437 |
438 | var ret = {
439 | url: url,
440 | schema: schema,
441 | server: a.hostname, port: port,
442 | vhost: vhost, app: app, stream: stream
443 | };
444 | self.__internal.fill_query(a.search, ret);
445 |
446 | // For webrtc API, we use 443 if page is https, or schema specified it.
447 | if (!ret.port) {
448 | if (schema === 'webrtc' || schema === 'rtc') {
449 | if (ret.user_query.schema === 'https') {
450 | ret.port = 443;
451 | } else if (window.location.href.indexOf('https://') === 0) {
452 | ret.port = 443;
453 | } else {
454 | // For WebRTC, SRS use 1985 as default API port.
455 | ret.port = 1985;
456 | }
457 | }
458 | }
459 |
460 | return ret;
461 | },
462 | fill_query: function (query_string, obj) {
463 | // pure user query object.
464 | obj.user_query = {};
465 |
466 | if (query_string.length === 0) {
467 | return;
468 | }
469 |
470 | // split again for angularjs.
471 | if (query_string.indexOf("?") >= 0) {
472 | query_string = query_string.split("?")[1];
473 | }
474 |
475 | var queries = query_string.split("&");
476 | for (var i = 0; i < queries.length; i++) {
477 | var elem = queries[i];
478 |
479 | var query = elem.split("=");
480 | obj[query[0]] = query[1];
481 | obj.user_query[query[0]] = query[1];
482 | }
483 |
484 | // alias domain for vhost.
485 | if (obj.domain) {
486 | obj.vhost = obj.domain;
487 | }
488 | }
489 | };
490 |
491 | self.pc = new RTCPeerConnection(null);
492 |
493 | // Create a stream to add track to the stream, @see https://webrtc.org/getting-started/remote-streams
494 | self.stream = new MediaStream();
495 |
496 | // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/ontrack
497 | self.pc.ontrack = function(event) {
498 | if (self.ontrack) {
499 | self.ontrack(event);
500 | }
501 | };
502 |
503 | return self;
504 | }
505 |
506 | // Format the codec of RTCRtpSender, kind(audio/video) is optional filter.
507 | // https://developer.mozilla.org/en-US/docs/Web/Media/Formats/WebRTC_codecs#getting_the_supported_codecs
508 | function SrsRtcFormatSenders(senders, kind) {
509 | var codecs = [];
510 | senders.forEach(function (sender) {
511 | var params = sender.getParameters();
512 | params && params.codecs && params.codecs.forEach(function(c) {
513 | if (kind && sender.track.kind !== kind) {
514 | return;
515 | }
516 |
517 | if (c.mimeType.indexOf('/red') > 0 || c.mimeType.indexOf('/rtx') > 0 || c.mimeType.indexOf('/fec') > 0) {
518 | return;
519 | }
520 |
521 | var s = '';
522 |
523 | s += c.mimeType.replace('audio/', '').replace('video/', '');
524 | s += ', ' + c.clockRate + 'HZ';
525 | if (sender.track.kind === "audio") {
526 | s += ', channels: ' + c.channels;
527 | }
528 | s += ', pt: ' + c.payloadType;
529 |
530 | codecs.push(s);
531 | });
532 | });
533 | return codecs.join(", ");
534 | }
535 |
536 |
--------------------------------------------------------------------------------
39 | SRS:
40 |
41 | Room:
42 |
43 | Display:
44 |
45 |
46 |
47 |
48 |
49 |
56 |
66 |
67 |
68 |
69 |
70 |
97 |
98 |
99 |
100 |
120 |