app.go

package extcap

import (
	"errors"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

const (
	defaultHelpPage = "https://github.com/kor44/extcap"
)

// App is the main structure of a extcap application.
type App struct {
	// Application brief description
	Description string

	// HelpPage is link to help page with description. Can be link to file or URL
	// Examples:
	// 	file:///C:/Program%20Files/Wireshark/sshdump.html
	//	http://desowin.org/usbpcap/
	HelpPage string

	// Version of tool
	Version string

	// AdditionalVersion is used to show verbose version of tool when provided flag -v (--version).
	// In case of empty, Version value will be used.
	AdditionalVersion string

	// CaptureExamples allows add more examples in usage section of help
	// By default usage examples include following common examples:
	//    <application-name> --extcap-interfaces
	//    <application-name> --extcap-dlts --extcap-interface <iface-name>
	//    <application-name> --extcap-config --extcap-interface <iface-name>
	//    <application-name> --capture --extcap-interface <iface-name> --fifo <fifo_name>
	CaptureExamples []string

	// ListInterfaces returns list of intefaces. If not implements it will use name of executable (without extension) and HelpPage
	// Result will be used by Wireshark to display in list of available interfaces to capture
	ListInterfaces func() ([]Interface, error)

	// ListLinkType returns LinkType (DLT) for given interface. Optional.
	// If not defined, then return LinkType=147
	// dlt {number=147}{name=<iface_name>}{display=Capture dependent DLT}
	ListLinkType func(iface string) (LinkType, error)

	// ListArgs returns configuration parameters for given interface. Optional.
	ListArgs func(iface string) ([]Arg, error)

	// StartCapture starts capture process. Required.
	// Before capture extcap open pipe with function OpenPipe and return writer.
	StartCapture func(iface string, w io.WriteCloser, filter string, args *CaptureArgs) error

	// OpenPipe opens fifo pipe to write capture results. If it not defined then default is used.
	OpenPipe func(string) (io.WriteCloser, error)

	// Base options. See extcap-base.h
	/*listIfacesFlag   *bool
	versionFlag      *string
	listDLTsFlag     *bool
	listIfaceCfgFlag *bool
	startCaptureFlag *bool

	ifaceFlag  *string
	filterFlag *string
	fifoFlag   *string
	*/

	/* need implement
	log-level
	log-file
	*/

	// add writer for dubug
	writer io.Writer
}

// Run creates application with minimal necessary functionality
// in case there are no interfaces and interface configuration options.
func Run(desc string, captureFunc func(fifo io.WriteCloser, filter string) error) error {
	app := &App{
		Description: desc,
		StartCapture: func(iface string, fifo io.WriteCloser, filter string, argSet *CaptureArgs) error {
			return captureFunc(fifo, filter)
		},
	}

	return app.Run(os.Args)
}

func (app *App) init() {
	if app.ListInterfaces == nil {
		app.ListInterfaces = func() ([]Interface, error) {
			name := os.Args[0]

			iface := Interface{
				Value:   strings.TrimSuffix(filepath.Base(name), filepath.Ext(name)),
				Display: app.Description,
			}

			return []Interface{iface}, nil
		}
	}

	if app.ListLinkType == nil {
		app.ListLinkType = func(iface string) (LinkType, error) {
			//dlt {number=147}{name=<iface_name>}{display=Capture dependent DLT}
			return LinkType{147, iface, "Capture dependent DLT"}, nil
		}
	}

	if app.OpenPipe == nil {
		app.OpenPipe = openPipe
	}

	if app.Version == "" {
		app.Version = "0.0.0"
	}

	if app.AdditionalVersion == "" {
		app.AdditionalVersion = app.Version
	}

	if app.writer == nil {
		app.writer = os.Stdout
	}
}

// Runs main loop application
func (app *App) Run(args []string) error {
	app.init()

	if len(args) == 1 {
		// print help
		fmt.Fprintf(app.writer, app.help())
		return nil
	}

	// TODO: need parse commands order insensitive
	command := args[1]
	switch command {
	case "-v", "--version":
		fmt.Fprintln(app.writer, app.AdditionalVersion)
		return nil

	case "-h", "--help":
		fmt.Fprintf(app.writer, app.help())
		return nil

	// list the extcap Interfaces
	case "--extcap-interfaces":
		return app.cmdListInterfaces()

	// list the additional configuration for an interface
	case "--extcap-config":
		if len(args[2:]) < 2 {
			return NewError("show interface config", ErrNoInterfaceSpecified)
		}
		return app.cmdListIfaceArgs(args[2:])

	// list the DLTs
	case "--extcap-dlts":
		if len(args[2:]) < 2 {
			return NewError("show interface DLTs", ErrNoInterfaceSpecified)
		}
		return app.cmdListLinkTypes(args[2:])

	// run the capture
	case "--capture":
		cfg, remainArgs, err := parseCommonStartCaptureFlags(args[2:])
		if err != nil {
			return NewError("extcap capture", err)
		}

		return app.cmdStartCapture(cfg, remainArgs)

	// print tool version for extcap
	case "--extcap-version":
		return app.cmdPrintToolVersion()

	}

	return fmt.Errorf(`Invalid option: '%s'`, command)
}

func parseInterfaceName(args []string) (string, error) {
	if len(args) < 2 {
		return "", fmt.Errorf(`Not enough input parameters: "%s".\nExpected: "--extcap-interface <iface-name>"`,
			strings.Join(args, " "))
	}

	if args[0] != "--extcap-interface" {
		return "", ErrNoInterfaceSpecified
	}

	return args[1], nil
}

func (app *App) cmdListInterfaces() error {
	ifaces, err := app.ListInterfaces()
	if err != nil {
		return err
	}

	fmt.Fprintln(app.writer, versionString(app.Version, app.HelpPage))
	for i := range ifaces {
		_, err := fmt.Fprintln(app.writer, ifaces[i].marshal())
		if err != nil {
			return fmt.Errorf("print interfaces: %w", err)
		}
	}

	return nil
}

func (app *App) cmdListLinkTypes(args []string) error {
	iface, err := parseInterfaceName(args)
	if err != nil {
		return err
	}

	dlt, err := app.ListLinkType(iface)

	if err != nil {
		return err
	}

	if _, err = fmt.Fprintln(app.writer, dlt.marshal()); err != nil {
		return NewError("print link types", err)
	}
	return nil
}

func (app *App) cmdListIfaceArgs(args []string) error {
	if app.ListArgs == nil {
		return nil
	}

	iface, err := parseInterfaceName(args)
	if err != nil {
		return err
	}

	confOpts, err := app.ListArgs(iface)
	if err != nil {
		return err
	}

	for i := range confOpts {
		confOpts[i].setID(i)
		_, err = fmt.Fprintln(app.writer, argString(confOpts[i]))
		if err != nil {
			return NewError("print interface arguments", err)
		}
	}

	return nil
}

// return help page string
func (app *App) help() string {
	w := new(strings.Builder)

	fmt.Fprintf(w, "%s - %s\n\n", os.Args[0], app.AdditionalVersion)
	fmt.Fprintf(w, "Usage:\n%s\n", strings.Join(app.CaptureExamples, "\n"))
	//fmt.Fprintf(w, "Options:%s", app.)

	return w.String()
}

type captureConfig struct {
	iface  string
	fifo   string
	filter string
}

func parseCommonStartCaptureFlags(args []string) (captureConfig, []string, error) {
	temp := make([]string, len(args))
	copy(temp, args)

	var cfg captureConfig

	for i, v := range temp {
		if v == "--extcap-interface" && i+1 < len(temp) {
			cfg.iface = temp[i+1]

			temp = append(temp[:i], temp[i+2:]...)

			goto GET_FIFO
		}
	}

	return captureConfig{}, args, ErrNoInterfaceSpecified

GET_FIFO:
	for i, v := range temp {
		if v == "--fifo" && i+1 < len(temp) {
			cfg.fifo = temp[i+1]

			temp = append(temp[:i], temp[i+2:]...)

			goto GET_FILTER
		}
	}
	return captureConfig{}, args, ErrNoPipeProvided

GET_FILTER:
	for i, v := range temp {
		if v == "--extcap-capture-filter" && i+1 < len(temp) {
			cfg.filter = temp[i+1]

			temp = append(temp[:i], temp[i+2:]...)
			break
		}
	}

	return cfg, temp, nil

}

type CaptureArgs struct {
	fs    *flag.FlagSet
	flags []string
}

func (set *CaptureArgs) ParseArgs(args []Arg) error {
	for _, a := range args {
		a.addFlag(set)
	}

	return set.fs.Parse(set.flags)
}

// Exist check wheather flag for argument is provided or not
func (set *CaptureArgs) Exist(name string) bool {
	f := "--" + name
	for i := range set.flags {
		if set.flags[i] == f {
			return true
		}
	}

	return false
}

func newCaptureArgs(flags []string) *CaptureArgs {
	return &CaptureArgs{
		fs:    flag.NewFlagSet("capture", flag.ExitOnError),
		flags: flags,
	}
}

func (app *App) cmdStartCapture(cfg captureConfig, remainArgs []string) error {
	pipe, err := app.OpenPipe(cfg.fifo)
	if err != nil {
		return err
	}

	argSet := newCaptureArgs(remainArgs)

	err = app.StartCapture(cfg.iface, pipe, cfg.filter, argSet)

	return err
}

func (app *App) cmdPrintToolVersion() error {
	_, err := fmt.Fprintln(app.writer, versionString(app.Version, app.HelpPage))

	return err
}

func openPipe(name string) (io.WriteCloser, error) {
	pipe, err := os.OpenFile(name, os.O_WRONLY, os.ModeNamedPipe)
	if err != nil {
		return nil, NewError(fmt.Sprintf("open pipe:%s", name), errors.Unwrap(err))
	}

	return pipe, nil
}