feat: upgrade goVirtualHost v1.3.0

Author: marjune163

src/goVirtualHost/const.go

@@ -0,0 +1,12 @@
+package goVirtualHost
+
+const tcp46 = "tcp"
+const tcp4 = "tcp4"
+const tcp6 = "tcp6"
+const unix = "unix"
+
+const ip4ver = 4
+const ip6ver = 6
+
+const httpUrl = "http://"
+const httpsUrl = "https://"

src/goVirtualHost/errorwrapper.go

@@ -0,0 +1,18 @@
+package goVirtualHost
+
+type errorWrapper struct {
+	parent  error
+	message string
+}
+
+func (wrapper errorWrapper) Error() string {
+	return wrapper.message
+}
+
+func (wrapper errorWrapper) Unwrap() error {
+	return wrapper.parent
+}
+
+func wrapError(parent error, message string) errorWrapper {
+	return errorWrapper{parent, message}
+}

src/goVirtualHost/hostInfo.go

@@ -3,27 +3,25 @@ package goVirtualHost
 import "crypto/tls"
 
 func (info *HostInfo) toParam(listen string, useTLS bool) *param {
-	proto, addr := splitListen(listen, false)
+	proto, ip, port := splitListen(listen, false)
 	var cert *tls.Certificate
 	if useTLS {
 		cert = info.Cert
 	}
 
 	param := &param{
-		proto:   proto,
-		addr:    addr,
-		useTLS:  useTLS,
-		cert:    cert,
-		handler: info.Handler,
+		proto:  proto,
+		ip:     ip,
+		port:   port,
+		useTLS: useTLS,
+		cert:   cert,
 	}
 
 	return param
 }
 
