func GetBtcdConfig() (cfg config, err error) { btcdHomeDir := btcutil.AppDataDir("btcd", false) defaultConfigFile := filepath.Join(btcdHomeDir, "btcd.conf") cfg = config{ ConfigFile: defaultConfigFile, } parser := flags.NewParser(&cfg, flags.Default) err = flags.NewIniParser(parser).ParseFile(cfg.ConfigFile) return }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in daemon functioning properly without any config settings // while still allowing the user to override settings with config files and // command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ DcrdHomeDir: dcrdHomeDir, ConfigFile: defaultConfigFile, DebugLevel: defaultLogLevel, MaxPeers: defaultMaxPeers, BanDuration: defaultBanDuration, RPCMaxClients: defaultMaxRPCClients, RPCMaxWebsockets: defaultMaxRPCWebsockets, DataDir: defaultDataDir, LogDir: defaultLogDir, DbType: defaultDbType, RPCKey: defaultRPCKeyFile, RPCCert: defaultRPCCertFile, MinRelayTxFee: defaultMinRelayTxFee.ToCoin(), FreeTxRelayLimit: defaultFreeTxRelayLimit, BlockMinSize: defaultBlockMinSize, BlockMaxSize: defaultBlockMaxSize, BlockPrioritySize: defaultBlockPrioritySize, SigCacheMaxSize: defaultSigCacheMaxSize, MaxOrphanTxs: maxOrphanTransactions, Generate: defaultGenerate, NoAddrIndex: defaultAddrIndex, NoMiningStateSync: defaultNoMiningStateSync, AllowOldVotes: defaultAllowOldVotes, } // Service options which are only added on Windows. serviceOpts := serviceOptions{} // Pre-parse the command line options to see if an alternative config // file or the version flag was specified. Any errors aside from the // help message error can be ignored here since they will be caught by // the final parse below. preCfg := cfg preParser := newConfigParser(&preCfg, &serviceOpts, flags.HelpFlag) _, err := preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp { fmt.Fprintln(os.Stderr, err) return nil, nil, err } } // Show the version and exit if the version flag was specified. appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show usage", appName) if preCfg.ShowVersion { fmt.Println(appName, "version", version()) os.Exit(0) } // Perform service command and exit if specified. Invalid service // commands show an appropriate error. Only runs on Windows since // the runServiceCommand function will be nil when not on Windows. if serviceOpts.ServiceCommand != "" && runServiceCommand != nil { err := runServiceCommand(serviceOpts.ServiceCommand) if err != nil { fmt.Fprintln(os.Stderr, err) } os.Exit(0) } // Update the home directory for dcrd if specified. Since the home // directory is updated, other variables need to be updated to // reflect the new changes. if len(preCfg.DcrdHomeDir) > 0 { cfg.DcrdHomeDir, _ = filepath.Abs(preCfg.DcrdHomeDir) cfg.ConfigFile = filepath.Join(cfg.DcrdHomeDir, defaultConfigFilename) cfg.DataDir = filepath.Join(cfg.DcrdHomeDir, defaultDataDirname) cfg.RPCKey = filepath.Join(cfg.DcrdHomeDir, "rpc.key") cfg.RPCCert = filepath.Join(cfg.DcrdHomeDir, "rpc.cert") cfg.LogDir = filepath.Join(cfg.DcrdHomeDir, defaultLogDirname) } // Load additional config from file. var configFileError error parser := newConfigParser(&cfg, &serviceOpts, flags.Default) if !(preCfg.SimNet) || preCfg.ConfigFile != defaultConfigFile { err := flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintf(os.Stderr, "Error parsing config "+ "file: %v\n", err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } configFileError = err } } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { fmt.Fprintln(os.Stderr, usageMessage) } return nil, nil, err } // Create the home directory if it doesn't already exist. funcName := "loadConfig" err = os.MkdirAll(dcrdHomeDir, 0700) if err != nil { // Show a nicer error message if it's because a symlink is // linked to a directory that does not exist (probably because // it's not mounted). if e, ok := err.(*os.PathError); ok && os.IsExist(err) { if link, lerr := os.Readlink(e.Path); lerr == nil { str := "is symlink %s -> %s mounted?" err = fmt.Errorf(str, e.Path, link) } } str := "%s: Failed to create home directory: %v" err := fmt.Errorf(str, funcName, err) fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Multiple networks can't be selected simultaneously. numNets := 0 // Count number of network flags passed; assign active network params // while we're at it if cfg.TestNet { numNets++ activeNetParams = &testNetParams } if cfg.SimNet { numNets++ // Also disable dns seeding on the simulation test network. activeNetParams = &simNetParams cfg.DisableDNSSeed = true } if numNets > 1 { str := "%s: The testnet and simnet params can't be " + "used together -- choose one of the three" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Append the network type to the data directory so it is "namespaced" // per network. In addition to the block database, there are other // pieces of data that are saved to disk such as address manager state. // All data is specific to a network, so namespacing the data directory // means each individual piece of serialized data does not have to // worry about changing names per network and such. cfg.DataDir = cleanAndExpandPath(cfg.DataDir) cfg.DataDir = filepath.Join(cfg.DataDir, netName(activeNetParams)) // Append the network type to the log directory so it is "namespaced" // per network in the same fashion as the data directory. cfg.LogDir = cleanAndExpandPath(cfg.LogDir) cfg.LogDir = filepath.Join(cfg.LogDir, netName(activeNetParams)) // Special show command to list supported subsystems and exit. if cfg.DebugLevel == "show" { fmt.Println("Supported subsystems", supportedSubsystems()) os.Exit(0) } // Initialize logging at the default logging level. initSeelogLogger(filepath.Join(cfg.LogDir, defaultLogFilename)) setLogLevels(defaultLogLevel) // Parse, validate, and set debug log level(s). if err := parseAndSetDebugLevels(cfg.DebugLevel); err != nil { err := fmt.Errorf("%s: %v", funcName, err.Error()) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Validate database type. if !validDbType(cfg.DbType) { str := "%s: The specified database type [%v] is invalid -- " + "supported types %v" err := fmt.Errorf(str, funcName, cfg.DbType, knownDbTypes) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if !cfg.NoAddrIndex && cfg.DropAddrIndex { err := fmt.Errorf("addrindex and dropaddrindex cannot be " + "activated at the same") fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Memdb does not currently support the addrindex. if cfg.DbType == "memdb" && !cfg.NoAddrIndex { err := fmt.Errorf("memdb does not currently support the addrindex") fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Validate profile port number if cfg.Profile != "" { profilePort, err := strconv.Atoi(cfg.Profile) if err != nil || profilePort < 1024 || profilePort > 65535 { str := "%s: The profile port must be between 1024 and 65535" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } // Don't allow ban durations that are too short. if cfg.BanDuration < time.Duration(time.Second) { str := "%s: The banduration option may not be less than 1s -- parsed [%v]" err := fmt.Errorf(str, funcName, cfg.BanDuration) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // --addPeer and --connect do not mix. if len(cfg.AddPeers) > 0 && len(cfg.ConnectPeers) > 0 { str := "%s: the --addpeer and --connect options can not be " + "mixed" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // --proxy or --connect without --listen disables listening. if (cfg.Proxy != "" || len(cfg.ConnectPeers) > 0) && len(cfg.Listeners) == 0 { cfg.DisableListen = true } // Connect means no DNS seeding. if len(cfg.ConnectPeers) > 0 { cfg.DisableDNSSeed = true } // Add the default listener if none were specified. The default // listener is all addresses on the listen port for the network // we are to connect to. if len(cfg.Listeners) == 0 { cfg.Listeners = []string{ net.JoinHostPort("", activeNetParams.DefaultPort), } } // Check to make sure limited and admin users don't have the same username if cfg.RPCUser == cfg.RPCLimitUser && cfg.RPCUser != "" { str := "%s: --rpcuser and --rpclimituser must not specify the " + "same username" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Check to make sure limited and admin users don't have the same password if cfg.RPCPass == cfg.RPCLimitPass && cfg.RPCPass != "" { str := "%s: --rpcpass and --rpclimitpass must not specify the " + "same password" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // The RPC server is disabled if no username or password is provided. if (cfg.RPCUser == "" || cfg.RPCPass == "") && (cfg.RPCLimitUser == "" || cfg.RPCLimitPass == "") { cfg.DisableRPC = true } // Default RPC to listen on localhost only. if !cfg.DisableRPC && len(cfg.RPCListeners) == 0 { addrs, err := net.LookupHost("localhost") if err != nil { return nil, nil, err } cfg.RPCListeners = make([]string, 0, len(addrs)) for _, addr := range addrs { addr = net.JoinHostPort(addr, activeNetParams.rpcPort) cfg.RPCListeners = append(cfg.RPCListeners, addr) } } // Validate the the minrelaytxfee. cfg.minRelayTxFee, err = dcrutil.NewAmount(cfg.MinRelayTxFee) if err != nil { str := "%s: invalid minrelaytxfee: %v" err := fmt.Errorf(str, funcName, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Limit the max block size to a sane value. if cfg.BlockMaxSize < blockMaxSizeMin || cfg.BlockMaxSize > blockMaxSizeMax { str := "%s: The blockmaxsize option must be in between %d " + "and %d -- parsed [%d]" err := fmt.Errorf(str, funcName, blockMaxSizeMin, blockMaxSizeMax, cfg.BlockMaxSize) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Limit the max orphan count to a sane vlue. if cfg.MaxOrphanTxs < 0 { str := "%s: The maxorphantx option may not be less than 0 " + "-- parsed [%d]" err := fmt.Errorf(str, funcName, cfg.MaxOrphanTxs) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Limit the block priority and minimum block sizes to max block size. cfg.BlockPrioritySize = minUint32(cfg.BlockPrioritySize, cfg.BlockMaxSize) cfg.BlockMinSize = minUint32(cfg.BlockMinSize, cfg.BlockMaxSize) // Check getwork keys are valid and saved parsed versions. cfg.miningAddrs = make([]dcrutil.Address, 0, len(cfg.GetWorkKeys)+ len(cfg.MiningAddrs)) for _, strAddr := range cfg.GetWorkKeys { addr, err := dcrutil.DecodeAddress(strAddr, activeNetParams.Params) if err != nil { str := "%s: getworkkey '%s' failed to decode: %v" err := fmt.Errorf(str, funcName, strAddr, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if !addr.IsForNet(activeNetParams.Params) { str := "%s: getworkkey '%s' is on the wrong network" err := fmt.Errorf(str, funcName, strAddr) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } cfg.miningAddrs = append(cfg.miningAddrs, addr) } // Check mining addresses are valid and saved parsed versions. for _, strAddr := range cfg.MiningAddrs { addr, err := dcrutil.DecodeAddress(strAddr, activeNetParams.Params) if err != nil { str := "%s: mining address '%s' failed to decode: %v" err := fmt.Errorf(str, funcName, strAddr, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if !addr.IsForNet(activeNetParams.Params) { str := "%s: mining address '%s' is on the wrong network" err := fmt.Errorf(str, funcName, strAddr) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } cfg.miningAddrs = append(cfg.miningAddrs, addr) } // Ensure there is at least one mining address when the generate flag is // set. if cfg.Generate && len(cfg.MiningAddrs) == 0 { str := "%s: the generate flag is set, but there are no mining " + "addresses specified " err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Add default port to all listener addresses if needed and remove // duplicate addresses. cfg.Listeners = normalizeAddresses(cfg.Listeners, activeNetParams.DefaultPort) // Add default port to all rpc listener addresses if needed and remove // duplicate addresses. cfg.RPCListeners = normalizeAddresses(cfg.RPCListeners, activeNetParams.rpcPort) // Only allow TLS to be disabled if the RPC is bound to localhost // addresses. if !cfg.DisableRPC && cfg.DisableTLS { allowedTLSListeners := map[string]struct{}{ "localhost": struct{}{}, "127.0.0.1": struct{}{}, "::1": struct{}{}, } for _, addr := range cfg.RPCListeners { host, _, err := net.SplitHostPort(addr) if err != nil { str := "%s: RPC listen interface '%s' is " + "invalid: %v" err := fmt.Errorf(str, funcName, addr, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if _, ok := allowedTLSListeners[host]; !ok { str := "%s: the --notls option may not be used " + "when binding RPC to non localhost " + "addresses: %s" err := fmt.Errorf(str, funcName, addr) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } } // Add default port to all added peer addresses if needed and remove // duplicate addresses. cfg.AddPeers = normalizeAddresses(cfg.AddPeers, activeNetParams.DefaultPort) cfg.ConnectPeers = normalizeAddresses(cfg.ConnectPeers, activeNetParams.DefaultPort) // Tor stream isolation requires either proxy or onion proxy to be set. if cfg.TorIsolation && cfg.Proxy == "" && cfg.OnionProxy == "" { str := "%s: Tor stream isolation requires either proxy or " + "onionproxy to be set" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Setup dial and DNS resolution (lookup) functions depending on the // specified options. The default is to use the standard net.Dial // function as well as the system DNS resolver. When a proxy is // specified, the dial function is set to the proxy specific dial // function and the lookup is set to use tor (unless --noonion is // specified in which case the system DNS resolver is used). cfg.dial = net.Dial cfg.lookup = net.LookupIP if cfg.Proxy != "" { _, _, err := net.SplitHostPort(cfg.Proxy) if err != nil { str := "%s: Proxy address '%s' is invalid: %v" err := fmt.Errorf(str, funcName, cfg.Proxy, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if cfg.TorIsolation && (cfg.ProxyUser != "" || cfg.ProxyPass != "") { dcrdLog.Warn("Tor isolation set -- overriding " + "specified proxy user credentials") } proxy := &socks.Proxy{ Addr: cfg.Proxy, Username: cfg.ProxyUser, Password: cfg.ProxyPass, TorIsolation: cfg.TorIsolation, } cfg.dial = proxy.Dial if !cfg.NoOnion { cfg.lookup = func(host string) ([]net.IP, error) { return torLookupIP(host, cfg.Proxy) } } } // Setup onion address dial and DNS resolution (lookup) functions // depending on the specified options. The default is to use the // same dial and lookup functions selected above. However, when an // onion-specific proxy is specified, the onion address dial and // lookup functions are set to use the onion-specific proxy while // leaving the normal dial and lookup functions as selected above. // This allows .onion address traffic to be routed through a different // proxy than normal traffic. if cfg.OnionProxy != "" { _, _, err := net.SplitHostPort(cfg.OnionProxy) if err != nil { str := "%s: Onion proxy address '%s' is invalid: %v" err := fmt.Errorf(str, funcName, cfg.OnionProxy, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if cfg.TorIsolation && (cfg.OnionProxyUser != "" || cfg.OnionProxyPass != "") { dcrdLog.Warn("Tor isolation set -- overriding " + "specified onionproxy user credentials ") } cfg.oniondial = func(a, b string) (net.Conn, error) { proxy := &socks.Proxy{ Addr: cfg.OnionProxy, Username: cfg.OnionProxyUser, Password: cfg.OnionProxyPass, TorIsolation: cfg.TorIsolation, } return proxy.Dial(a, b) } cfg.onionlookup = func(host string) ([]net.IP, error) { return torLookupIP(host, cfg.OnionProxy) } } else { cfg.oniondial = cfg.dial cfg.onionlookup = cfg.lookup } // Specifying --noonion means the onion address dial and DNS resolution // (lookup) functions result in an error. if cfg.NoOnion { cfg.oniondial = func(a, b string) (net.Conn, error) { return nil, errors.New("tor has been disabled") } cfg.onionlookup = func(a string) ([]net.IP, error) { return nil, errors.New("tor has been disabled") } } // Warn about missing config file only after all other configuration is // done. This prevents the warning on help messages and invalid // options. Note this should go directly before the return. if configFileError != nil { dcrdLog.Warnf("%v", configFileError) } return &cfg, remainingArgs, nil }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in btcwallet functioning properly without any config // settings while still allowing the user to override settings with config files // and command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ DebugLevel: defaultLogLevel, ConfigFile: defaultConfigFile, DataDir: defaultDataDir, LogDir: defaultLogDir, WalletPass: defaultPubPassphrase, RPCKey: defaultRPCKeyFile, RPCCert: defaultRPCCertFile, DisallowFree: defaultDisallowFree, RPCMaxClients: defaultRPCMaxClients, RPCMaxWebsockets: defaultRPCMaxWebsockets, } // A config file in the current directory takes precedence. if fileExists(defaultConfigFilename) { cfg.ConfigFile = defaultConfigFile } // Pre-parse the command line options to see if an alternative config // file or the version flag was specified. preCfg := cfg preParser := flags.NewParser(&preCfg, flags.Default) _, err := preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { preParser.WriteHelp(os.Stderr) } return nil, nil, err } // Show the version and exit if the version flag was specified. funcName := "loadConfig" appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show usage", appName) if preCfg.ShowVersion { fmt.Println(appName, "version", version()) os.Exit(0) } // Load additional config from file. var configFileError error parser := flags.NewParser(&cfg, flags.Default) err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintln(os.Stderr, err) parser.WriteHelp(os.Stderr) return nil, nil, err } configFileError = err } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { parser.WriteHelp(os.Stderr) } return nil, nil, err } // Warn about missing config file after the final command line parse // succeeds. This prevents the warning on help messages and invalid // options. if configFileError != nil { log.Warnf("%v", configFileError) } // If an alternate data directory was specified, and paths with defaults // relative to the data dir are unchanged, modify each path to be // relative to the new data dir. if cfg.DataDir != defaultDataDir { if cfg.RPCKey == defaultRPCKeyFile { cfg.RPCKey = filepath.Join(cfg.DataDir, "rpc.key") } if cfg.RPCCert == defaultRPCCertFile { cfg.RPCCert = filepath.Join(cfg.DataDir, "rpc.cert") } } // Choose the active network params based on the selected network. // Multiple networks can't be selected simultaneously. numNets := 0 if cfg.MainNet { activeNet = &mainNetParams numNets++ } if cfg.SimNet { activeNet = &simNetParams numNets++ } if numNets > 1 { str := "%s: The mainnet and simnet params can't be used " + "together -- choose one" err := fmt.Errorf(str, "loadConfig") fmt.Fprintln(os.Stderr, err) parser.WriteHelp(os.Stderr) return nil, nil, err } // Append the network type to the log directory so it is "namespaced" // per network. cfg.LogDir = cleanAndExpandPath(cfg.LogDir) cfg.LogDir = filepath.Join(cfg.LogDir, activeNet.Params.Name) // Special show command to list supported subsystems and exit. if cfg.DebugLevel == "show" { fmt.Println("Supported subsystems", supportedSubsystems()) os.Exit(0) } // Initialize logging at the default logging level. initSeelogLogger(filepath.Join(cfg.LogDir, defaultLogFilename)) setLogLevels(defaultLogLevel) // Parse, validate, and set debug log level(s). if err := parseAndSetDebugLevels(cfg.DebugLevel); err != nil { err := fmt.Errorf("%s: %v", "loadConfig", err.Error()) fmt.Fprintln(os.Stderr, err) parser.WriteHelp(os.Stderr) return nil, nil, err } // Exit if you try to use a simulation wallet with a standard // data directory. if cfg.DataDir == defaultDataDir && cfg.CreateTemp { fmt.Fprintln(os.Stderr, "Tried to create a temporary simulation "+ "wallet, but failed to specify data directory!") os.Exit(0) } // Exit if you try to use a simulation wallet on anything other than // simnet or testnet3. if !cfg.SimNet && cfg.CreateTemp { fmt.Fprintln(os.Stderr, "Tried to create a temporary simulation "+ "wallet for network other than simnet!") os.Exit(0) } // Ensure the wallet exists or create it when the create flag is set. netDir := networkDir(cfg.DataDir, activeNet.Params) dbPath := filepath.Join(netDir, walletDbName) if cfg.CreateTemp && cfg.Create { err := fmt.Errorf("The flags --create and --createtemp can not " + "be specified together. Use --help for more information.") fmt.Fprintln(os.Stderr, err) return nil, nil, err } if cfg.CreateTemp { tempWalletExists := false if fileExists(dbPath) { str := fmt.Sprintf("The wallet already exists. Loading this " + "wallet instead.") fmt.Fprintln(os.Stdout, str) tempWalletExists = true } // Ensure the data directory for the network exists. if err := checkCreateDir(netDir); err != nil { fmt.Fprintln(os.Stderr, err) return nil, nil, err } if !tempWalletExists { // Perform the initial wallet creation wizard. if err := createSimulationWallet(&cfg); err != nil { fmt.Fprintln(os.Stderr, "Unable to create wallet:", err) return nil, nil, err } } } else if cfg.Create { // Error if the create flag is set and the wallet already // exists. if fileExists(dbPath) { err := fmt.Errorf("The wallet already exists.") fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Ensure the data directory for the network exists. if err := checkCreateDir(netDir); err != nil { fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Perform the initial wallet creation wizard. if err := createWallet(&cfg); err != nil { fmt.Fprintln(os.Stderr, "Unable to create wallet:", err) return nil, nil, err } // Created successfully, so exit now with success. os.Exit(0) } else if !fileExists(dbPath) { var err error keystorePath := filepath.Join(netDir, keystore.Filename) if !fileExists(keystorePath) { err = fmt.Errorf("The wallet does not exist. Run with the " + "--create option to initialize and create it.") } else { err = fmt.Errorf("The wallet is in legacy format. Run with the " + "--create option to import it.") } fmt.Fprintln(os.Stderr, err) return nil, nil, err } if cfg.RPCConnect == "" { cfg.RPCConnect = activeNet.connect } // Add default port to connect flag if missing. cfg.RPCConnect = normalizeAddress(cfg.RPCConnect, activeNet.btcdPort) localhostListeners := map[string]struct{}{ "localhost": struct{}{}, "127.0.0.1": struct{}{}, "::1": struct{}{}, } RPCHost, _, err := net.SplitHostPort(cfg.RPCConnect) if err != nil { return nil, nil, err } if cfg.DisableClientTLS { if _, ok := localhostListeners[RPCHost]; !ok { str := "%s: the --noclienttls option may not be used " + "when connecting RPC to non localhost " + "addresses: %s" err := fmt.Errorf(str, funcName, cfg.RPCConnect) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } else { // If CAFile is unset, choose either the copy or local btcd cert. if cfg.CAFile == "" { cfg.CAFile = filepath.Join(cfg.DataDir, defaultCAFilename) // If the CA copy does not exist, check if we're connecting to // a local btcd and switch to its RPC cert if it exists. if !fileExists(cfg.CAFile) { if _, ok := localhostListeners[RPCHost]; ok { if fileExists(btcdHomedirCAFile) { cfg.CAFile = btcdHomedirCAFile } } } } } if len(cfg.SvrListeners) == 0 { addrs, err := net.LookupHost("localhost") if err != nil { return nil, nil, err } cfg.SvrListeners = make([]string, 0, len(addrs)) for _, addr := range addrs { addr = net.JoinHostPort(addr, activeNet.svrPort) cfg.SvrListeners = append(cfg.SvrListeners, addr) } } // Add default port to all rpc listener addresses if needed and remove // duplicate addresses. cfg.SvrListeners = normalizeAddresses(cfg.SvrListeners, activeNet.svrPort) // Only allow server TLS to be disabled if the RPC is bound to localhost // addresses. if cfg.DisableServerTLS { for _, addr := range cfg.SvrListeners { host, _, err := net.SplitHostPort(addr) if err != nil { str := "%s: RPC listen interface '%s' is " + "invalid: %v" err := fmt.Errorf(str, funcName, addr, err) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } if _, ok := localhostListeners[host]; !ok { str := "%s: the --noservertls option may not be used " + "when binding RPC to non localhost " + "addresses: %s" err := fmt.Errorf(str, funcName, addr) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } } // Expand environment variable and leading ~ for filepaths. cfg.CAFile = cleanAndExpandPath(cfg.CAFile) // If the btcd username or password are unset, use the same auth as for // the client. The two settings were previously shared for btcd and // client auth, so this avoids breaking backwards compatibility while // allowing users to use different auth settings for btcd and wallet. if cfg.BtcdUsername == "" { cfg.BtcdUsername = cfg.Username } if cfg.BtcdPassword == "" { cfg.BtcdPassword = cfg.Password } return &cfg, remainingArgs, nil }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in functioning properly without any config settings // while still allowing the user to override settings with config files and // command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ ConfigFile: defaultConfigFile, RPCServer: defaultRPCServer, RPCCert: defaultRPCCertFile, AccessTokenFile: defaultAccessToken, RelayUrl: defaultRelayUrl, } // Create the home directory if it doesn't already exist. err := os.MkdirAll(retweeterHomeDir, 0700) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(-1) } // Pre-parse the command line options to see if an alternative config // file, the version flag, or the list commands flag was specified. Any // errors aside from the help message error can be ignored here since // they will be caught by the final parse below. preCfg := cfg preParser := flags.NewParser(&preCfg, flags.HelpFlag) _, err = preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp { return nil, nil, err } } // Show the version and exit if the version flag was specified. appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show options", appName) // Load additional config from file. parser := flags.NewParser(&cfg, flags.Default) err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintf(os.Stderr, "Error parsing config file: %v\n", err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { fmt.Fprintln(os.Stderr, usageMessage) } return nil, nil, err } // Set activeNet for the application activeNet = chaincfg.MainNetParams if cfg.TestNet3 { activeNet = chaincfg.TestNet3Params } // Handle environment variable expansion in the RPC certificate path. cfg.RPCCert = cleanAndExpandPath(cfg.RPCCert) // Add default port to RPC server based on --testnet and --wallet flags // if needed. cfg.RPCServer = normalizeAddress(cfg.RPCServer, cfg.TestNet3, false, true) hasField("hashtag", cfg.Hashtag) //hasField("sending address", cfg.SendAddress) hasField("consumer key", cfg.ConsumerKey) hasField("consumer secret", cfg.ConsumerSecret) hasField("wallet passphrase", cfg.WalletPassphrase) return &cfg, remainingArgs, nil }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in functioning properly without any config settings // while still allowing the user to override settings with config files and // command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ ConfigFile: defaultConfigFile, RPCServer: defaultRPCServer, RPCCert: defaultRPCCertFile, } // Create the home directory if it doesn't already exist. err := os.MkdirAll(dcrdHomeDir, 0700) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(-1) } // Pre-parse the command line options to see if an alternative config // file, the version flag, or the list commands flag was specified. Any // errors aside from the help message error can be ignored here since // they will be caught by the final parse below. preCfg := cfg preParser := flags.NewParser(&preCfg, flags.HelpFlag) _, err = preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp { fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, "") fmt.Fprintln(os.Stderr, "The special parameter `-` "+ "indicates that a parameter should be read "+ "from the\nnext unread line from standard "+ "input.") return nil, nil, err } } // Load additional config from file. appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show options", appName) parser := flags.NewParser(&cfg, flags.Default) err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintf(os.Stderr, "Error parsing config file: %v\n", err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { fmt.Fprintln(os.Stderr, usageMessage) } return nil, nil, err } // Handle environment variable expansion in the RPC certificate path. cfg.RPCCert = cleanAndExpandPath(cfg.RPCCert) // Add default port to RPC server if needed. cfg.RPCServer = normalizeAddress(cfg.RPCServer) return &cfg, remainingArgs, nil }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in functioning properly without any config settings // while still allowing the user to override settings with config files and // command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ ConfigFile: defaultConfigFile, RPCServer: defaultRPCServer, RPCCert: defaultRPCCertFile, } // Create the home directory if it doesn't already exist. err := os.MkdirAll(btcdHomeDir, 0700) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(-1) } // Pre-parse the command line options to see if an alternative config // file, the version flag, or the list commands flag was specified. Any // errors aside from the help message error can be ignored here since // they will be caught by the final parse below. preCfg := cfg preParser := flags.NewParser(&preCfg, flags.HelpFlag) _, err = preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp { fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, "") fmt.Fprintln(os.Stderr, "The special parameter `-` "+ "indicates that a parameter should be read "+ "from the\nnext unread line from standard "+ "input.") return nil, nil, err } } // Show the version and exit if the version flag was specified. appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show options", appName) if preCfg.ShowVersion { fmt.Println(appName, "version", version()) os.Exit(0) } // Show the available commands and exit if the associated flag was // specified. if preCfg.ListCommands { listCommands() os.Exit(0) } // Load additional config from file. parser := flags.NewParser(&cfg, flags.Default) err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintf(os.Stderr, "Error parsing config file: %v\n", err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { fmt.Fprintln(os.Stderr, usageMessage) } return nil, nil, err } // Multiple networks can't be selected simultaneously. numNets := 0 if cfg.TestNet3 { numNets++ } if cfg.SimNet { numNets++ } if numNets > 1 { str := "%s: The testnet and simnet params can't be used " + "together -- choose one of the two" err := fmt.Errorf(str, "loadConfig") fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Override the RPC certificate if the --wallet flag was specified and // the user did not specify one. if cfg.Wallet && cfg.RPCCert == defaultRPCCertFile { cfg.RPCCert = defaultWalletCertFile } // Handle environment variable expansion in the RPC certificate path. cfg.RPCCert = cleanAndExpandPath(cfg.RPCCert) // Add default port to RPC server based on --testnet and --wallet flags // if needed. cfg.RPCServer = normalizeAddress(cfg.RPCServer, cfg.TestNet3, cfg.SimNet, cfg.Wallet) return &cfg, remainingArgs, nil }
// loadConfig initializes and parses the config using a config file and command // line options. // // The configuration proceeds as follows: // 1) Start with a default config with sane settings // 2) Pre-parse the command line to check for an alternative config file // 3) Load configuration file overwriting defaults with any specified options // 4) Parse CLI options and overwrite/add any specified options // // The above results in daemon functioning properly without any config settings // while still allowing the user to override settings with config files and // command line options. Command line options always take precedence. func loadConfig() (*config, []string, error) { // Default config. cfg := config{ BaseURL: defaultBaseURL, ClosePool: false, ClosePoolMsg: defaultClosePoolMsg, ConfigFile: defaultConfigFile, DebugLevel: defaultLogLevel, DataDir: defaultDataDir, LogDir: defaultLogDir, CookieSecure: defaultCookieSecure, DBHost: defaultDBHost, DBName: defaultDBName, DBPort: defaultDBPort, DBUser: defaultDBUser, Listen: defaultListen, PoolEmail: defaultPoolEmail, PoolFees: defaultPoolFees, PoolLink: defaultPoolLink, PublicPath: defaultPublicPath, TemplatePath: defaultTemplatePath, RecaptchaSecret: defaultRecaptchaSecret, RecaptchaSitekey: defaultRecaptchaSitekey, SMTPHost: defaultSMTPHost, Version: version(), MinServers: defaultMinServers, } // Service options which are only added on Windows. serviceOpts := serviceOptions{} // Pre-parse the command line options to see if an alternative config // file or the version flag was specified. Any errors aside from the // help message error can be ignored here since they will be caught by // the final parse below. preCfg := cfg preParser := newConfigParser(&preCfg, &serviceOpts, flags.HelpFlag) _, err := preParser.Parse() if err != nil { if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp { fmt.Fprintln(os.Stderr, err) return nil, nil, err } } // Show the version and exit if the version flag was specified. appName := filepath.Base(os.Args[0]) appName = strings.TrimSuffix(appName, filepath.Ext(appName)) usageMessage := fmt.Sprintf("Use %s -h to show usage", appName) if preCfg.ShowVersion { fmt.Println(appName, "version", version()) os.Exit(0) } // Perform service command and exit if specified. Invalid service // commands show an appropriate error. Only runs on Windows since // the runServiceCommand function will be nil when not on Windows. if serviceOpts.ServiceCommand != "" && runServiceCommand != nil { err := runServiceCommand(serviceOpts.ServiceCommand) if err != nil { fmt.Fprintln(os.Stderr, err) } os.Exit(0) } // Load additional config from file. var configFileError error parser := newConfigParser(&cfg, &serviceOpts, flags.Default) if !(preCfg.SimNet) || preCfg.ConfigFile != defaultConfigFile { err := flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile) if err != nil { if _, ok := err.(*os.PathError); !ok { fmt.Fprintf(os.Stderr, "Error parsing config "+ "file: %v\n", err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } configFileError = err } } // Parse command line options again to ensure they take precedence. remainingArgs, err := parser.Parse() if err != nil { if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp { fmt.Fprintln(os.Stderr, usageMessage) } return nil, nil, err } // Create the home directory if it doesn't already exist. funcName := "loadConfig" err = os.MkdirAll(dcrstakepoolHomeDir, 0700) if err != nil { // Show a nicer error message if it's because a symlink is // linked to a directory that does not exist (probably because // it's not mounted). if e, ok := err.(*os.PathError); ok && os.IsExist(err) { if link, lerr := os.Readlink(e.Path); lerr == nil { str := "is symlink %s -> %s mounted?" err = fmt.Errorf(str, e.Path, link) } } str := "%s: Failed to create home directory: %v" err := fmt.Errorf(str, funcName, err) fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Multiple networks can't be selected simultaneously. numNets := 0 // Count number of network flags passed; assign active network params // while we're at it activeNetParams = &mainNetParams if cfg.TestNet { numNets++ activeNetParams = &testNetParams } if cfg.SimNet { numNets++ // Also disable dns seeding on the simulation test network. activeNetParams = &simNetParams } if numNets > 1 { str := "%s: The testnet and simnet params can't be " + "used together -- choose one of the three" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Append the network type to the data directory so it is "namespaced" // per network. In addition to the block database, there are other // pieces of data that are saved to disk such as address manager state. // All data is specific to a network, so namespacing the data directory // means each individual piece of serialized data does not have to // worry about changing names per network and such. cfg.DataDir = cleanAndExpandPath(cfg.DataDir) cfg.DataDir = filepath.Join(cfg.DataDir, netName(activeNetParams)) // Append the network type to the log directory so it is "namespaced" // per network in the same fashion as the data directory. cfg.LogDir = cleanAndExpandPath(cfg.LogDir) cfg.LogDir = filepath.Join(cfg.LogDir, netName(activeNetParams)) // Special show command to list supported subsystems and exit. if cfg.DebugLevel == "show" { fmt.Println("Supported subsystems", supportedSubsystems()) os.Exit(0) } // Initialize logging at the default logging level. initSeelogLogger(filepath.Join(cfg.LogDir, defaultLogFilename)) setLogLevels(defaultLogLevel) // Parse, validate, and set debug log level(s). if err := parseAndSetDebugLevels(cfg.DebugLevel); err != nil { err := fmt.Errorf("%s: %v", funcName, err.Error()) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } // Validate profile port number if cfg.Profile != "" { profilePort, err := strconv.Atoi(cfg.Profile) if err != nil || profilePort < 1024 || profilePort > 65535 { str := "%s: The profile port must be between 1024 and 65535" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, usageMessage) return nil, nil, err } } if cfg.APISecret == "" { str := "%s: APIsecret is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if cfg.CookieSecret == "" { str := "%s: cookiesecret is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if cfg.DBPassword == "" { str := "%s: dbpassword is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.ColdWalletExtPub) == 0 { str := "%s: coldwalletextpub is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.AdminIPs) == 0 { str := "%s: adminips is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletHosts) == 0 { str := "%s: wallethosts is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletCerts) == 0 { str := "%s: walletcerts is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletUsers) == 0 { str := "%s: walletusers is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletPasswords) == 0 { str := "%s: walletpasswords is not set in config" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } // Convert comma separated list into a slice cfg.AdminIPs = strings.Split(cfg.AdminIPs[0], ",") cfg.WalletHosts = strings.Split(cfg.WalletHosts[0], ",") cfg.WalletUsers = strings.Split(cfg.WalletUsers[0], ",") cfg.WalletPasswords = strings.Split(cfg.WalletPasswords[0], ",") cfg.WalletCerts = strings.Split(cfg.WalletCerts[0], ",") // Add default wallet port for the active network if there's no port specified cfg.WalletHosts = normalizeAddresses(cfg.WalletHosts, activeNetParams.WalletRPCServerPort) if len(cfg.WalletHosts) < 2 { str := "%s: you must specify at least 2 wallethosts" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletHosts) != len(cfg.WalletUsers) { str := "%s: wallet configuration mismatch (walletusers and wallethosts counts differ)" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletHosts) != len(cfg.WalletPasswords) { str := "%s: wallet configuration mismatch (walletpasswords and wallethosts counts differ)" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } if len(cfg.WalletHosts) != len(cfg.WalletCerts) { str := "%s: wallet configuration mismatch (walletcerts and wallethosts counts differ)" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } for idx := range cfg.WalletCerts { if _, err := os.Stat(cfg.WalletCerts[idx]); os.IsNotExist(err) { if _, err := os.Stat(filepath.Join(dcrstakepoolHomeDir, cfg.WalletCerts[idx])); os.IsNotExist(err) { str := "%s: walletcert " + cfg.WalletCerts[idx] + " and " + filepath.Join(dcrstakepoolHomeDir, cfg.WalletCerts[idx]) + " don't exist" err := fmt.Errorf(str, funcName) fmt.Fprintln(os.Stderr, err) return nil, nil, err } cfg.WalletCerts[idx] = filepath.Join(dcrstakepoolHomeDir, cfg.WalletCerts[idx]) } } // Warn about missing config file only after all other configuration is // done. This prevents the warning on help messages and invalid // options. Note this should go directly before the return. if configFileError != nil { log.Warnf("%v", configFileError) } return &cfg, remainingArgs, nil }