func (c *initCmd) RunCommand(args []string) error { if len(args) > 0 { return cmdmain.ErrUsage } if c.newKey && c.keyId != "" { log.Fatal("--newkey and --gpgkey are mutually exclusive") } if c.userPass != "" { cc, err := c.clientConfigFromServer() if err != nil { return err } return c.writeConfig(cc) } var err error if c.newKey { c.secretRing = osutil.DefaultSecretRingFile() c.keyId, err = jsonsign.GenerateNewSecRing(c.secretRing) if err != nil { return err } } else { if err := c.initSecretRing(); err != nil { return err } if err := c.initKeyId(); err != nil { return err } } pubArmor, err := c.getPublicKeyArmored() if err != nil { return err } bref := blob.SHA1FromString(string(pubArmor)) log.Printf("Your Camlistore identity (your GPG public key's blobref) is: %s", bref.String()) if c.noconfig { return nil } return c.writeConfig(&clientconfig.Config{ Servers: map[string]*clientconfig.Server{ "localhost": { Server: "http://localhost:3179", IsDefault: true, Auth: "localhost", }, }, Identity: c.keyId, IgnoredFiles: []string{".DS_Store"}, }) }
func newDefaultConfigFile(path string) error { conf := defaultConfigFile{ Listen: defaultListenAddr, HTTPS: false, Auth: "localhost", ReplicateTo: make([]interface{}, 0), } blobDir := osutil.CamliBlobRoot() if err := os.MkdirAll(blobDir, 0700); err != nil { return fmt.Errorf("Could not create default blobs directory: %v", err) } conf.BlobPath = blobDir if sqlite.CompiledIn() { conf.SQLite = filepath.Join(osutil.CamliVarDir(), "camli-index.db") if fi, err := os.Stat(conf.SQLite); os.IsNotExist(err) || (fi != nil && fi.Size() == 0) { if err := initSQLiteDB(conf.SQLite); err != nil { log.Printf("Error initializing DB %s: %v", conf.SQLite, err) } } } else { conf.KVFile = filepath.Join(osutil.CamliVarDir(), "camli-index.kvdb") } var keyId string secRing := osutil.IdentitySecretRing() _, err := os.Stat(secRing) switch { case err == nil: keyId, err = jsonsign.KeyIdFromRing(secRing) if err != nil { return fmt.Errorf("Could not find any keyId in file %q: %v", secRing, err) } log.Printf("Re-using identity with keyId %q found in file %s", keyId, secRing) case os.IsNotExist(err): keyId, err = jsonsign.GenerateNewSecRing(secRing) if err != nil { return fmt.Errorf("Could not generate new secRing at file %q: %v", secRing, err) } log.Printf("Generated new identity with keyId %q in file %s", keyId, secRing) } if err != nil { return fmt.Errorf("Could not stat secret ring %q: %v", secRing, err) } conf.Identity = keyId conf.IdentitySecretRing = secRing confData, err := json.MarshalIndent(conf, "", " ") if err != nil { return fmt.Errorf("Could not json encode config file : %v", err) } if err := ioutil.WriteFile(path, confData, 0600); err != nil { return fmt.Errorf("Could not create or write default server config: %v", err) } return nil }
func newDefaultConfigFile(path string) error { conf := defaultConfigFile{ Listen: ":3179", HTTPS: false, Auth: "localhost", ReplicateTo: make([]interface{}, 0), } blobDir := osutil.CamliBlobRoot() if err := os.MkdirAll(blobDir, 0700); err != nil { return fmt.Errorf("Could not create default blobs directory: %v", err) } conf.BlobPath = blobDir conf.SQLite = filepath.Join(osutil.CamliVarDir(), "camli-index.db") var keyId string secRing := osutil.IdentitySecretRing() _, err := os.Stat(secRing) switch { case err == nil: keyId, err = jsonsign.KeyIdFromRing(secRing) log.Printf("Re-using identity with keyId %q found in file %s", keyId, secRing) case os.IsNotExist(err): keyId, err = jsonsign.GenerateNewSecRing(secRing) log.Printf("Generated new identity with keyId %q in file %s", keyId, secRing) } if err != nil { return fmt.Errorf("Secret ring: %v", err) } conf.Identity = keyId conf.IdentitySecretRing = secRing confData, err := json.MarshalIndent(conf, "", " ") if err != nil { return fmt.Errorf("Could not json encode config file : %v", err) } if err := ioutil.WriteFile(path, confData, 0600); err != nil { return fmt.Errorf("Could not create or write default server config: %v", err) } if sqlite.CompiledIn() { if fi, err := os.Stat(conf.SQLite); os.IsNotExist(err) || (fi != nil && fi.Size() == 0) { if err := initSQLiteDB(conf.SQLite); err != nil { log.Printf("Error initializing DB %s: %v", conf.SQLite, err) } } } else { log.Printf("Wrote config file assuming SQLite, but SQLite is not available. Recompile with SQLite or modify %s and pick an index type. Please see http://camlistore.org/docs/server-config#windows", path) return errors.New("Newly written configuration not usable.") } return nil }
func getOrMakeKeyring() (keyID string, err error) { _, err = wkfs.Stat(secRing) switch { case err == nil: keyID, err = jsonsign.KeyIdFromRing(secRing) if err != nil { err = fmt.Errorf("Could not find any keyID in file %q: %v", secRing, err) return } log.Printf("Re-using identity with keyID %q found in file %s", keyID, secRing) case os.IsNotExist(err): keyID, err = jsonsign.GenerateNewSecRing(secRing) if err != nil { err = fmt.Errorf("Could not generate new secRing at file %q: %v", secRing, err) return } log.Printf("Generated new identity with keyID %q in file %s", keyID, secRing) default: err = fmt.Errorf("Could not stat secret ring %q: %v", secRing, err) } return }
func (c *initCmd) RunCommand(args []string) error { if len(args) > 0 { return cmdmain.ErrUsage } if c.newKey && c.gpgkey != "" { log.Fatal("--newkey and --gpgkey are mutually exclusive") } blobDir := osutil.KeyBlobsDir() if err := os.MkdirAll(blobDir, 0700); err != nil { return err } var keyId string var err error secRing := osutil.IdentitySecretRing() if c.newKey { keyId, err = jsonsign.GenerateNewSecRing(secRing) if err != nil { return err } } else { keyId, err = c.keyId(secRing) if err != nil { return err } } pubArmor, err := c.getPublicKeyArmored(keyId) if err != nil { return err } bref := blob.SHA1FromString(string(pubArmor)) keyBlobPath := path.Join(blobDir, bref.String()+".camli") if err = ioutil.WriteFile(keyBlobPath, pubArmor, 0644); err != nil { log.Fatalf("Error writing public key blob to %q: %v", keyBlobPath, err) } if ok, err := jsonsign.VerifyPublicKeyFile(keyBlobPath, keyId); !ok { log.Fatalf("Error verifying public key at %q: %v", keyBlobPath, err) } log.Printf("Your Camlistore identity (your GPG public key's blobref) is: %s", bref.String()) if c.noconfig { return nil } configFilePath := osutil.UserClientConfigPath() _, err = os.Stat(configFilePath) if err == nil { log.Fatalf("Config file %q already exists; quitting without touching it.", configFilePath) } if f, err := os.OpenFile(configFilePath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600); err == nil { defer f.Close() m := &clientconfig.Config{ Servers: map[string]*clientconfig.Server{ "localhost": { Server: "http://localhost:3179", IsDefault: true, Auth: "localhost", }, }, Identity: keyId, IgnoredFiles: []string{".DS_Store"}, } jsonBytes, err := json.MarshalIndent(m, "", " ") if err != nil { log.Fatalf("JSON serialization error: %v", err) } _, err = f.Write(jsonBytes) if err != nil { log.Fatalf("Error writing to %q: %v", configFilePath, err) } log.Printf("Wrote %q; modify as necessary.", configFilePath) } return nil }
func (c *initCmd) RunCommand(args []string) error { if len(args) > 0 { return cmdmain.ErrUsage } if c.newKey && c.gpgkey != "" { log.Fatal("--newkey and --gpgkey are mutually exclusive") } blobDir := path.Join(osutil.CamliConfigDir(), "keyblobs") os.Mkdir(osutil.CamliConfigDir(), 0700) os.Mkdir(blobDir, 0700) var keyId string var err error secRing := osutil.IdentitySecretRing() if c.newKey { keyId, err = jsonsign.GenerateNewSecRing(secRing) if err != nil { return err } } else { keyId, err = c.keyId(secRing) if err != nil { return err } } if os.Getenv("GPG_AGENT_INFO") == "" { log.Printf("No GPG_AGENT_INFO found in environment; you should setup gnupg-agent. camput might be annoying otherwise, if your private key is encrypted.") } pubArmor, err := c.getPublicKeyArmored(keyId) if err != nil { return err } bref := blobref.SHA1FromString(string(pubArmor)) keyBlobPath := path.Join(blobDir, bref.String()+".camli") if err = ioutil.WriteFile(keyBlobPath, pubArmor, 0644); err != nil { log.Fatalf("Error writing public key blob to %q: %v", keyBlobPath, err) } if ok, err := jsonsign.VerifyPublicKeyFile(keyBlobPath, keyId); !ok { log.Fatalf("Error verifying public key at %q: %v", keyBlobPath, err) } log.Printf("Your Camlistore identity (your GPG public key's blobref) is: %s", bref.String()) configFilePath := osutil.UserClientConfigPath() _, err = os.Stat(configFilePath) if err == nil { log.Fatalf("Config file %q already exists; quitting without touching it.", configFilePath) } if f, err := os.OpenFile(configFilePath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600); err == nil { defer f.Close() m := make(map[string]interface{}) m["keyId"] = keyId // TODO(bradfitz): make this 'identity' to match server config? m["publicKeyBlobref"] = bref.String() // TODO(bradfitz): not used anymore? m["server"] = "http://localhost:3179/" m["selfPubKeyDir"] = blobDir m["auth"] = "localhost" jsonBytes, err := json.MarshalIndent(m, "", " ") if err != nil { log.Fatalf("JSON serialization error: %v", err) } _, err = f.Write(jsonBytes) if err != nil { log.Fatalf("Error writing to %q: %v", configFilePath, err) } log.Printf("Wrote %q; modify as necessary.", configFilePath) } return nil }
func (c *initCmd) RunCommand(args []string) error { if len(args) > 0 { return cmdmain.ErrUsage } var err error if c.dumpJSON { type jsonConfig struct { Identity_secring *jsonsign.IdentitySecring Client_config *clientconfig.Config Server_config *serverconfig.Config } var config jsonConfig // generate a new secring struct config.Identity_secring, err = jsonsign.GenerateNewSecRingStruct() if err != nil { return err } c.keyId = config.Identity_secring.KeyId // generate a new server config struct config.Server_config = GenerateServerConfig(c.keyId) // generate a new client config struct config.Client_config = GenerateClientConfig(c.keyId) jsonBytes, err := json.MarshalIndent(config, "", " ") if err != nil { log.Fatalf("JSON serialization error: %v", err) } //log.Printf("%+#v\n", string(jsonBytes)) _, err = os.Stdout.Write(jsonBytes) return err } if c.newKey && c.keyId != "" { log.Fatal("--newkey and --gpgkey are mutually exclusive") } if c.newKey { c.secretRing = osutil.DefaultSecretRingFile() c.keyId, err = jsonsign.GenerateNewSecRing(c.secretRing) if err != nil { return err } } else { if err := c.initSecretRing(); err != nil { return err } if err := c.initKeyId(); err != nil { return err } } pubArmor, err := c.getPublicKeyArmored() if err != nil { return err } bref := blob.SHA1FromString(string(pubArmor)) log.Printf("Your Camlistore identity (your GPG public key's blobref) is: %s", bref.String()) if c.noconfig { return nil } configFilePath := osutil.UserClientConfigPath() _, err = os.Stat(configFilePath) if err == nil { log.Fatalf("Config file %q already exists; quitting without touching it.", configFilePath) } if err := os.MkdirAll(filepath.Dir(configFilePath), 0700); err != nil { return err } if f, err := os.OpenFile(configFilePath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600); err == nil { defer f.Close() // refactored to a service routine m := GenerateClientConfig(c.keyId) jsonBytes, err := json.MarshalIndent(m, "", " ") if err != nil { log.Fatalf("JSON serialization error: %v", err) } _, err = f.Write(jsonBytes) if err != nil { log.Fatalf("Error writing to %q: %v", configFilePath, err) } log.Printf("Wrote %q; modify as necessary.", configFilePath) } else { return fmt.Errorf("could not write client config file %v: %v", configFilePath, err) } return nil }