forked from madari/go-socket.io
/
transport_htmlfile.go
121 lines (98 loc) · 2.77 KB
/
transport_htmlfile.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package socketio
import (
"http"
"os"
"io"
"bytes"
"strings"
"json"
"net"
"fmt"
)
var htmlfileHeader = "<html><body>" + strings.Repeat(" ", 244)
// The xhr-multipart transport.
type htmlfileTransport struct {
rtimeout int64 // The period during which the client must send a message.
wtimeout int64 // The period during which a write must succeed.
}
// Creates a new xhr-multipart transport with the given read and write timeouts.
func NewHTMLFileTransport(rtimeout, wtimeout int64) Transport {
return &htmlfileTransport{rtimeout, wtimeout}
}
// Returns the resource name.
func (t *htmlfileTransport) Resource() string {
return "htmlfile"
}
// Creates a new socket that can be used with a connection.
func (t *htmlfileTransport) newSocket() socket {
return &htmlfileSocket{t: t}
}
// Implements the socket interface for xhr-multipart transports.
type htmlfileSocket struct {
t *htmlfileTransport
rwc io.ReadWriteCloser
connected bool
}
// String returns a verbose representation of the socket.
func (s *htmlfileSocket) String() string {
return s.t.Resource()
}
// Transport returns the transport the socket is based on.
func (s *htmlfileSocket) Transport() Transport {
return s.t
}
// Accepts a http connection & request pair. It hijacks the connection, sends headers and calls
// proceed if succesfull.
func (s *htmlfileSocket) accept(w http.ResponseWriter, req *http.Request, proceed func()) (err os.Error) {
if s.connected {
return ErrConnected
}
rwc, _, err := w.(http.Hijacker).Hijack()
if err == nil {
rwc.(*net.TCPConn).SetReadTimeout(s.t.rtimeout)
rwc.(*net.TCPConn).SetWriteTimeout(s.t.wtimeout)
buf := new(bytes.Buffer)
buf.WriteString("HTTP/1.1 200 OK\r\n")
buf.WriteString("Content-Type: text/html\r\n")
buf.WriteString("Connection: keep-alive\r\n")
buf.WriteString("Transfer-Encoding: chunked\r\n\r\n")
if _, err = buf.WriteTo(rwc); err != nil {
rwc.Close()
return
}
if _, err = fmt.Fprintf(rwc, "%x\r\n%s\r\n", len(htmlfileHeader), htmlfileHeader); err != nil {
rwc.Close()
return
}
s.rwc = rwc
s.connected = true
proceed()
}
return
}
func (s *htmlfileSocket) Read(p []byte) (n int, err os.Error) {
if !s.connected {
return 0, ErrNotConnected
}
return s.rwc.Read(p)
}
// Write sends a single multipart message to the wire.
func (s *htmlfileSocket) Write(p []byte) (n int, err os.Error) {
if !s.connected {
return 0, ErrNotConnected
}
var jp []byte
var buf bytes.Buffer
if jp, err = json.Marshal(string(p)); err != nil {
return
}
fmt.Fprintf(&buf, "<script>parent.s._(%s, document);</script>", jp)
return fmt.Fprintf(s.rwc, "%x\r\n%s\r\n", buf.Len(), buf.String())
}
func (s *htmlfileSocket) Close() os.Error {
if !s.connected {
return ErrNotConnected
}
s.connected = false
return s.rwc.Close()
}