request.go

package pinger

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"regexp"
	"slices"
	"strconv"
	"strings"
	"sync"

	pkgdnsprobe "github.com/internetworklab/cloudping/pkg/dnsprobe"
	pkghttpprobe "github.com/internetworklab/cloudping/pkg/httpprobe"
	pkgutils "github.com/internetworklab/cloudping/pkg/utils"
)

type L4PacketTypeOption string

const (
	L4ProtoICMP L4PacketTypeOption = "icmp"
	L4ProtoUDP  L4PacketTypeOption = "udp"
	L4ProtoTCP  L4PacketTypeOption = "tcp"
)

type L7PacketTypeOption string

const (
	L7ProtoDNS  L7PacketTypeOption = "dns"
	L7ProtoHTTP L7PacketTypeOption = "http"
)

type SimplePingRequest struct {
	From                       []string
	Targets                    []string
	IntvMilliseconds           int
	PktTimeoutMilliseconds     int
	PreferV4                   *bool
	PreferV6                   *bool
	TotalPkts                  *int
	Resolver                   *string
	TTL                        TTLGenerator
	RandomPayloadSize          *int
	ResolveTimeoutMilliseconds *int
	IPInfoProviderName         *string

	L4PacketType *L4PacketTypeOption
	L7PacketType *L7PacketTypeOption
	DNSTargets   []pkgdnsprobe.LookupParameter
	HTTPTargets  []pkghttpprobe.HTTPProbe

	// Take effect only when L3PacketType is 'udp'
	UDPDstPort *int
}

func (pingReq *SimplePingRequest) DeriveAsPingRequest(from string, target string) *SimplePingRequest {
	derivedPingRequest := new(SimplePingRequest)
	*derivedPingRequest = *pingReq
	derivedPingRequest.Targets = []string{target}
	derivedPingRequest.From = []string{from}
	return derivedPingRequest
}

func (pingReq *SimplePingRequest) DeriveAsDNSProbeRequest(from string, dnsTarget pkgdnsprobe.LookupParameter) *SimplePingRequest {
	derivedPingRequest := new(SimplePingRequest)
	*derivedPingRequest = *pingReq
	derivedPingRequest.DNSTargets = []pkgdnsprobe.LookupParameter{dnsTarget}
	derivedPingRequest.From = []string{from}
	return derivedPingRequest
}

func (pingReq *SimplePingRequest) DeriveAdHTTPProbeRequest(from string, maximumBodyRead *int) *SimplePingRequest {
	derivedPingRequest := new(SimplePingRequest)
	*derivedPingRequest = *pingReq
	derivedPingRequest.From = []string{from}
	derivedPingRequest.HTTPTargets = make([]pkghttpprobe.HTTPProbe, len(pingReq.HTTPTargets))
	copy(derivedPingRequest.HTTPTargets, pingReq.HTTPTargets)
	if maximumBodyRead != nil {
		for idx := range derivedPingRequest.HTTPTargets {
			if currentLim := derivedPingRequest.HTTPTargets[idx].SizeLimit; currentLim == nil {
				lim := new(int64)
				*lim = int64(*maximumBodyRead)
				derivedPingRequest.HTTPTargets[idx].SizeLimit = lim
			}
		}
	}
	return derivedPingRequest
}

const ParamTargets = "targets"
const ParamFrom = "from"
const ParamCount = "count"
const ParamIntvMs = "intervalMs"
const ParamPktTimeoutMs = "pktTimeoutMs"
const ParamTTL = "ttl"
const ParamPreferV4 = "preferV4"
const ParamPreferV6 = "preferV6"
const ParamResolver = "resolver"
const ParamRandomPayloadSize = "randomPayloadSize"

// Deprecated, for backward compatibility only.
const ParamDestination = "destination"

const ParamResolveTimeoutMilliseconds = "resolveTimeoutMilliseconds"
const ParamsIPInfoProviderName = "ipInfoProviderName"
const ParamL4PacketType = "l4PacketType"
const ParamL7PacketType = "l7PacketType"
const ParamDNSTarget = "dnsTarget"
const ParamHTTPTarget = "httpTarget"

// it was a typo to name it 'l3PacketType', it should be 'l4PacketType' instead, use it only for backward compatibility
const ParamL3PacketType = "l3PacketType"
const ParamUDPDstPort = "udpDstPort"

