mirror of
https://github.com/dcarrillo/whatismyip.git
synced 2026-07-23 15:55:45 +00:00
dcarrillo
49ffcadb0a
High (behavioral bugs):
- service.Geo: add RLock on lookups, handle Reload error, keep old DBs on failure
- models.GeoDB.Reload: open new DBs before closing old ones (no reader gap)
- router: guard nil geo records (404 instead of 500) in geo.go, generic.go, dns.go
- router/port_scanner: reject undetermined client IPs (nil->localhost dial)
- internal/httputils: fix access log date layout (02/Jan/2006, not literal Nov)
- server/quic: log.Printf instead of log.Fatal in request handler
Medium:
- server/*: 10s shutdown timeout; SIGTERM drains servers before closing geo DBs
- httputils: Clone() request headers instead of mutating the live map; strings.Builder
- setting/app: handle all os.Stat errors; fix "truster" typos; use errors.New;
remove dead Token field
- cmd: errors.Is for sentinel checks; os.Stderr; log.Fatal instead of panic;
pass http.Handler by value (not pointer-to-interface)
- resolver: validate config at startup (pre-parse RRs, validate IPs); check WriteMsg
errors; Setup returns error
Low:
- .golangci.yaml: enable errcheck, govet, errorlint; fix all resulting findings
- server/tls: explicit TLSConfig{MinVersion: tls.VersionTLS12}
- router/dns: label-exact vhost suffix check, strip port; template.Must
- models: errors.Join instead of %s on []error
- service/geo_test: race-regression test (concurrent lookups during Reload)
- README: Go >= 1.25; fix latent test bug (store.Add->Set in dns_test.go)
115 lines
3.0 KiB
Go
115 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"slices"
|
|
"time"
|
|
|
|
"github.com/dcarrillo/whatismyip/internal/httputils"
|
|
"github.com/dcarrillo/whatismyip/internal/metrics"
|
|
"github.com/dcarrillo/whatismyip/internal/setting"
|
|
"github.com/dcarrillo/whatismyip/resolver"
|
|
"github.com/dcarrillo/whatismyip/server"
|
|
"github.com/dcarrillo/whatismyip/service"
|
|
"github.com/gin-contrib/secure"
|
|
"github.com/patrickmn/go-cache"
|
|
|
|
"github.com/dcarrillo/whatismyip/router"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
func main() {
|
|
o, err := setting.Setup(os.Args[1:])
|
|
if err != nil {
|
|
if errors.Is(err, flag.ErrHelp) || errors.Is(err, setting.ErrVersion) {
|
|
fmt.Print(o)
|
|
os.Exit(0)
|
|
}
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
servers := []server.Server{}
|
|
engine := setupEngine()
|
|
|
|
if setting.App.Resolver.Domain != "" {
|
|
store := cache.New(1*time.Minute, 10*time.Minute)
|
|
var dnsEngine *resolver.Resolver
|
|
if dnsEngine, err = resolver.Setup(store); err != nil {
|
|
log.Fatalf("Invalid resolver configuration: %s", err)
|
|
}
|
|
nameServer := server.NewDNSServer(context.Background(), dnsEngine.Handler())
|
|
servers = append(servers, nameServer)
|
|
engine.Use(router.GetDNSDiscoveryHandler(store, setting.App.Resolver.Domain, setting.App.Resolver.RedirectPort))
|
|
}
|
|
|
|
var geoSvc *service.Geo
|
|
if setting.App.GeodbPath.City != "" || setting.App.GeodbPath.ASN != "" {
|
|
if geoSvc, err = service.NewGeo(context.Background(), setting.App.GeodbPath.City, setting.App.GeodbPath.ASN); err != nil {
|
|
log.Fatalf("Failed to load geo databases: %s", err)
|
|
}
|
|
}
|
|
|
|
router.SetupTemplate(engine)
|
|
router.Setup(engine, geoSvc)
|
|
servers = slices.Concat(servers, setupHTTPServers(context.Background(), engine.Handler()))
|
|
|
|
if setting.App.PrometheusAddress != "" {
|
|
prometheusServer := server.NewPrometheusServer(context.Background())
|
|
servers = append(servers, prometheusServer)
|
|
}
|
|
|
|
whatismyip := server.Setup(servers, geoSvc)
|
|
whatismyip.Run()
|
|
}
|
|
|
|
func setupEngine() *gin.Engine {
|
|
gin.DisableConsoleColor()
|
|
if os.Getenv(gin.EnvGinMode) == "" {
|
|
gin.SetMode(gin.ReleaseMode)
|
|
}
|
|
engine := gin.New()
|
|
engine.Use(gin.LoggerWithFormatter(httputils.GetLogFormatter), gin.Recovery())
|
|
if setting.App.PrometheusAddress != "" {
|
|
metrics.Enable()
|
|
engine.Use(metrics.GinMiddleware())
|
|
}
|
|
if setting.App.EnableSecureHeaders {
|
|
engine.Use(secure.New(secure.Config{
|
|
BrowserXssFilter: true,
|
|
ContentTypeNosniff: true,
|
|
FrameDeny: true,
|
|
}))
|
|
}
|
|
_ = engine.SetTrustedProxies(nil)
|
|
engine.TrustedPlatform = setting.App.TrustedHeader
|
|
|
|
return engine
|
|
}
|
|
|
|
func setupHTTPServers(ctx context.Context, handler http.Handler) []server.Server {
|
|
var servers []server.Server
|
|
|
|
if setting.App.BindAddress != "" {
|
|
tcpServer := server.NewTCPServer(ctx, handler)
|
|
servers = append(servers, tcpServer)
|
|
}
|
|
|
|
if setting.App.TLSAddress != "" {
|
|
tlsServer := server.NewTLSServer(ctx, handler)
|
|
servers = append(servers, tlsServer)
|
|
if setting.App.EnableHTTP3 {
|
|
quicServer := server.NewQuicServer(ctx, tlsServer)
|
|
servers = append(servers, quicServer)
|
|
}
|
|
}
|
|
|
|
return servers
|
|
}
|