← Back to branch summary

~cloud-green/juju-core/charmstore-sdist

« back to all changes in this revision

Viewing changes to launchpad.net/gwacl/fork/http/chunked.go

  • Committer: Casey Marshall
  • Date: 2014-03-27 15:59:46 UTC
  • Revision ID: cmars@cmarstech.com-20140327155946-8huorf37g0zwar43
Source distribution of launchpad.net/juju-core created 20140327105939

Show diffs side-by-side

added added

removed removed

Lines of Context:
launchpad.net/gwacl/fork/http/chunked.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
// The wire protocol for HTTP's "chunked" Transfer-Encoding.
 
6
 
 
7
// This code is duplicated in httputil/chunked.go.
 
8
// Please make any changes in both files.
 
9
 
 
10
package http
 
11
 
 
12
import (
 
13
    "bufio"
 
14
    "bytes"
 
15
    "errors"
 
16
    "io"
 
17
    "strconv"
 
18
)
 
19
 
 
20
const maxLineLength = 4096 // assumed <= bufio.defaultBufSize
 
21
 
 
22
var ErrLineTooLong = errors.New("header line too long")
 
23
 
 
24
// newChunkedReader returns a new chunkedReader that translates the data read from r
 
25
// out of HTTP "chunked" format before returning it.
 
26
// The chunkedReader returns io.EOF when the final 0-length chunk is read.
 
27
//
 
28
// newChunkedReader is not needed by normal applications. The http package
 
29
// automatically decodes chunking when reading response bodies.
 
30
func newChunkedReader(r io.Reader) io.Reader {
 
31
    br, ok := r.(*bufio.Reader)
 
32
    if !ok {
 
33
        br = bufio.NewReader(r)
 
34
    }
 
35
    return &chunkedReader{r: br}
 
36
}
 
37
 
 
38
type chunkedReader struct {
 
39
    r   *bufio.Reader
 
40
    n   uint64 // unread bytes in chunk
 
41
    err error
 
42
}
 
43
 
 
44
func (cr *chunkedReader) beginChunk() {
 
45
    // chunk-size CRLF
 
46
    var line string
 
47
    line, cr.err = readLine(cr.r)
 
48
    if cr.err != nil {
 
49
        return
 
50
    }
 
51
    cr.n, cr.err = strconv.ParseUint(line, 16, 64)
 
52
    if cr.err != nil {
 
53
        return
 
54
    }
 
55
    if cr.n == 0 {
 
56
        cr.err = io.EOF
 
57
    }
 
58
}
 
59
 
 
60
func (cr *chunkedReader) Read(b []uint8) (n int, err error) {
 
61
    if cr.err != nil {
 
62
        return 0, cr.err
 
63
    }
 
64
    if cr.n == 0 {
 
65
        cr.beginChunk()
 
66
        if cr.err != nil {
 
67
            return 0, cr.err
 
68
        }
 
69
    }
 
70
    if uint64(len(b)) > cr.n {
 
71
        b = b[0:cr.n]
 
72
    }
 
73
    n, cr.err = cr.r.Read(b)
 
74
    cr.n -= uint64(n)
 
75
    if cr.n == 0 && cr.err == nil {
 
76
        // end of chunk (CRLF)
 
77
        b := make([]byte, 2)
 
78
        if _, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
 
79
            if b[0] != '\r' || b[1] != '\n' {
 
80
                cr.err = errors.New("malformed chunked encoding")
 
81
            }
 
82
        }
 
83
    }
 
84
    return n, cr.err
 
85
}
 
86
 
 
87
// Read a line of bytes (up to \n) from b.
 
88
// Give up if the line exceeds maxLineLength.
 
89
// The returned bytes are a pointer into storage in
 
90
// the bufio, so they are only valid until the next bufio read.
 
91
func readLineBytes(b *bufio.Reader) (p []byte, err error) {
 
92
    if p, err = b.ReadSlice('\n'); err != nil {
 
93
        // We always know when EOF is coming.
 
94
        // If the caller asked for a line, there should be a line.
 
95
        if err == io.EOF {
 
96
            err = io.ErrUnexpectedEOF
 
97
        } else if err == bufio.ErrBufferFull {
 
98
            err = ErrLineTooLong
 
99
        }
 
100
        return nil, err
 
101
    }
 
102
    if len(p) >= maxLineLength {
 
103
        return nil, ErrLineTooLong
 
104
    }
 
105
 
 
106
    // Chop off trailing white space.
 
107
    p = bytes.TrimRight(p, " \r\t\n")
 
108
 
 
109
    return p, nil
 
110
}
 
111
 
 
112
// readLineBytes, but convert the bytes into a string.
 
113
func readLine(b *bufio.Reader) (s string, err error) {
 
114
    p, e := readLineBytes(b)
 
115
    if e != nil {
 
116
        return "", e
 
117
    }
 
118
    return string(p), nil
 
119
}
 
120
 
 
121
// newChunkedWriter returns a new chunkedWriter that translates writes into HTTP
 
122
// "chunked" format before writing them to w. Closing the returned chunkedWriter
 
123
// sends the final 0-length chunk that marks the end of the stream.
 
124
//
 
125
// newChunkedWriter is not needed by normal applications. The http
 
126
// package adds chunking automatically if handlers don't set a
 
127
// Content-Length header. Using newChunkedWriter inside a handler
 
128
// would result in double chunking or chunking with a Content-Length
 
129
// length, both of which are wrong.
 
130
func newChunkedWriter(w io.Writer) io.WriteCloser {
 
131
    return &chunkedWriter{w}
 
132
}
 
133
 
 
134
// Writing to chunkedWriter translates to writing in HTTP chunked Transfer
 
135
// Encoding wire format to the underlying Wire chunkedWriter.
 
136
type chunkedWriter struct {
 
137
    Wire io.Writer
 
138
}
 
139
 
 
140
// Write the contents of data as one chunk to Wire.
 
141
// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
 
142
// a bug since it does not check for success of io.WriteString
 
143
func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
 
144
 
 
145
    // Don't send 0-length data. It looks like EOF for chunked encoding.
 
146
    if len(data) == 0 {
 
147
        return 0, nil
 
148
    }
 
149
 
 
150
    head := strconv.FormatInt(int64(len(data)), 16) + "\r\n"
 
151
 
 
152
    if _, err = io.WriteString(cw.Wire, head); err != nil {
 
153
        return 0, err
 
154
    }
 
155
    if n, err = cw.Wire.Write(data); err != nil {
 
156
        return
 
157
    }
 
158
    if n != len(data) {
 
159
        err = io.ErrShortWrite
 
160
        return
 
161
    }
 
162
    _, err = io.WriteString(cw.Wire, "\r\n")
 
163
 
 
164
    return
 
165
}
 
166
 
 
167
func (cw *chunkedWriter) Close() error {
 
168
    _, err := io.WriteString(cw.Wire, "0\r\n")
 
169
    return err
 
170
}