const defaultTTL = 64

func ParseSimplePingRequest(r *http.Request) (*SimplePingRequest, error) {
	result := new(SimplePingRequest)

	if httpTgts := r.URL.Query()[ParamHTTPTarget]; httpTgts != nil {
		result.HTTPTargets = make([]pkghttpprobe.HTTPProbe, 0)
		for _, tgt := range httpTgts {
			var tgtObject pkghttpprobe.HTTPProbe
			err := json.Unmarshal([]byte(tgt), &tgtObject)
			if err != nil {
				return nil, fmt.Errorf("failed to parse http target: %v", err)
			}

			if tgtObject.Proto != nil {
				if !slices.Contains(pkghttpprobe.GetAcceptableHTTPProtos(), *tgtObject.Proto) {
					allowedProtos := make([]string, 0)
					for _, proto := range pkghttpprobe.GetAcceptableHTTPProtos() {
						allowedProtos = append(allowedProtos, string(proto))
					}
					return nil, fmt.Errorf("unacceptable http proto: %s, allowed values are: %s", *tgtObject.Proto, strings.Join(allowedProtos, ", "))
				}
			}

			result.HTTPTargets = append(result.HTTPTargets, tgtObject)
		}
	}

	if dnsTargets := r.URL.Query()[ParamDNSTarget]; dnsTargets != nil {
		result.DNSTargets = make([]pkgdnsprobe.LookupParameter, 0)
		for _, tgt := range dnsTargets {
			var dnsProbeTarget pkgdnsprobe.LookupParameter
			err := json.Unmarshal([]byte(tgt), &dnsProbeTarget)
			if err != nil {
				return nil, fmt.Errorf("failed to parse dns target: %v", err)
			}
			result.DNSTargets = append(result.DNSTargets, dnsProbeTarget)
		}
	}

	if l7TyStr := r.URL.Query().Get(ParamL7PacketType); l7TyStr != "" {
		l7ty := L7PacketTypeOption(l7TyStr)
		result.L7PacketType = &l7ty
	}

	if l4TyStr := r.URL.Query().Get(ParamL3PacketType); l4TyStr != "" {
		l4Ty := L4PacketTypeOption(l4TyStr)
		result.L4PacketType = &l4Ty
	}
	if l4TyStr := r.URL.Query().Get(ParamL4PacketType); l4TyStr != "" {
		l4Ty := L4PacketTypeOption(l4TyStr)
		result.L4PacketType = &l4Ty
	}

	if udpDstPort := r.URL.Query().Get(ParamUDPDstPort); udpDstPort != "" {
		udpDstPortInt, err := strconv.Atoi(udpDstPort)
		if err != nil {
			return nil, fmt.Errorf("failed to parse udp dst port: %v", err)
		}
		result.UDPDstPort = &udpDstPortInt
	}

	if ipInfoProviderName := r.URL.Query().Get(ParamsIPInfoProviderName); ipInfoProviderName != "" {
		result.IPInfoProviderName = &ipInfoProviderName
	}

	if randomPayloadSize := r.URL.Query().Get(ParamRandomPayloadSize); randomPayloadSize != "" {
		randomPayloadSizeInt, err := strconv.Atoi(randomPayloadSize)
		if err != nil {
			return nil, fmt.Errorf("failed to parse random payload size: %v", err)
		}
		result.RandomPayloadSize = &randomPayloadSizeInt
	}

	if targetsStr := r.URL.Query().Get(ParamTargets); targetsStr != "" {
		for target := range strings.SplitSeq(targetsStr, ",") {
			target = strings.TrimSpace(target)
			if target == "" {
				continue
			}
			result.Targets = append(result.Targets, target)
		}
	}

	if fromStr := r.URL.Query().Get(ParamFrom); fromStr != "" {
		for from := range strings.SplitSeq(fromStr, ",") {
			from = strings.TrimSpace(from)
			if from == "" {
				continue
			}
			result.From = append(result.From, from)
		}
	}

	if count := r.URL.Query().Get(ParamCount); count != "" {
		countInt, err := strconv.Atoi(count)
		if err != nil {
			return nil, fmt.Errorf("failed to parse count: %v", err)
		}
		result.TotalPkts = &countInt
	}

	if intervalMilliSecs := r.URL.Query().Get(ParamIntvMs); intervalMilliSecs != "" {
		intervalInt, err := strconv.Atoi(intervalMilliSecs)
		if err != nil {
			return nil, fmt.Errorf("failed to parse interval: %v", err)
		}
		result.IntvMilliseconds = intervalInt
	} else {
		result.IntvMilliseconds = 1000
	}

	if pktTimeoutMilliSecs := r.URL.Query().Get(ParamPktTimeoutMs); pktTimeoutMilliSecs != "" {
		pktTimeoutInt, err := strconv.Atoi(pktTimeoutMilliSecs)
		if err != nil {
			return nil, fmt.Errorf("failed to parse pktTimeout: %v", err)
		}
		result.PktTimeoutMilliseconds = pktTimeoutInt
	} else {
		result.PktTimeoutMilliseconds = 3000
	}

	if ttl := r.URL.Query().Get(ParamTTL); ttl != "" {
		if strings.HasPrefix(ttl, "auto(") || ttl == "auto" {
			autoTTL, err := ParseToAutoTTL(ttl)
			if err != nil {
				return nil, fmt.Errorf("failed to parse ttl: %v", err)
			}
			result.TTL = autoTTL
		} else if strings.HasPrefix(ttl, "range(") {
			rangeTTL, err := ParseToRangeTTL(ttl)
			if err != nil {
				return nil, fmt.Errorf("failed to parse ttl: %v", err)
			}
			result.TTL = rangeTTL
		} else {
			ints, err := pkgutils.ParseInts(ttl)
			if err != nil {
				return nil, fmt.Errorf("failed to parse ttl: %v", err)
			}
			result.TTL = &RangeTTL{TTLs: ints}
		}
	} else {
		result.TTL = &RangeTTL{TTLs: []int{defaultTTL}}
	}

	if preferV4 := r.URL.Query().Get(ParamPreferV4); preferV4 != "" {
		preferV4Bool, err := strconv.ParseBool(preferV4)
		if err != nil {
			return nil, fmt.Errorf("failed to parse preferV4: %v", err)
		}
		result.PreferV4 = &preferV4Bool
	}

	if preferV6 := r.URL.Query().Get(ParamPreferV6); preferV6 != "" {
		preferV6Bool, err := strconv.ParseBool(preferV6)
		if err != nil {
			return nil, fmt.Errorf("failed to parse preferV6: %v", err)
		}
		result.PreferV6 = &preferV6Bool
	}

	if resolver := r.URL.Query().Get(ParamResolver); resolver != "" {
		result.Resolver = &resolver
	}

	return result, nil
}

