STRLCPY/sing-box

Add command to fetch a URL
世界 committed 1 year ago

99b2ab55

1 parent e5f3bb63

Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)

■ ■ ■ ■ ■ ■ ■

cmd/sing-box/cmd_tools.go

		skipped 3 lines
4	4		"context"
5	5
6	6		box "github.com/sagernet/sing-box"
	7	+	"github.com/sagernet/sing-box/option"
7	8		E "github.com/sagernet/sing/common/exceptions"
	9	+	N "github.com/sagernet/sing/common/network"
8	10
9	11		"github.com/spf13/cobra"
10	12		)
11	13
12	14		var commandTools = &cobra.Command{
13	15		Use: "tools",
14		-	Short: "experimental tools",
	16	+	Short: "Experimental tools",
15	17		}
16	18
17	19		func init() {
		skipped 5 lines
23	25		if err != nil {
24	26		return nil, err
25	27		}
	28	+	if options.Log == nil {
	29	+	options.Log = &option.LogOptions{}
	30	+	}
	31	+	options.Log.Disabled = true
26	32		instance, err := box.New(context.Background(), options, nil)
27	33		if err != nil {
28	34		return nil, E.Cause(err, "create service")
		skipped 5 lines
34	40		return instance, nil
35	41		}
36	42
	43	+	func createDialer(instance *box.Box, network string, outboundTag string) (N.Dialer, error) {
	44	+	if outboundTag == "" {
	45	+	outbound := instance.Router().DefaultOutbound(network)
	46	+	if outbound == nil {
	47	+	return nil, E.New("missing default outbound")
	48	+	}
	49	+	return outbound, nil
	50	+	} else {
	51	+	outbound, loaded := instance.Router().Outbound(outboundTag)
	52	+	if !loaded {
	53	+	return nil, E.New("outbound not found: ", outboundTag)
	54	+	}
	55	+	return outbound, nil
	56	+	}
	57	+	}
	58	+

■ ■ ■ ■ ■ ■

cmd/sing-box/cmd_tools_connect.go

		skipped 14 lines
15	15		"github.com/spf13/cobra"
16	16		)
17	17
18		-	var commandFlagNetwork string
	18	+	var (
	19	+	commandConnectFlagNetwork string
	20	+	commandConnectFlagOutbound string
	21	+	)
