package/requests
1
0
Fork 0
mirror of https://github.com/gospider007/requests.git synced 2025-12-24 13:57:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

sync

Browse Source
This commit is contained in:
gospider
2025-07-29 16:12:21 +08:00
parent a08970461a
commit 01bdec0987
4 changed files with 0 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored Normal file
View File

Binary file not shown.

5
errors.go
View File

@@ -1,5 +0,0 @@
package requests
import "errors"
var errConnectionForceClosed = errors.New("errConnectionClosed")

281
http.go
View File

@@ -1,281 +0,0 @@
package requests
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"net"
"net/http"
"github.com/gospider007/tools"
"golang.org/x/net/http/httpguts"
)
type rsp struct {
r *http.Response
ctx context.Context
err error
}
type clientConn struct {
conn net.Conn
r *bufio.Reader
w *bufio.Writer
closeFunc func(error)
ctx context.Context
cnl context.CancelCauseFunc
rsps chan *rsp
}
func NewClientConn(con net.Conn, closeFunc func(error)) *clientConn {
ctx, cnl := context.WithCancelCause(context.TODO())
c := &clientConn{
ctx: ctx,
cnl: cnl,
conn: con,
closeFunc: closeFunc,
rsps: make(chan *rsp),
r: bufio.NewReader(con),
w: bufio.NewWriter(con),
}
go c.read()
return c
}
func (obj *clientConn) read() {
var err error
var res *http.Response
defer obj.CloseWithError(err)
for {
res, err = http.ReadResponse(obj.r, nil)
if res == nil && err == nil {
err = errors.New("response is nil")
}
if err != nil {
select {
case obj.rsps <- &rsp{res, nil, err}:
case <-obj.ctx.Done():
return
}
return
}
if res.StatusCode == 101 {
select {
case obj.rsps <- &rsp{res, obj.ctx, err}:
case <-obj.ctx.Done():
return
}
<-obj.ctx.Done()
return
} else if res == nil || res.Body == nil || res.Body == http.NoBody {
select {
case obj.rsps <- &rsp{res, nil, err}:
case <-obj.ctx.Done():
return
}
} else {
ctx, cnl := context.WithCancelCause(obj.ctx)
res.Body = &clientBody{res.Body, cnl}
select {
case obj.rsps <- &rsp{res, ctx, err}:
case <-obj.ctx.Done():
return
}
<-ctx.Done()
}
select {
case <-obj.ctx.Done():
return
default:
}
}
}
func (obj *clientConn) httpWrite(req *http.Request, rawHeaders http.Header, orderHeaders []interface {
Key() string
Val() any
}) (err error) {
defer func() {
if err != nil {
obj.CloseWithError(tools.WrapError(err, "failed to send request body"))
}
}()
host := req.Host
if host == "" {
host = req.URL.Host
}
host, err = httpguts.PunycodeHostPort(host)
if err != nil {
return
}
host = removeZone(host)
if rawHeaders.Get("Host") == "" {
rawHeaders.Set("Host", host)
}
contentL, chunked := tools.GetContentLength(req)
if contentL >= 0 {
rawHeaders.Set("Content-Length", fmt.Sprint(contentL))
} else if chunked {
rawHeaders.Set("Transfer-Encoding", "chunked")
}
ruri := req.URL.RequestURI()
if req.Method == "CONNECT" && req.URL.Path == "" {
if req.URL.Opaque != "" {
ruri = req.URL.Opaque
} else {
ruri = host
}
}
if _, err = obj.w.WriteString(fmt.Sprintf("%s %s %s\r\n", req.Method, ruri, req.Proto)); err != nil {
return
}
for _, kv := range tools.NewHeadersWithH1(orderHeaders, rawHeaders) {
if _, err = obj.w.WriteString(fmt.Sprintf("%s: %s\r\n", kv[0], kv[1])); err != nil {
return
}
}
if _, err = obj.w.WriteString("\r\n"); err != nil {
return
}
if req.Body == nil {
err = obj.w.Flush()
return
}
if chunked {
chunkedWriter := newChunkedWriter(obj.w)
if _, err = tools.Copy(chunkedWriter, req.Body); err != nil {
return
}
if err = chunkedWriter.Close(); err != nil {
return
}
} else {
if _, err = tools.Copy(obj.w, req.Body); err != nil {
return
}
}
err = obj.w.Flush()
return
}
type clientBody struct {
r io.Reader
cnl context.CancelCauseFunc
}
func (obj *clientBody) Read(p []byte) (n int, err error) {
return obj.r.Read(p)
}
func (obj *clientBody) Close() error {
return obj.CloseWithError(nil)
}
func (obj *clientBody) CloseWithError(err error) error {
obj.cnl(err)
return nil
}
func (obj *clientConn) DoRequest(req *http.Request, orderHeaders []interface {
Key() string
Val() any
}) (res *http.Response, ctx context.Context, err error) {
defer func() {
if err != nil {
obj.CloseWithError(tools.WrapError(err, "failed to send request"))
}
}()
var writeErr error
writeDone := make(chan struct{})
go func() {
writeErr = obj.httpWrite(req, req.Header.Clone(), orderHeaders)
close(writeDone)
}()
select {
case <-writeDone:
if writeErr != nil {
return nil, nil, writeErr
}
select {
case <-req.Context().Done():
return nil, nil, req.Context().Err()
case <-obj.ctx.Done():
return nil, nil, obj.ctx.Err()
case rsp := <-obj.rsps:
return rsp.r, rsp.ctx, rsp.err
}
case <-req.Context().Done():
return nil, nil, req.Context().Err()
case <-obj.ctx.Done():
return nil, nil, obj.ctx.Err()
case rsp := <-obj.rsps:
return rsp.r, rsp.ctx, rsp.err
}
}
func (obj *clientConn) Close() error {
return obj.CloseWithError(nil)
}
func (obj *clientConn) CloseWithError(err error) error {
if obj.closeFunc != nil {
obj.closeFunc(err)
}
obj.cnl(err)
return obj.conn.Close()
}
func (obj *clientConn) Stream() io.ReadWriteCloser {
return &websocketConn{
cnl: obj.cnl,
r: obj.r,
w: obj.conn,
}
}
func newChunkedWriter(w *bufio.Writer) io.WriteCloser {
return &chunkedWriter{w}
}
type chunkedWriter struct {
w *bufio.Writer
}
func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
if len(data) == 0 {
return 0, nil
}
if _, err = fmt.Fprintf(cw.w, "%x\r\n", len(data)); err != nil {
return 0, err
}
if _, err = cw.w.Write(data); err != nil {
return
}
if _, err = io.WriteString(cw.w, "\r\n"); err != nil {
return
}
return len(data), cw.w.Flush()
}
func (cw *chunkedWriter) Close() error {
_, err := io.WriteString(cw.w, "0\r\n\r\n")
return err
}
type websocketConn struct {
r io.Reader
w io.WriteCloser
cnl context.CancelCauseFunc
}
func (obj *websocketConn) Read(p []byte) (n int, err error) {
return obj.r.Read(p)
}
func (obj *websocketConn) Write(p []byte) (n int, err error) {
// i, err := obj.w.Write(p)
// log.Print(err, " write error ", i, p)
// return i, err
return obj.w.Write(p)
}
func (obj *websocketConn) Close() error {
obj.cnl(nil)
return obj.w.Close()
}

41
rw.go
View File

@@ -1,41 +0,0 @@
package requests
import (
"errors"
"io"
"github.com/gospider007/http1"
"github.com/gospider007/tools"
)
type wrapBody struct {
rawBody *http1.ClientBody
conn *connecotr
}
func (obj *wrapBody) connStream() io.ReadWriteCloser {
return obj.conn.Conn.Stream()
}
func (obj *wrapBody) Read(p []byte) (n int, err error) {
return obj.rawBody.Read(p)
}
func (obj *wrapBody) Proxys() []Address {
return obj.conn.proxys
}
func (obj *wrapBody) Close() error {
return obj.CloseWithError(nil)
}
func (obj *wrapBody) CloseWithError(err error) error {
if err != nil && err != tools.ErrNoErr {
obj.conn.CloseWithError(err)
}
return obj.rawBody.CloseWithError(err)
}
// safe close conn
func (obj *wrapBody) CloseConn() {
obj.conn.forceCnl(errors.New("readWriterCloser close conn"))
obj.conn.CloseWithError(errConnectionForceClosed)
}