func (pr *SimplePingRequest) ToURLValues() url.Values {
	vals := url.Values{}

	if len(pr.Targets) > 0 {
		vals.Add(ParamTargets, strings.Join(pr.Targets, ","))
		if firstTgt := pr.Targets[0]; firstTgt != "" {
			firstTgt := strings.TrimSpace(firstTgt)
			if firstTgt != "" {
				// Note: the `destination=` query parameter is DEPRECATED!
				// we do so is solely for backward compatibility.
				// that is, some agents still recognize `destination=` only
				vals.Set(ParamDestination, firstTgt)
			}
		}
	}

	if pr.From != nil {
		vals.Add(ParamFrom, strings.Join(pr.From, ","))
	}

	vals.Add(ParamIntvMs, strconv.Itoa(pr.IntvMilliseconds))
	vals.Add(ParamPktTimeoutMs, strconv.Itoa(pr.PktTimeoutMilliseconds))
	if pr.PreferV4 != nil {
		vals.Add(ParamPreferV4, strconv.FormatBool(*pr.PreferV4))
	}
	if pr.PreferV6 != nil {
		vals.Add(ParamPreferV6, strconv.FormatBool(*pr.PreferV6))
	}
	if pr.TotalPkts != nil {
		vals.Add(ParamCount, strconv.Itoa(*pr.TotalPkts))
	}
	if pr.Resolver != nil {
		vals.Add(ParamResolver, *pr.Resolver)
	}
	if pr.TTL != nil {
		vals.Add(ParamTTL, pr.TTL.String())
	}
	if pr.ResolveTimeoutMilliseconds != nil {
		vals.Add(ParamResolveTimeoutMilliseconds, strconv.Itoa(*pr.ResolveTimeoutMilliseconds))
	}
	if pr.RandomPayloadSize != nil {
		vals.Add(ParamRandomPayloadSize, strconv.Itoa(*pr.RandomPayloadSize))
	}
	if pr.IPInfoProviderName != nil && *pr.IPInfoProviderName != "" {
		vals.Add(ParamsIPInfoProviderName, *pr.IPInfoProviderName)
	}
	if pr.L4PacketType != nil && *pr.L4PacketType != "" {
		vals.Add(ParamL3PacketType, string(*pr.L4PacketType))
		vals.Add(ParamL4PacketType, string(*pr.L4PacketType))
	}
	if pr.UDPDstPort != nil {
		vals.Add(ParamUDPDstPort, strconv.Itoa(*pr.UDPDstPort))
	}
	if pr.L7PacketType != nil && *pr.L7PacketType != "" {
		vals.Add(ParamL7PacketType, string(*pr.L7PacketType))
	}
	if pr.DNSTargets != nil {
		for _, tgt := range pr.DNSTargets {
			j, err := json.Marshal(tgt)
			if err != nil {
				log.Printf("failed to marshal dns target: %v", err)
				continue
			}
			vals.Add(ParamDNSTarget, string(j))
		}
	}
	if pr.HTTPTargets != nil {
		for _, tgt := range pr.HTTPTargets {
			j, err := json.Marshal(tgt)
			if err != nil {
				log.Printf("failed to marshal http target: %v", err)
				continue
			}
			vals.Add(ParamHTTPTarget, string(j))
		}
	}

	return vals
}

