mirror of
https://github.com/valyala/fasthttp.git
synced 2026-06-13 15:46:49 +03:00
Moritz Poldrack
d0f2727a4d
* client: simplify (*HostClient).do() Remove an allocation in favour of deferring a call to release the response. * client: remove panic in dialAddr Return an error instead of panicking if the user supplied a nonsensical DialFunc. * compression: remove panic on invalid compression level If a compression level exceeding gzip's boundaries is provided, fasthttp will panic. Instead it would be better to handle this error for them by limiting it to the minimum or maximum value, depending on the direction the user has exceeded the limits. Clamp the value of gzip to always be between gzip.BestSpeed and gzip.BestCompression. * peripconn: remove panic on negative connection count When a negative count is reached when unregistering a connection, a panic is caused even though data-integrity is not at risk. Replace the panic() with a simple clamp on the value to ensure the value does not exceed it's expected lower bounds. References: #1504 * compress: remove error on failed nonblocking writes Since there is no way of handling or even logging non-critical errors in stateless non-blocking writecalls, just drop them and hope the user notices and tries again. * workerPool: remove panic on redundant Start and Stop calls Instead of panicking for invalid behaviour, it's preferable to just turn the function into a noop. * http: remove panic on invalid form boundary * http: remove panic on negative reads Since bufio already panics on negative reads, it is not necessary to do so as well. If the length is zero and for some reason no error is returned, readBodyIdentity and appendBodyFixedSize now errors in these cases. Link: https://github.com/golang/go/blob/851f6fd61425c810959c7ab51e6dc86f8a63c970/src/bufio/bufio.go#L246 * fs: remove panic on negative reader count When a negative count is reached when unregistering a reader, a panic is thrown even though data-integrity is not at risk. Replace the panic() with a simple clamp on the value to ensure the value does not exceed it's expected lower bounds. * server: remove panic in favour of a segfault Panicking with "BUG: " obscures the error. As the segfault causes a panic anyway, just let the chaos unfold. * server: remove panic in favour of returning an error Writing on a timed-out response is not endangering data integrity and just fails. * chore: add comments to all panics * chore: fix minor typo
101 lines
1.7 KiB
Go
101 lines
1.7 KiB
Go
package fasthttp
|
|
|
|
import (
|
|
"net"
|
|
"sync"
|
|
)
|
|
|
|
type perIPConnCounter struct {
|
|
pool sync.Pool
|
|
lock sync.Mutex
|
|
m map[uint32]int
|
|
}
|
|
|
|
func (cc *perIPConnCounter) Register(ip uint32) int {
|
|
cc.lock.Lock()
|
|
if cc.m == nil {
|
|
cc.m = make(map[uint32]int)
|
|
}
|
|
n := cc.m[ip] + 1
|
|
cc.m[ip] = n
|
|
cc.lock.Unlock()
|
|
return n
|
|
}
|
|
|
|
func (cc *perIPConnCounter) Unregister(ip uint32) {
|
|
cc.lock.Lock()
|
|
defer cc.lock.Unlock()
|
|
if cc.m == nil {
|
|
// developer safeguard
|
|
panic("BUG: perIPConnCounter.Register() wasn't called")
|
|
}
|
|
n := cc.m[ip] - 1
|
|
if n < 0 {
|
|
n = 0
|
|
}
|
|
cc.m[ip] = n
|
|
}
|
|
|
|
type perIPConn struct {
|
|
net.Conn
|
|
|
|
ip uint32
|
|
perIPConnCounter *perIPConnCounter
|
|
}
|
|
|
|
func acquirePerIPConn(conn net.Conn, ip uint32, counter *perIPConnCounter) *perIPConn {
|
|
v := counter.pool.Get()
|
|
if v == nil {
|
|
return &perIPConn{
|
|
perIPConnCounter: counter,
|
|
Conn: conn,
|
|
ip: ip,
|
|
}
|
|
}
|
|
c := v.(*perIPConn)
|
|
c.Conn = conn
|
|
c.ip = ip
|
|
return c
|
|
}
|
|
|
|
func releasePerIPConn(c *perIPConn) {
|
|
c.Conn = nil
|
|
c.perIPConnCounter.pool.Put(c)
|
|
}
|
|
|
|
func (c *perIPConn) Close() error {
|
|
err := c.Conn.Close()
|
|
c.perIPConnCounter.Unregister(c.ip)
|
|
releasePerIPConn(c)
|
|
return err
|
|
}
|
|
|
|
func getUint32IP(c net.Conn) uint32 {
|
|
return ip2uint32(getConnIP4(c))
|
|
}
|
|
|
|
func getConnIP4(c net.Conn) net.IP {
|
|
addr := c.RemoteAddr()
|
|
ipAddr, ok := addr.(*net.TCPAddr)
|
|
if !ok {
|
|
return net.IPv4zero
|
|
}
|
|
return ipAddr.IP.To4()
|
|
}
|
|
|
|
func ip2uint32(ip net.IP) uint32 {
|
|
if len(ip) != 4 {
|
|
return 0
|
|
}
|
|
return uint32(ip[0])<<24 | uint32(ip[1])<<16 | uint32(ip[2])<<8 | uint32(ip[3])
|
|
}
|
|
|
|
func uint322ip(ip uint32) net.IP {
|
|
b := make([]byte, 4)
|
|
b[0] = byte(ip >> 24)
|
|
b[1] = byte(ip >> 16)
|
|
b[2] = byte(ip >> 8)
|
|
b[3] = byte(ip)
|
|
return b
|
|
}
|