iframe-proxy | Sunbelt Computer Software

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

package req

import (

"encoding/base64"

"fmt"

"io"

"net/http"

"net/textproto"

"strings"

"github.com/imroc/req/v3/internal/ascii"

"golang.org/x/net/http/httpguts"

"golang.org/x/net/idna"

)

// maxInt64 is the effective "infinite" value for the Server and

// Transport's byte-limiting readers.

const maxInt64 = 1<<63 - 1

// incomparable is a zero-width, non-comparable type. Adding it to a struct

// makes that struct also non-comparable, and generally doesn't add

// any size (as long as it's first).

type incomparable [0]func()

// bodyIsWritable reports whether the Body supports writing. The

// Transport returns Writable bodies for 101 Switching Protocols

// responses.

// The Transport uses this method to determine whether a persistent

// connection is done being managed from its perspective. Once we

// return a writable response body to a user, the net/http package is

// done managing that connection.

func bodyIsWritable(r *http.Response) bool {

_, ok := r.Body.(io.Writer)

return ok

}

// isProtocolSwitch reports whether the response code and header

// indicate a successful protocol upgrade response.

func isProtocolSwitch(r *http.Response) bool {

return isProtocolSwitchResponse(r.StatusCode, r.Header)

}

// isProtocolSwitchResponse reports whether the response code and

// response header indicate a successful protocol upgrade response.

func isProtocolSwitchResponse(code int, h http.Header) bool {

return code == http.StatusSwitchingProtocols && isProtocolSwitchHeader(h)

}

// isProtocolSwitchHeader reports whether the request or response header

// is for a protocol switch.

func isProtocolSwitchHeader(h http.Header) bool {

return h.Get("Upgrade") != "" &&

httpguts.HeaderValuesContainsToken(h["Connection"], "Upgrade")

}

// NoBody is an io.ReadCloser with no bytes. Read always returns EOF

// and Close always returns nil. It can be used in an outgoing client

// request to explicitly signal that a request has zero bytes.

// An alternative, however, is to simply set Request.Body to nil.

var NoBody = noBody{}

type noBody struct{}

func (noBody) Read([]byte) (int, error) { return 0, io.EOF }

func (noBody) Close() error { return nil }

func (noBody) WriteTo(io.Writer) (int64, error) { return 0, nil }

var (

// verify that an io.Copy from NoBody won't require a buffer:

_ io.WriterTo = NoBody

_ io.ReadCloser = NoBody

)

type readResult struct {

_ incomparable

n int

err error

b byte // byte read, if n == 1

}

// hasToken reports whether token appears with v, ASCII

// case-insensitive, with space or comma boundaries.

// token must be all lowercase.

// v may contain mixed cased.

func hasToken(v, token string) bool {

if len(token) > len(v) || token == "" {

return false

}

if v == token {

return true

}

for sp := 0; sp <= len(v)-len(token); sp++ {

// Check that first character is good.

// The token is ASCII, so checking only a single byte

// is sufficient. We skip this potential starting

// position if both the first byte and its potential

// ASCII uppercase equivalent (b|0x20) don't match.

// False positives ('^' => '~') are caught by EqualFold.

if b := v[sp]; b != token[0] && b|0x20 != token[0] {

continue

}

// Check that start pos is on a valid token boundary.

if sp > 0 && !isTokenBoundary(v[sp-1]) {

continue

}

// Check that end pos is on a valid token boundary.

if endPos := sp + len(token); endPos != len(v) && !isTokenBoundary(v[endPos]) {

continue

}

if ascii.EqualFold(v[sp:sp+len(token)], token) {

return true

}

return false

}

func isTokenBoundary(b byte) bool {

return b == ' ' || b == ',' || b == '\t'

}

func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }

// foreachHeaderElement splits v according to the "#rule" construction

// in RFC 7230 section 7 and calls fn for each non-empty element.

func foreachHeaderElement(v string, fn func(string)) {

v = textproto.TrimString(v)

if v == "" {

return

}

if !strings.Contains(v, ",") {

fn(v)

return

}

for _, f := range strings.Split(v, ",") {

if f = textproto.TrimString(f); f != "" {

fn(f)

}

// maxPostHandlerReadBytes is the max number of Request.Body bytes not

// consumed by a handler that the server will read from the client

// in order to keep a connection alive. If there are more bytes than

// this then the server to be paranoid instead sends a "Connection:

// close" response.

// This number is approximately what a typical machine's TCP buffer

// size is anyway. (if we have the bytes on the machine, we might as

// well read them)

const maxPostHandlerReadBytes = 256 << 10

func idnaASCII(v string) (string, error) {

// TODO: Consider removing this check after verifying performance is okay.

// Right now punycode verification, length checks, context checks, and the

// permissible character tests are all omitted. It also prevents the ToASCII

// call from salvaging an invalid IDN, when possible. As a result it may be

// possible to have two IDNs that appear identical to the user where the

// ASCII-only version causes an error downstream whereas the non-ASCII

// version does not.

// Note that for correct ASCII IDNs ToASCII will only do considerably more

// work, but it will not cause an allocation.

if ascii.Is(v) {

return v, nil

}

return idna.Lookup.ToASCII(v)

}

// removeZone removes IPv6 zone identifier from host.

// E.g., "[fe80::1%en0]:8080" to "[fe80::1]:8080"

func removeZone(host string) string {

if !strings.HasPrefix(host, "[") {

return host

}

i := strings.LastIndex(host, "]")

if i < 0 {

return host

}

j := strings.LastIndex(host[:i], "%")

if j < 0 {

return host

}

return host[:j] + host[i:]

}

// stringContainsCTLByte reports whether s contains any ASCII control character.

func stringContainsCTLByte(s string) bool {

for i := 0; i < len(s); i++ {

b := s[i]

if b < ' ' || b == 0x7f {

return true

}

return false

}

// See 2 (end of page 4) https://www.ietf.org/rfc/rfc2617.txt

// "To receive authorization, the client sends the userid and password,

// separated by a single colon (":") character, within a base64

// encoded string in the credentials."

// It is not meant to be urlencoded.

func basicAuth(username, password string) string {

auth := username + ":" + password

return base64.StdEncoding.EncodeToString([]byte(auth))

}

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Repository navigation

http.go

http.go

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

http.go

Latest commit

History

http.go

File metadata and controls