-func (info *HostInfo) toParams() params {
-	params := params{}
-
-	hostNames := normalizeHostNames(info.HostNames)
+func (info *HostInfo) parse() (hostNames []string, params params) {
+	hostNames = normalizeHostNames(info.HostNames)
 
 	for _, listen := range info.Listens {
 		param := info.toParam(listen, info.Cert != nil)
@@ -43,5 +41,5 @@ func (info *HostInfo) toParams() params {
 		params = append(params, param)
 	}
 
-	return params
+	return
 }

src/goVirtualHost/ipaddr.go

@@ -0,0 +1,51 @@
+package goVirtualHost
+
+import (
+	"errors"
+	"net"
+)
+
+var unknownIPVersion = errors.New("unknown IP version")
+
+func isPrivateIPv4(netIPv4 net.IP) bool {
+	return netIPv4[0] == 10 ||
+		(netIPv4[0] == 172 && netIPv4[1]&0xf0 == 16) ||
+		(netIPv4[0] == 192 && netIPv4[1] == 168)
+}
+
+func isPrivateIPv6(netIPv6 net.IP) bool {
+	return netIPv6[0]&0xfe == 0xfc
+}
+
+func newIPAddr(netIP net.IP) (*ipAddr, error) {
+	var version int
+	var isNonPrivate bool
+
+	if netIPv4 := netIP.To4(); netIPv4 != nil {
+		version = ip4ver
+		isNonPrivate = !isPrivateIPv4(netIPv4)
+	} else if netIPv6 := netIP.To16(); netIPv6 != nil {
+		version = ip6ver
+		isNonPrivate = !isPrivateIPv6(netIPv6)
+	} else {
+		return nil, unknownIPVersion
+	}
+
+	instance := &ipAddr{
+		netIP:              netIP,
+		version:            version,
+		isGlobalUnicast:    netIP.IsGlobalUnicast(),
+		isLinkLocalUnicast: netIP.IsLinkLocalUnicast(),
+		isNonPrivate:       isNonPrivate,
+		isNonLoopback:      !netIP.IsLoopback(),
+	}
+	return instance, nil
+}
+
+func (addr *ipAddr) String() string {
+	if addr.version == ip6ver {
+		return "[" + addr.netIP.String() + "]"
+	} else {
+		return addr.netIP.String()
+	}
+}

src/goVirtualHost/ipaddr_test.go

@@ -0,0 +1,59 @@
+package goVirtualHost
+
+import (
+	"net"
+	"testing"
+)
+
+func TestIsPrivateIPv4(t *testing.T) {
+	var ip net.IP
+
+	ip = net.IPv4(10, 1, 2, 3).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(172, 16, 2, 3).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(172, 17, 2, 3).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(172, 30, 2, 3).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(172, 31, 2, 3).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(192, 168, 4, 5).To4()
+	if !isPrivateIPv4(ip) {
+		t.Error()
+	}
+
+	ip = net.IPv4(8, 8, 8, 8).To4()
+	if isPrivateIPv4(ip) {
+		t.Error()
+	}
+}
+
+func TestIsPrivateIPv6(t *testing.T) {
+	var ip net.IP
+
+	ip = net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
+	if !isPrivateIPv6(ip) {
+		t.Error()
+	}
+
+	ip = net.IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
+	if isPrivateIPv6(ip) {
+		t.Error()
+	}
+}

src/goVirtualHost/ipaddrs.go

@@ -0,0 +1,44 @@
+package goVirtualHost
+
+func (addrs ipAddrs) Len() int {
+	return len(addrs)
+}
+
+func (addrs ipAddrs) Less(i, j int) bool {
+	addr1 := addrs[i]
+	addr2 := addrs[j]
+
+	if addr1.isGlobalUnicast != addr2.isGlobalUnicast {
+		return addr1.isGlobalUnicast
+	}
+
+	if addr1.isLinkLocalUnicast != addr2.isLinkLocalUnicast {
+		return addr1.isLinkLocalUnicast
+	}
+
+	if addr1.isNonPrivate != addr2.isNonPrivate {
+		return addr1.isNonPrivate
+	}
+
+	if addr1.isNonLoopback != addr2.isNonLoopback {
+		return addr1.isNonLoopback
+	}
+
+	if addr1.version != addr2.version {
+		return addr1.version == ip4ver
+	}
+
+	return i < j
+}
+
+func (addrs ipAddrs) Swap(i, j int) {
+	addrs[i], addrs[j] = addrs[j], addrs[i]
+}
+
+func (addrs ipAddrs) String() []string {
+	results := make([]string, len(addrs))
+	for i := range addrs {
+		results[i] = addrs[i].String()
+	}
+	return results
+}

src/goVirtualHost/listener.go

@@ -5,28 +5,30 @@ import (
 	"os"
 )
 
-func newListener(proto, addr string) *listener {
+func newListener(proto, ip, port string) *listener {
 	listener := &listener{
 		proto: proto,
-		addr:  addr,
+		ip:    ip,
+		port:  port,
 	}
 
 	return listener
 }
 
 func (listener *listener) open() error {
+	addr := listener.ip + listener.port
 	if listener.proto == "unix" {
-		sockInfo, _ := os.Lstat(listener.addr)
+		sockInfo, _ := os.Lstat(addr)
 		if sockInfo != nil && (sockInfo.Mode()&os.ModeSocket != 0) {
-			os.Remove(listener.addr)
+			os.Remove(addr)
 		}
 	}
 
-	netListener, err := net.Listen(listener.proto, listener.addr)
+	netListener, err := net.Listen(listener.proto, addr)
 	listener.netListener = netListener
 
 	if listener.proto == "unix" && err == nil {
-		os.Chmod(listener.addr, 0777)
+		os.Chmod(addr, 0777)
 	}
 
 	return err

src/goVirtualHost/listeners.go

@@ -1,8 +1,8 @@
 package goVirtualHost
 
-func (listeners listeners) find(proto, addr string) *listener {
+func (listeners listeners) find(proto, ip, port string) *listener {
 	for _, l := range listeners {
-		if l.proto == proto && l.addr == addr {
+		if l.proto == proto && l.ip == ip && l.port == port {
 			return l
 		}
 	}

src/goVirtualHost/param.go

@@ -1,6 +1,11 @@
 package goVirtualHost
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
+
+var CertificateNotFound = errors.New("certificate not found for TLS listens")
 
 func (param *param) hasHostNames(checkHostNames []string) bool {
 	if len(param.hostNames) == 0 || len(checkHostNames) == 0 {
@@ -19,7 +24,7 @@ func (param *param) hasHostNames(checkHostNames []string) bool {
 
 func (param *param) validate() (errs []error) {
 	if param.useTLS && param.cert == nil {
-		err := fmt.Errorf("certificate not found for TLS listens: %+v", param)
+		err := wrapError(CertificateNotFound, fmt.Sprintf("certificate not found for TLS listens: %+v", param))
 		errs = append(errs, err)
 	}
 

src/goVirtualHost/param_test.go

@@ -0,0 +1,36 @@
+package goVirtualHost
+
+import (
+	"crypto/tls"
+	"errors"
+	"testing"
+)
+
+func TestParamValidate(t *testing.T) {
+	var p *param
+	var errs []error
+
+	p = &param{
+		proto: "tcp",
+		ip:    "",
+		port:  "80",
+	}
+	errs = p.validate()
+	if len(errs) > 0 {
+		t.Error()
+	}
+
+	p.useTLS = true
+	errs = p.validate()
+	if len(errs) == 0 {
+		t.Error()
+	} else if !errors.Is(errs[0], CertificateNotFound) {
+		t.Error()
+	}
+
+	p.cert = &tls.Certificate{}
+	errs = p.validate()
+	if len(errs) > 0 {
+		t.Error()
+	}
+}