示例#1
0
/*------------------------------------------------------------------------
 * void process_options();
 *
 * Processes the command-line options and sets the protocol parameters
 * as appropriate.
 *------------------------------------------------------------------------*/
func ProcessOptions() *Parameter {
	parameter := NewParameter()

	opt.BoolVarLong(&parameter.verbose, "verbose", 'v',
		"turns on verbose output mode, deafult off")
	opt.BoolVarLong(&parameter.transcript, "transcript", 't',
		"turns on transcript mode for statistics recording, deafult off")
	opt.BoolVarLong(&parameter.ipv6, "v6", '6',
		"operates using IPv6 instead of (not in addition to!) IPv4")
	deafultHelp := fmt.Sprintf(
		"specifies which TCP port on which to listen to incoming connections, default %d",
		tsunami.TS_TCP_PORT)
	port := opt.Uint16Long("port", 'p', tsunami.TS_TCP_PORT, deafultHelp)
	secret := opt.StringLong("secret", 's', tsunami.DEFAULT_SECRET,
		"specifies the shared secret for the client and server")

	deafultHelp = fmt.Sprintf(
		"specifies the desired size for UDP socket send buffer (in bytes), default %d",
		DEFAULT_UDP_BUFFER)
	buffer := opt.Uint32Long("buffer", 'b', DEFAULT_UDP_BUFFER, deafultHelp)

	deafultHelp = fmt.Sprintf(
		"specifies the timeout in seconds for disconnect after client heartbeat lost, default %d",
		DEFAULT_HEARTBEAT_TIMEOUT)
	hbtimeout := opt.Uint16Long("hbtimeout", 'h', DEFAULT_HEARTBEAT_TIMEOUT, deafultHelp)
	opt.StringVarLong(&parameter.client, "client", 'c',
		"specifies an alternate client IP or host where to send data")
	opt.StringVarLong(&parameter.finishhook, "finishhook", 'f',
		"run command on transfer completion, file name is appended automatically")
	opt.StringVarLong(&parameter.allhook, "allhook", 'a',
		"run command on 'get *' to produce a custom file list for client downloads")
	opt.Parse()

	parameter.tcp_port = *port
	parameter.secret = *secret
	parameter.udp_buffer = *buffer
	parameter.hb_timeout = *hbtimeout

	files := opt.Args()
	parameter.file_names = files
	parameter.file_sizes = make([]uint64, len(files))
	parameter.total_files = uint16(len(files))
	for i, v := range files {
		stat, err := os.Stat(v)
		if err != nil {
			fmt.Fprintln(os.Stderr, v, err)
		} else {
			size := stat.Size()
			parameter.file_sizes[i] = uint64(size)
			fmt.Fprintf(os.Stderr, " %3d)   %-20s  %d bytes\n", i+1, v, size)
		}
	}

	parameter.VerboseArg("")
	return parameter
}
示例#2
0
文件: indexer.go 项目: cardi/timefind
func main() {
	getopt.ListVarLong(&configPaths, "config", 'c',
		"REQUIRED: Path to configuration file (can be used multiple times)", "PATH")
	getopt.BoolVarLong(&verbose, "verbose", 'v', "Verbose progress indicators and messages")
	help := getopt.BoolLong("help", 'h', "Show this help message and exit")
	getopt.SetParameters("")
	getopt.Parse()

	if *help {
		getopt.Usage()
		os.Exit(0)
	}

	if len(configPaths) == 0 {
		log.Printf("no configuration (-c/--config) found")
		getopt.Usage()
		os.Exit(1)
	}

	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)

	// set parallelism (automatic in Go 1.6+)
	if runtime.GOMAXPROCS(0) < runtime.NumCPU() {
		runtime.GOMAXPROCS(runtime.NumCPU())
		log.Printf("setting GOMAXPROCS = NumCPU = %d\n", runtime.NumCPU())
	}

	for _, configPath := range configPaths {

		cfg, err := config.NewConfiguration(configPath)
		if err != nil {
			log.Fatal(err)
			continue
		}

		idx, err := index.NewIndex(cfg)
		if err != nil {
			log.Print(err)
			return
		}

		if err := idx.Update(); err != nil {
			log.Print(err)
			return
		}

		if err := idx.WriteOut(); err != nil {
			log.Print(err)
			return
		}
	}
}
示例#3
0
文件: main.go 项目: gnomix/weave
func main() {
	var (
		justVersion bool
		logLevel    = "info"
		c           = proxy.Config{ListenAddrs: defaultListenAddrs}
	)

	c.Version = version
	getopt.BoolVarLong(&justVersion, "version", 0, "print version and exit")
	getopt.StringVarLong(&logLevel, "log-level", 0, "logging level (debug, info, warning, error)", "info")
	getopt.ListVar(&c.ListenAddrs, 'H', fmt.Sprintf("address on which to listen (default %s)", defaultListenAddrs))
	getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipalloc", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR")
	getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipam", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR (deprecated; please use --no-default-ipalloc")
	getopt.StringVarLong(&c.TLSConfig.CACert, "tlscacert", 0, "Trust certs signed only by this CA")
	getopt.StringVarLong(&c.TLSConfig.Cert, "tlscert", 0, "Path to TLS certificate file")
	getopt.BoolVarLong(&c.TLSConfig.Enabled, "tls", 0, "Use TLS; implied by --tlsverify")
	getopt.StringVarLong(&c.TLSConfig.Key, "tlskey", 0, "Path to TLS key file")
	getopt.BoolVarLong(&c.TLSConfig.Verify, "tlsverify", 0, "Use TLS and verify the remote")
	getopt.BoolVarLong(&c.WithDNS, "with-dns", 'w', "instruct created containers to always use weaveDNS as their nameserver")
	getopt.BoolVarLong(&c.WithoutDNS, "without-dns", 0, "instruct created containers to never use weaveDNS as their nameserver")
	getopt.Parse()

	if justVersion {
		fmt.Printf("weave proxy %s\n", version)
		os.Exit(0)
	}

	if c.WithDNS && c.WithoutDNS {
		Log.Fatalf("Cannot use both '--with-dns' and '--without-dns' flags")
	}

	SetLogLevel(logLevel)

	Log.Infoln("weave proxy", version)
	Log.Infoln("Command line arguments:", strings.Join(os.Args[1:], " "))

	p, err := proxy.NewProxy(c)
	if err != nil {
		Log.Fatalf("Could not start proxy: %s", err)
	}

	p.ListenAndServe()
}
示例#4
0
文件: twhelp.go 项目: mpyw/twhelp
func main() {
	var (
		format string
		t      *oauth.Credential
		help   bool
		ini    bool
		yaml   bool
		array  bool
		assoc  bool
		json   bool
		env    bool
		xauth  bool
		oauth_ bool
		ck     string
		cs     string
		sn     string
		pw     string
		app    string
	)
	util := utility.NewUtil()
	prompter := prompt.NewPrompter()
	getopt.BoolVarLong(&help, "help", 'h')
	getopt.BoolVarLong(&ini, "ini", 'i')
	getopt.BoolVarLong(&yaml, "yaml", 'y')
	getopt.BoolVarLong(&array, "array", 'a')
	getopt.BoolVarLong(&assoc, "assoc", 'A')
	getopt.BoolVarLong(&json, "json", 'j')
	getopt.BoolVarLong(&env, "env", 'e')
	getopt.BoolVarLong(&oauth_, "oauth", 'o')
	getopt.BoolVarLong(&xauth, "xauth", 'x')
	getopt.StringVarLong(&ck, "ck", 0, "")
	getopt.StringVarLong(&cs, "cs", 0, "")
	getopt.StringVarLong(&sn, "sn", 0, "")
	getopt.StringVarLong(&pw, "pw", 0, "")
	getopt.StringVarLong(&app, "app", 0, "")
	getopt.SetUsage(util.Usage)
	getopt.CommandLine.Parse(os.Args)
	if help {
		util.Usage()
		os.Exit(0)
	}
	if ck == "" && cs == "" && app != "" {
		appks, ok := util.Apps[app]
		if !ok {
			log.Fatalln("Application not found: " + app)
		}
		ck = (*appks)[0]
		cs = (*appks)[1]
	}
	if ck == "" {
		ck = prompter.PromptTrimmed("consumer_key: ")
	}
	if cs == "" {
		cs = prompter.PromptTrimmed("consumer_secret: ")
	}
	if xauth || !oauth_ {
		if sn == "" {
			sn = prompter.PromptTrimmed("screen_name: ")
		}
		if pw == "" {
			pw = prompter.PromptMasked("password: "******"", ""}).RenewWithAccessToken(map[string]string{
				"x_auth_mode":     "client_auth",
				"x_auth_username": sn,
				"x_auth_password": pw,
			}, nil)
		} else {
			t = (&oauth.Credential{ck, cs, "", ""}).RenewWithRequestToken()
			sess := session.NewSession()
			uri := "https://api.twitter.com/oauth/authorize?force_login=1&oauth_token=" + t.OAuthToken
			{
				expr := `<input name="authenticity_token" type="hidden" value="([^"]+)">`
				matches := regexp.MustCompile(expr).FindSubmatch(sess.Get(uri))
				if matches == nil {
					log.Fatalln("Could not find authenticity_token")
				}
				sess.SetAuthenticityToken(string(matches[1]))
			}
			{
				expr := `<code>([^<]+)</code>`
				matches := regexp.MustCompile(expr).FindSubmatch(sess.Post(uri, &url.Values{
					"session[username_or_email]": {sn},
					"session[password]":          {pw},
				}))
				if matches == nil {
					log.Fatalln("Wrong username or password. Otherwise, you may have to verify your email address.")
				}
				verifier := string(matches[1])
				t = t.RenewWithAccessToken(map[string]string{}, &verifier)
			}
		}
	} else {
		t = (&oauth.Credential{ck, cs, "", ""}).RenewWithRequestToken()
		uri := "https://api.twitter.com/oauth/authorize?force_login=1&oauth_token=" + t.OAuthToken
		os.Stderr.WriteString("Access here for authorization: " + uri + "\n")
		verifier := prompter.PromptTrimmed("PIN: ")
		t = t.RenewWithAccessToken(map[string]string{}, &verifier)
	}

	if ini {
		format = `consumer_key        = "%s"
consumer_secret     = "%s"
access_token        = "%s"
access_token_secret = "%s"
`
	} else if yaml {
		format = `consumer_key:        "%s"
consumer_secret:     "%s"
access_token:        "%s"
access_token_secret: "%s"
`
	} else if array {
		format = `[
    "%s",
    "%s",
    "%s",
    "%s"
]
`
	} else if assoc {
		format = `[
    "consumer_key"        => "%s",
    "consumer_secret"     => "%s",
    "access_token"        => "%s",
    "access_token_secret" => "%s",
]
`
	} else if json {
		format = `{
    "consumer_key":        "%s",
    "consumer_secret":     "%s",
    "access_token":        "%s",
    "access_token_secret": "%s"
}
`
	} else if env {
		format = `CONSUMER_KEY="%s"
CONSUMER_SECRET="%s"
ACCESS_TOKEN="%s"
ACCESS_TOKEN_SECRET="%s"
`
	} else {
		format = `%s
%s
%s
%s
`
	}

	fmt.Printf(format, t.ConsumerKey, t.ConsumerSecret, t.OAuthToken, t.OAuthTokenSecret)

}
示例#5
0
func main() {
	// Uncomment the following lines if you need to time the options parsing
	//log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
	//log.Println(": Program started")

	// Configure Command Line Options
	var useUDP, quiet, debug bool
	var maxRTT time.Duration
	var numPing int
	getopt.BoolVarLong(&useUDP, "udp", 'u', "use UDP instead of ICMP")
	getopt.BoolVarLong(&quiet, "quiet", 'q', "only display host data")
	getopt.BoolVarLong(&debug, "debug", 'v', "print additional messages")
	maxRTT = defaultMaxRTT
	getopt.DurationVarLong(&maxRTT, "rtt", 't', "max RTT for each ping")
	numPing = defaultPingCount
	getopt.IntVarLong(&numPing, "count", 'n', "max number of pings per target")
	getopt.SetParameters("startIP endIP")
	getopt.Parse()

	// Verify arguments
	if getopt.NArgs() != 2 {
		log.Println("Incorrect number of arguments!")
		getopt.PrintUsage(os.Stderr)
		os.Exit(1)
	}
	startIPString := getopt.Arg(0)
	endIPString := getopt.Arg(1)

	// Test for incompatible options
	if quiet && debug {
		log.Println("`quiet` and `debug` are incompatible")
		getopt.PrintUsage(os.Stderr)
		os.Exit(1)
	}

	if debug {
		log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
		log.Println(": Command Line Parsing complete")
	}

	// Convert to IP object
	startIP := net.ParseIP(startIPString)
	if startIP == nil {
		log.Fatal("Start IP,", startIPString, ", is not a valid IP address")
	}
	if debug {
		log.Println(": Start IP\t", startIPString)
	}
	endIP := net.ParseIP(endIPString)
	if endIP == nil {
		log.Fatal("End IP,", endIPString, ", is not a valid IP address")
	}
	if debug {
		log.Println(": End IP  \t", endIPString)
	}

	netProto := "ip4:icmp"
	if strings.Index(startIPString, ":") != -1 {
		netProto = "ip6:ipv6-icmp"
	}

	p := fastping.NewPinger()
	p.MaxRTT = maxRTT
	p.OnRecv = func(addr *net.IPAddr, rtt time.Duration) {
		var device resultData
		device.PingResult = addr.String() + "\t" + roundDuration(baseRTT+rtt, time.Millisecond).String()
		ips = append(ips, device)
		p.RemoveIPAddr(addr)
	}

	currentIP := make(net.IP, len(startIP))
	for copy(currentIP, startIP); bytes.Compare(currentIP, endIP) <= 0; inc(currentIP) {
		ra, err := net.ResolveIPAddr(netProto, currentIP.String())
		if err != nil {
			log.Fatal(err)
		}
		p.AddIPAddr(ra)
	}

	if useUDP {
		p.Network("udp")
	}

	if debug {
		log.Println(": Start Scan")
	}

	for index := 0; index < numPing; index++ {
		baseRTT = time.Duration(index) * maxRTT
		err := p.Run()
		if err != nil {
			log.Fatal("Pinger returns error: ", err)
		}
	}

	if debug {
		log.Println(": Scan complete")
	}

	if !quiet {
		fmt.Println()
		fmt.Printf("%d devices found\n", len(ips))
		fmt.Println()
	}

	if debug {
		log.Println(": Start Host Lookup")
	}

	// Query DNS for the name of each device found by the ping scan
	var ipAndTime []string
	var hostname string
	var wg sync.WaitGroup
	for index, ip := range ips {
		ipAndTime = strings.SplitN(ip.PingResult, "\t", 2)
		wg.Add(1)
		go func(ipString string, localIndex int) {
			hosts, err := net.LookupAddr(ipString)
			if err != nil {
				hostname = "Error: " + err.Error()
			} else {
				hostname = strings.Join(hosts, ", ")
			}
			ips[localIndex].HostResult = hostname
			wg.Done()
		}(ipAndTime[0], index)
	}
	wg.Wait()

	if debug {
		log.Println(": DNS complete")
	}

	sort.Sort(byIP(ips))

	if debug {
		log.Println(": Sort complete")
	}

	for _, ip := range ips {
		fmt.Printf("%-25s\t--> %s\n", ip.PingResult, ip.HostResult)
	}

	if !quiet {
		fmt.Println()
	}

	if debug {
		log.Println(": Program complete")
	}
}