// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file implements the Zircon loglistener protocol.
package netboot

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
	"syscall"

	"golang.org/x/sys/unix"
)

// Magic constants used by the netboot protocol.
const (
	debugMagic = 0xAEAE1123 // see system/public/zircon/boot/netboot.h
)

// Port numbers used by the netboot protocol.
const (
	debugPort = 33337 // debugging log port
)

// logpacket is the network logging protocol packet.
type logpacket struct {
	Magic    uint32
	Seqno    uint32
	Nodename [64]byte
	Data     [1216]byte
}

// LogListener is Zircon's debug log listener.
type LogListener struct {
	seq      uint32
	conn     *net.UDPConn
	nodename string
}

// NewLogListener creates and connects a new instance of debug log listener.
func NewLogListener(nodename string) (*LogListener, error) {
	conn, err := net.ListenUDP("udp6", &net.UDPAddr{
		IP:   net.IPv6zero,
		Port: debugPort,
	})
	if err != nil {
		return nil, fmt.Errorf("failed to bind to udp6 port: %v\n", err)
	}

	rawConn, err := conn.SyscallConn()
	if err != nil {
		return nil, err
	}

	// SO_REUSEADDR and SO_REUSEPORT allows binding to the same port multiple
	// times which is necessary in the case when there are multiple instances.
	var fderr error
	if err = rawConn.Control(func(fd uintptr) {
		if fderr = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_REUSEADDR, 1); fderr != nil {
			return
		}

		if fderr = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_REUSEPORT, 1); fderr != nil {
			return
		}
	}); err != nil {
		return nil, err
	}
	if fderr != nil {
		return nil, fderr
	}

	return &LogListener{
		conn:     conn,
		nodename: nodename,
	}, nil
}

// Listen receive a single debug log packet.
func (l *LogListener) Listen() (string, error) {
	b := make([]byte, 4096)

	// Wait for logpacket.
	_, addr, err := l.conn.ReadFrom(b)
	if err != nil {
		return "", err
	}

	var pkt logpacket
	if err := binary.Read(bytes.NewReader(b), binary.LittleEndian, &pkt); err != nil {
		return "", err
	}
	if pkt.Magic != debugMagic {
		// Not a valid debug packet.
		return "", errors.New("invalid magic")
	}
	name, err := netbootString(pkt.Nodename[:])
	if err != nil {
		return "", err
	}
	if name != l.nodename {
		// Not a packet from our node.
		return "", errors.New("invalid nodename")
	}

	var data string
	if pkt.Seqno != l.seq {
		data, err = netbootString(pkt.Data[:])
		if err != nil {
			return data, err
		}
		l.seq = pkt.Seqno
	}

	// Acknowledge the packet.
	if _, err = l.conn.WriteTo(b[:8], addr); err != nil {
		return "", err
	}

	return data, nil
}

// Close shuts down the log listener underlying connection.
func (l *LogListener) Close() error {
	return l.conn.Close()
}