19	22
20	23		var commandConnect = &cobra.Command{
21	24		Use: "connect [address]",
22		-	Short: "connect to a address through default outbound",
	25	+	Short: "Connect to an address",
23	26		Args: cobra.ExactArgs(1),
24	27		Run: func(cmd *cobra.Command, args []string) {
25	28		err := connect(args[0])
		skipped 4 lines
30	33		}
31	34
32	35		func init() {
33		-	commandConnect.Flags().StringVar(&commandFlagNetwork, "network", "tcp", "network type")
	36	+	commandConnect.Flags().StringVar(&commandConnectFlagNetwork, "network", "tcp", "network type")
	37	+	commandConnect.Flags().StringVar(&commandConnectFlagOutbound, "outbound", "", "outbound tag")
34	38		commandTools.AddCommand(commandConnect)
35	39		}
36	40
37	41		func connect(address string) error {
38		-	switch N.NetworkName(commandFlagNetwork) {
	42	+	switch N.NetworkName(commandConnectFlagNetwork) {
39	43		case N.NetworkTCP, N.NetworkUDP:
40	44		default:
41		-	return E.Cause(N.ErrUnknownNetwork, commandFlagNetwork)
	45	+	return E.Cause(N.ErrUnknownNetwork, commandConnectFlagNetwork)
42	46		}
43	47		instance, err := createPreStartedClient()
44	48		if err != nil {
45	49		return err
46	50		}
47		-	outbound := instance.Router().DefaultOutbound(commandFlagNetwork)
48		-	if outbound == nil {
49		-	return E.New("missing default outbound")
	51	+	defer instance.Close()
	52	+	dialer, err := createDialer(instance, commandConnectFlagNetwork, commandConnectFlagOutbound)
	53	+	if err != nil {
	54	+	return err
50	55		}
51		-	conn, err := outbound.DialContext(context.Background(), commandFlagNetwork, M.ParseSocksaddr(address))
	56	+	conn, err := dialer.DialContext(context.Background(), commandConnectFlagNetwork, M.ParseSocksaddr(address))
52	57		if err != nil {
53	58		return E.Cause(err, "connect to server")
54	59		}
		skipped 3 lines
58	63		})
59	64		group.Append("download", func(ctx context.Context) error {
60	65		return common.Error(bufio.Copy(os.Stdout, conn))
	66	+	})
	67	+	group.Cleanup(func() {
	68	+	conn.Close()
61	69		})
62	70		err = group.Run(context.Background())
63	71		if E.IsClosed(err) {
		skipped 7 lines

■ ■ ■ ■ ■ ■

cmd/sing-box/cmd_tools_fetch.go

1	+	package main
2	+
3	+	import (
4	+	"context"
5	+	"errors"
6	+	"io"
7	+	"net"
8	+	"net/http"
9	+	"net/url"
10	+	"os"
11	+
12	+	"github.com/sagernet/sing-box/log"
13	+	"github.com/sagernet/sing/common/bufio"
14	+	M "github.com/sagernet/sing/common/metadata"
15	+	N "github.com/sagernet/sing/common/network"
16	+
17	+	"github.com/spf13/cobra"
18	+	)
19	+
20	+	var commandFetchFlagOutbound string
21	+
22	+	var commandFetch = &cobra.Command{
23	+	Use: "fetch",
24	+	Short: "Fetch an URL",
25	+	Args: cobra.MinimumNArgs(1),
26	+	Run: func(cmd *cobra.Command, args []string) {
27	+	err := fetch(args)
28	+	if err != nil {
29	+	log.Fatal(err)
30	+	}
31	+	},
32	+	}
33	+
34	+	func init() {
35	+	commandFetch.Flags().StringVar(&commandFetchFlagOutbound, "outbound", "", "outbound tag")
36	+	commandTools.AddCommand(commandFetch)
37	+	}
38	+
39	+	var httpClient *http.Client
40	+
41	+	func fetch(args []string) error {
42	+	instance, err := createPreStartedClient()
43	+	if err != nil {
44	+	return err
45	+	}
46	+	defer instance.Close()
47	+	httpClient = &http.Client{
48	+	Transport: &http.Transport{
49	+	DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
50	+	dialer, err := createDialer(instance, N.NetworkTCP, commandFetchFlagOutbound)
51	+	if err != nil {
52	+	return nil, err
53	+	}
54	+	return dialer.DialContext(ctx, network, M.ParseSocksaddr(addr))
55	+	},
56	+	ForceAttemptHTTP2: true,
57	+	},
58	+	}
59	+	defer httpClient.CloseIdleConnections()
60	+	for _, urlString := range args {
61	+	parsedURL, err := url.Parse(urlString)
62	+	if err != nil {
63	+	return err
64	+	}
65	+	switch parsedURL.Scheme {
66	+	case "":
67	+	parsedURL.Scheme = "http"
68	+	fallthrough
69	+	case "http", "https":
70	+	err = fetchHTTP(parsedURL)
71	+	if err != nil {
72	+	return err
73	+	}
74	+	}
75	+	}
76	+	return nil
77	+	}
78	+
79	+	func fetchHTTP(parsedURL *url.URL) error {
80	+	request, err := http.NewRequest("GET", parsedURL.String(), nil)
81	+	if err != nil {
82	+	return err
83	+	}
84	+	request.Header.Add("User-Agent", "curl/7.88.0")
85	+	response, err := httpClient.Do(request)
86	+	if err != nil {
87	+	return err
88	+	}
89	+	defer response.Body.Close()
90	+	_, err = bufio.Copy(os.Stdout, response.Body)
91	+	if errors.Is(err, io.EOF) {
92	+	return nil
93	+	}
94	+	return err
95	+	}
96	+

Add command to fetch a URL