第二章 内容补充

内容补充：

IO 和 端口解析结合

main.go
package main

import "black-hat/IoAndParse/IO"

func main() {
	IO.Input()
}

io.go
package IO

import (
	"black-hat/IoAndParse/parse"
	"fmt"
	"log"
	"os"
	"strings"
)

// FooReader defines an io.Reader to read from stdin.
type FooReader struct{}

// Read reads data from stdin.
func (fooReader *FooReader) Read(b []byte) (int, error) {
	fmt.Print("in > ")
	return os.Stdin.Read(b)
}

func Input() {
	// Instantiate reader and writer.
	var (
		reader FooReader
	)

	// Create buffer to hold input/output.
	input := make([]byte, 4096)

	// Use reader to read input.
	s, err := reader.Read(input)
	if err != nil {
		log.Fatalln("Unable to read data")
	}
	fmt.Printf("Read %d bytes from stdin\n", s)
	// Use writer to write output.
	//这里要求传递的参数是字符串
	//这个地方卡了好久
	//问题可能出现在字符串的格式上。
	//因为你直接将读取的字节数据转换为字符串，
	//但是用户输入的数据格式可能不是严格的文本字符串
	//而是包含了换行符或其他非可见字符。
	//为了解决这个问题，你可以对读取的字节数据进行处理，去除可能的换行符等非可见字符，然后再将其转换为字符串。
	//可以使用 strings.TrimSpace 函数来去除字符串两端的空白字符，确保得到的字符串是干净的。
	//因为是以字节的形式读取的所以可能换行符什么也读进去了
	str := strings.TrimSpace(string(input[:s]))
	fmt.Println(str)
	parsePort, err := parse.Parse(str)
	if err != nil {
		log.Fatalln("Unable to parse input")
	}
	for index, port := range parsePort {
		ports := fmt.Sprintf("%d port:%d", index, port)
		fmt.Println(ports)
	}
}

parse.go
package parse

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

const (
	porterrmsg = "Invalid port specification"
)

func Foo(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Println(v, "is int")
	case string:
		fmt.Println(v, "is string")
	default:
		fmt.Println("UnKnow")
	}
}

func dashSplit(sp string, ports *[]int) error {
	//以-为分隔符进行分割，得到的结构以字符串的形式存入字符串切片中
	dp := strings.Split(sp, "-")
	if len(dp) != 2 {
		return errors.New(porterrmsg)
	}
	//将开始的端口号的形式从字符串转换为整型数
	start, err := strconv.Atoi(dp[0])
	if err != nil {
		return errors.New(porterrmsg)
	}
	fmt.Println(dp[1])
	Foo(dp[1]) //是stirng类型啊
	//加一个字符串读出来的过程
	end, err := strconv.Atoi(dp[1]) //一直出问题不知道为啥，读出来变成0
	//直接用另一种方式转
	fmt.Println(end)
	if err != nil {
		return errors.New(porterrmsg)
	}
	//确保端口范围在有效范围里面
	if start > end || start < 1 || end > 65535 {
		return errors.New(porterrmsg)
	}
	for ; start <= end; start++ {
		*ports = append(*ports, start)
	}
	return nil
}

func convertAndAddPort(p string, ports *[]int) error {
	i, err := strconv.Atoi(p)
	if err != nil {
		return errors.New(porterrmsg)
	}
	if i < 1 || i > 65535 {
		return errors.New(porterrmsg)
	}
	*ports = append(*ports, i)
	return nil
}

// Parse turns a string of ports separated by '-' or ',' and returns a slice of Ints.
func Parse(s string) ([]int, error) {
	//创建一个空的整数切片，用于存储解析后的端口。
	ports := []int{}
	//如果字符串包含逗号和破折号，表示可能包含多个端口和端口范围。
	if strings.Contains(s, ",") && strings.Contains(s, "-") {
		sp := strings.Split(s, ",")
		for _, p := range sp {
			if strings.Contains(p, "-") {
				if err := dashSplit(p, &ports); err != nil {
					return ports, err
				}
			} else {
				if err := convertAndAddPort(p, &ports); err != nil {
					return ports, err
				}
			}
		}
	} else if strings.Contains(s, ",") {
		sp := strings.Split(s, ",")
		for _, p := range sp {
			convertAndAddPort(p, &ports)
		}
	} else if strings.Contains(s, "-") {
		if err := dashSplit(s, &ports); err != nil {
			return ports, err
		}
	} else {
		if err := convertAndAddPort(s, &ports); err != nil {
			return ports, err
		}
	}
	return ports, nil
}

摆烂了一段时间，把之前内容补充一下