probes

var ErrNotSupported = errors.New("not supported")

var HaveAttachCgroup = sync.OnceValue(func() error {

	spec := &ebpf.ProgramSpec{
		Type:       ebpf.CGroupSKB,
		AttachType: ebpf.AttachCGroupInetIngress,
		Instructions: asm.Instructions{
			asm.LoadImm(asm.R0, 0, asm.DWord),
			asm.Return(),
		},
	}

	p, err := ebpf.NewProgramWithOptions(spec, ebpf.ProgramOptions{
		LogDisabled: true,
	})
	if err != nil {
		return fmt.Errorf("create cgroup program: %w: %w", err, ebpf.ErrNotSupported)
	}
	defer p.Close()

	_, err = link.AttachCgroup(link.CgroupOptions{Path: "/dev/null", Program: p, Attach: spec.AttachType})
	if errors.Is(err, unix.EBADF) {

		return nil
	}
	if err != nil {

		return fmt.Errorf("link cgroup program to /dev/null: %w: %w", err, ebpf.ErrNotSupported)
	}

	return errors.New("attaching prog to /dev/null did not result in error")
})

var HaveBPF = sync.OnceValue(func() error {
	prog, err := newProgram(ebpf.SocketFilter)
	if err != nil {
		return err
	}
	defer prog.Close()

	return nil
})

var HaveBPFJIT = sync.OnceValue(func() error {
	prog, err := newProgram(ebpf.SocketFilter)
	if err != nil {
		return err
	}
	defer prog.Close()

	info, err := prog.Info()
	if err != nil {
		return fmt.Errorf("get prog info: %w", err)
	}
	if _, err := info.JitedSize(); err != nil {
		return fmt.Errorf("get JITed prog size: %w", err)
	}

	return nil
})

var HaveManagedNeighbors = sync.OnceValue(func() error {
	ns, err := netns.New()
	if err != nil {
		return fmt.Errorf("create netns: %w", err)
	}
	defer ns.Close()

	return ns.Do(func() error {

		veth := &netlink.Veth{
			LinkAttrs: netlink.LinkAttrs{Name: "veth0"},
			PeerName:  "veth1",
		}

		if err := netlink.LinkAdd(veth); err != nil {
			return fmt.Errorf("failed to add dummy veth: %w", err)
		}

		neigh := netlink.Neigh{
			LinkIndex: veth.Index,
			IP:        net.IPv4(0, 0, 0, 1),
			Flags:     NTF_EXT_LEARNED,
			FlagsExt:  NTF_EXT_MANAGED,
		}

		if err := netlink.NeighAdd(&neigh); err != nil {
			return fmt.Errorf("failed to add neighbor: %w", err)
		}

		nl, err := safenetlink.NeighList(veth.Index, 0)
		if err != nil {
			return fmt.Errorf("failed to list neighbors: %w", err)
		}

		for _, n := range nl {
			if !n.IP.Equal(neigh.IP) {
				continue
			}
			if n.Flags != NTF_EXT_LEARNED {
				continue
			}
			if n.FlagsExt != NTF_EXT_MANAGED {
				continue
			}

			return nil
		}

		return ErrNotSupported
	})
})

var HaveNetkit = sync.OnceValue(func() error {
	prog, err := newProgram(ebpf.SchedCLS)
	if err != nil {
		return err
	}
	defer prog.Close()

	ns, err := netns.New()
	if err != nil {
		return fmt.Errorf("create netns: %w", err)
	}
	defer ns.Close()

	return ns.Do(func() error {
		l, err := link.AttachNetkit(link.NetkitOptions{
			Program:   prog,
			Attach:    ebpf.AttachNetkitPrimary,
			Interface: math.MaxInt,
		})

		if errors.Is(err, unix.ENODEV) {
			return nil
		}
		if err != nil {
			return fmt.Errorf("creating link: %w", err)
		}
		if err := l.Close(); err != nil {
			return fmt.Errorf("closing link: %w", err)
		}

		return fmt.Errorf("unexpected success: %w", err)
	})
})

var HaveTCBPF = sync.OnceValue(func() error {
	prog, err := newProgram(ebpf.SchedCLS)
	if err != nil {
		return err
	}
	defer prog.Close()

	ns, err := netns.New()
	if err != nil {
		return fmt.Errorf("create netns: %w", err)
	}
	defer ns.Close()

	qdisc := &netlink.Clsact{
		QdiscAttrs: netlink.QdiscAttrs{
			LinkIndex: 1,
			Handle:    netlink.MakeHandle(0xffff, 0),
			Parent:    netlink.HANDLE_CLSACT,
		},
	}

	filter := &netlink.BpfFilter{
		FilterAttrs: netlink.FilterAttrs{
			LinkIndex: 1,
			Parent:    netlink.HANDLE_MIN_INGRESS,
			Handle:    1,
			Protocol:  unix.ETH_P_ALL,
		},
		Fd:           prog.FD(),
		DirectAction: true,
	}

	return ns.Do(func() error {
		if err := netlink.QdiscReplace(qdisc); err != nil {
			return fmt.Errorf("creating clsact qdisc: %w: %w", err, ErrNotSupported)
		}

		if err := netlink.FilterReplace(filter); err != nil {
			return fmt.Errorf("attaching bpf tc filter: %w: %w", err, ErrNotSupported)
		}

		return nil
	})
})

var HaveTCX = sync.OnceValue(func() error {
	prog, err := newProgram(ebpf.SchedCLS)
	if err != nil {
		return err
	}
	defer prog.Close()

	ns, err := netns.New()
	if err != nil {
		return fmt.Errorf("create netns: %w", err)
	}
	defer ns.Close()

	return ns.Do(func() error {
		l, err := link.AttachTCX(link.TCXOptions{
			Program:   prog,
			Attach:    ebpf.AttachTCXIngress,
			Interface: 1,
			Anchor:    link.Tail(),
		})
		if err != nil {
			return fmt.Errorf("creating link: %w", err)
		}
		if err := l.Close(); err != nil {
			return fmt.Errorf("closing link: %w", err)
		}

		return nil
	})
})