type TTLGenerator interface {
	Get() int
	Forward()
	Reset()
	String() string
}

type AutoTTL struct {
	Start int
	Next  int
	lock  sync.Mutex `json:"-"`
}

const maxAllowedAutoTTL = 64

func ParseToAutoTTL(s string) (*AutoTTL, error) {
	if s == "auto" {
		return &AutoTTL{Start: 1, Next: 1}, nil
	}

	pattern1 := regexp.MustCompile(`^auto\((\d+)\)$`)
	if result := pattern1.FindStringSubmatch(s); result != nil {
		start, err := strconv.Atoi(result[1])
		if err != nil {
			return nil, fmt.Errorf("failed to parse auto ttl: %v", err)
		}
		return &AutoTTL{Start: start, Next: start}, nil
	}

	return nil, fmt.Errorf("failed to parse auto ttl: %s", s)
}

func (at *AutoTTL) Get() int {
	at.lock.Lock()
	defer at.lock.Unlock()

	return at.Next
}

func (at *AutoTTL) Forward() {
	at.lock.Lock()
	defer at.lock.Unlock()

	at.Next++
	if at.Next > maxAllowedAutoTTL {
		at.Next = at.Start
	}
}

func (at *AutoTTL) Reset() {
	at.lock.Lock()
	defer at.lock.Unlock()

	at.Next = at.Start
}

func (at *AutoTTL) String() string {
	return fmt.Sprintf("auto(%d)", at.Start)
}

type RangeTTL struct {
	TTLs []int
	idx  int        `json:"-"`
	lock sync.Mutex `json:"-"`
}

func ParseToRangeTTL(s string) (*RangeTTL, error) {
	ints, err := pkgutils.ParseInts(s)
	if err != nil {
		return nil, fmt.Errorf("failed to parse range ttl: %v", err)
	}
	return &RangeTTL{TTLs: ints}, nil
}

func (rt *RangeTTL) Get() int {
	rt.lock.Lock()
	defer rt.lock.Unlock()
	return rt.TTLs[rt.idx]
}

func (rt *RangeTTL) Forward() {
	rt.lock.Lock()
	defer rt.lock.Unlock()

	rt.idx++
	if rt.idx >= len(rt.TTLs) {
		rt.idx = 0
	}
}

func (rt *RangeTTL) Reset() {
	rt.lock.Lock()
	defer rt.lock.Unlock()

	rt.idx = 0
}

func (rt *RangeTTL) String() string {
	segs := make([]string, 0)
	for _, ttl := range rt.TTLs {
		segs = append(segs, strconv.Itoa(ttl))
	}
	return strings.Join(segs, ",")
}