func main() {
log.SetOutput(os.Stdout)
var cmdConfig ss.Config
var printVer bool
var core int
flag.BoolVar(&printVer, "version", false, "print version")
flag.StringVar(&configFile, "c", "config.json", "specify config file")
flag.StringVar(&cmdConfig.Password, "k", "", "password")
flag.IntVar(&cmdConfig.ServerPort, "p", 0, "server port")
flag.IntVar(&cmdConfig.Timeout, "t", 60, "connection timeout (in seconds)")
flag.StringVar(&cmdConfig.Method, "m", "", "encryption method, use empty string or rc4")
flag.IntVar(&core, "core", 0, "maximum number of CPU cores to use, default is determinied by Go runtime")
flag.BoolVar((*bool)(&debug), "d", false, "print debug message")
flag.Parse()
if printVer {
ss.PrintVersion()
os.Exit(0)
}
ss.SetDebug(debug)
var err error
config, err = ss.ParseConfig(configFile)
if err != nil {
if !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "error reading %s: %v\n", configFile, err)
os.Exit(1)
}
config = &cmdConfig
} else {
ss.UpdateConfig(config, &cmdConfig)
}
if err = unifyPortPassword(config); err != nil {
os.Exit(1)
}
if err = ss.SetDefaultCipher(config.Method); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
if core > 0 {
runtime.GOMAXPROCS(core)
}
for port, password := range config.PortPassword {
go run(port, password)
}
waitSignal()
}
func initShadowSocks() {
if config.ShadowSocks != "" && config.ShadowPasswd != "" {
var err error
if err = ss.SetDefaultCipher(config.ShadowMethod); err != nil {
fmt.Println("Initializing shadowsocks:", err)
os.Exit(1)
}
if cipher, err = ss.NewCipher(config.ShadowPasswd); err != nil {
fmt.Println("Creating shadowsocks cipher:", err)
os.Exit(1)
}
debug.Println("shadowsocks server:", config.ShadowSocks)
return
}
if (config.ShadowSocks != "" && config.ShadowPasswd == "") ||
(config.ShadowSocks == "" && config.ShadowPasswd != "") {
fmt.Println("Missing option: shadowSocks and shadowPasswd should be both given")
os.Exit(1)
}
}
func main() {
log.SetOutput(os.Stdout)
var configFile, cmdServer string
var cmdConfig ss.Config
var printVer bool
flag.BoolVar(&printVer, "version", false, "print version")
flag.StringVar(&configFile, "c", "config.json", "specify config file")
flag.StringVar(&cmdServer, "s", "", "server address")
flag.StringVar(&cmdConfig.Password, "k", "", "password")
flag.IntVar(&cmdConfig.ServerPort, "p", 0, "server port")
flag.IntVar(&cmdConfig.LocalPort, "l", 0, "local socks5 proxy port")
flag.StringVar(&cmdConfig.Method, "m", "", "encryption method, use empty string or rc4")
flag.BoolVar((*bool)(&debug), "d", false, "print debug message")
flag.Parse()
if printVer {
ss.PrintVersion()
os.Exit(0)
}
cmdConfig.Server = cmdServer
ss.SetDebug(debug)
exists, err := ss.IsFileExists(configFile)
// If no config file in current directory, try search it in the binary directory
// Note there's no portable way to detect the binary directory.
binDir := path.Dir(os.Args[0])
if (!exists || err != nil) && binDir != "" && binDir != "." {
oldConfig := configFile
configFile = path.Join(binDir, "config.json")
log.Printf("%s not found, try config file %s\n", oldConfig, configFile)
}
config, err := ss.ParseConfig(configFile)
if err != nil {
config = &cmdConfig
if !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "error reading %s: %v\n", configFile, err)
os.Exit(1)
}
} else {
ss.UpdateConfig(config, &cmdConfig)
}
if err = ss.SetDefaultCipher(config.Method); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
if len(config.ServerPassword) == 0 {
if !enoughOptions(config) {
fmt.Fprintln(os.Stderr, "must specify server address, password and both server/local port")
os.Exit(1)
}
} else {
if config.Password != "" || config.ServerPort != 0 || config.GetServerArray() != nil {
fmt.Fprintln(os.Stderr, "given server_password, ignore server, server_port and password option:", config)
}
if config.LocalPort == 0 {
fmt.Fprintln(os.Stderr, "must specify local port")
os.Exit(1)
}
}
initServers(config)
run(strconv.Itoa(config.LocalPort))
}
func main() {
flag.StringVar(&config.server, "s", "127.0.0.1", "server:port")
flag.IntVar(&config.port, "p", 0, "server:port")
flag.IntVar(&config.core, "core", 1, "number of CPU cores to use")
flag.StringVar(&config.passwd, "k", "", "password")
flag.StringVar(&config.method, "m", "", "encryption method, use empty string or rc4")
flag.IntVar(&config.nconn, "nc", 1, "number of connection to server")
flag.IntVar(&config.nreq, "nr", 1, "number of request for each connection")
// flag.IntVar(&config.nsec, "ns", 0, "run how many seconds for each connection")
flag.BoolVar((*bool)(&debug), "d", false, "print http response body for debugging")
flag.Parse()
if config.server == "" || config.port == 0 || config.passwd == "" || len(flag.Args()) != 1 {
fmt.Printf("Usage: %s -s <server> -p <port> -k <password> <url>\n", os.Args[0])
os.Exit(1)
}
if err := ss.SetDefaultCipher(config.method); err != nil {
fmt.Println(err)
os.Exit(1)
}
runtime.GOMAXPROCS(config.core)
uri := flag.Arg(0)
if !strings.HasPrefix(uri, "http://") {
uri = "http://" + uri
}
cipher, err := ss.NewCipher(config.passwd)
if err != nil {
fmt.Println("Error creating cipher:", err)
os.Exit(1)
}
serverAddr := net.JoinHostPort(config.server, strconv.Itoa(config.port))
parsedURL, err := url.Parse(uri)
if err != nil {
fmt.Println("Error parsing url:", err)
os.Exit(1)
}
host, _, err := net.SplitHostPort(parsedURL.Host)
if err != nil {
host = net.JoinHostPort(parsedURL.Host, "80")
} else {
host = parsedURL.Host
}
// fmt.Println(host)
rawAddr, err := ss.RawAddr(host)
if err != nil {
panic("Error getting raw address.")
return
}
done := make(chan []time.Duration)
for i := 1; i <= config.nconn; i++ {
go get(i, uri, serverAddr, rawAddr, cipher, done)
}
// collect request finish time
reqTime := make([]int64, config.nconn*config.nreq)
reqDone := 0
for i := 1; i <= config.nconn; i++ {
rt := <-done
for _, t := range rt {
reqTime[reqDone] = int64(t)
reqDone++
}
}
fmt.Println("number of total requests:", config.nconn*config.nreq)
fmt.Println("number of finished requests:", reqDone)
if reqDone == 0 {
return
}
// calculate average an standard deviation
reqTime = reqTime[:reqDone]
var sum int64
for _, d := range reqTime {
sum += d
}
avg := float64(sum) / float64(reqDone)
varSum := float64(0)
for _, d := range reqTime {
di := math.Abs(float64(d) - avg)
di *= di
varSum += di
}
stddev := math.Sqrt(varSum / float64(reqDone))
fmt.Println("\naverage time per request:", time.Duration(avg))
fmt.Println("standard deviation:", time.Duration(stddev))
}