// Package realip haalt het adres van de client achter een reverse proxy vandaan.
// X-Forwarded-For en X-Real-IP tellen alleen als de directe verbinding
// van een adres op de vertrouwenslijst komt. Een client die zelf een
// kop meestuurt, kan zijn adres daarmee niet vervalsen.
package realip

import (
	"fmt"
	"net"
	"net/http"
	"strings"
)

// Set is een lijst IP-adressen en CIDR-blokken.
type Set struct {
	nets []*net.IPNet
}

// Parse leest IP-adressen en CIDR-blokken. Een lege lijst vertrouwt niemand.
func Parse(entries []string) (*Set, error) {
	s := &Set{}
	for _, e := range entries {
		e = strings.TrimSpace(e)
		if e == "" {
			continue
		}
		if strings.Contains(e, "/") {
			_, n, err := net.ParseCIDR(e)
			if err != nil {
				return nil, fmt.Errorf("trusted_proxies: %q is geen CIDR", e)
			}
			s.nets = append(s.nets, n)
			continue
		}
		ip := net.ParseIP(e)
		if ip == nil {
			return nil, fmt.Errorf("trusted_proxies: %q is geen IP-adres of CIDR", e)
		}
		bits := 32
		if ip.To4() == nil {
			bits = 128
		}
		s.nets = append(s.nets, &net.IPNet{IP: ip, Mask: net.CIDRMask(bits, bits)})
	}
	return s, nil
}

// Contains meldt of ip op de lijst staat.
func (s *Set) Contains(ip net.IP) bool {
	if s == nil || ip == nil {
		return false
	}
	for _, n := range s.nets {
		if n.Contains(ip) {
			return true
		}
	}
	return false
}

// ClientIP kiest het clientadres.
// remoteAddr is host:poort van de TCP-verbinding. xff is X-Forwarded-For,
// xReal is X-Real-IP. In de keten is het clientadres de rechtse hop die
// zelf geen vertrouwde proxy is. Zijn alle hops vertrouwd, dan blijft
// het adres van de directe verbinding staan.
func ClientIP(remoteAddr, xff, xReal string, trusted *Set) string {
	peer, _, err := net.SplitHostPort(remoteAddr)
	if err != nil {
		peer = remoteAddr
	}
	peerIP := net.ParseIP(peer)
	if trusted == nil || peerIP == nil || !trusted.Contains(peerIP) {
		return peer
	}
	if ip := rightmostUntrusted(xff, trusted); ip != nil {
		return ip.String()
	}
	if ip := parseToken(xReal); ip != nil && !trusted.Contains(ip) {
		return ip.String()
	}
	return peer
}

func rightmostUntrusted(xff string, trusted *Set) net.IP {
	if strings.TrimSpace(xff) == "" {
		return nil
	}
	parts := strings.Split(xff, ",")
	for i := len(parts) - 1; i >= 0; i-- {
		ip := parseToken(parts[i])
		if ip == nil {
			continue
		}
		if !trusted.Contains(ip) {
			return ip
		}
	}
	return nil
}

func parseToken(s string) net.IP {
	s = strings.TrimSpace(s)
	s = strings.Trim(s, `"`)
	if s == "" {
		return nil
	}
	if h, _, err := net.SplitHostPort(s); err == nil {
		s = h
	}
	s = strings.Trim(s, "[]")
	return net.ParseIP(s)
}

// FromRequest leest de koppen van r.
func FromRequest(r *http.Request, trusted *Set) string {
	xff := strings.Join(r.Header.Values("X-Forwarded-For"), ", ")
	return ClientIP(r.RemoteAddr, xff, r.Header.Get("X-Real-IP"), trusted)
}

// Apply zet r.RemoteAddr op het clientadres. De poort blijft alleen staan
// als het adres niet uit een proxykop komt; die poort is anders van de proxy.
func Apply(r *http.Request, trusted *Set) {
	ip := FromRequest(r, trusted)
	host, port, err := net.SplitHostPort(r.RemoteAddr)
	if err != nil || port == "" {
		r.RemoteAddr = net.JoinHostPort(ip, "0")
		return
	}
	if parsed, got := net.ParseIP(host), net.ParseIP(ip); parsed == nil || got == nil || !parsed.Equal(got) {
		port = "0"
	}
	r.RemoteAddr = net.JoinHostPort(ip, port)
}
