pentapass/cmd/ppass/ppass.go

package main

import (
	"os"
	RPC "net/rpc"

	"github.com/spf13/cobra"

	"github.com/k4lipso/pentapass/internal/rpc"
	"github.com/k4lipso/pentapass/internal/crypto"
	. "github.com/k4lipso/pentapass/internal/log"
)

var (
	dbPath string
	debug bool
	rpcClient *RPC.Client
)


func parseSingleArgWithOptionalVault(args []string) (vault string, arg string){
	if len(args) == 1 {
		vault = "root"
		arg = args[0]
	} else {
		vault = args[0]
		arg = args[1]
	}

	return vault, arg
}


// Create the root command
var rootCmd = &cobra.Command{
	Use:   "ppass",
	Short: "Interact with the Password Store",
}

// Create the 'list' subcommand
var listCmd = &cobra.Command{
	Use:   "list [vault]",
	Short: "List all passwords",
	Args: cobra.RangeArgs(0, 1),
	Run: func(cmd *cobra.Command, args []string) {
		vault := "root"

		if len(args) == 1 {
			vault = args[0]
		}

		var names []string
		err := rpcClient.Call("Query.GetAllNames", &vault, &names)

		if err != nil {
			Logger.Error(err)
		}

		for _, name := range names {
			Logger.Info(name)
		}

	},
}

var generateCmd = &cobra.Command{
	Use:   "generate",
	Short: "Generate a Password",
	Args: cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		vault, serviceName := parseSingleArgWithOptionalVault(args)

		var password *crypto.Password
		np := rpc.VaultService{ Vault: vault, Service: serviceName }
		err := rpcClient.Call("Query.Generate", &np, &password)

		if err != nil {
			Logger.Error(err)
		}

		Logger.Info(password.Password)
	},
}

var showCmd = &cobra.Command{
	Use:   "show",
	Short: "show a Password",
	Args: cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		vault, serviceName := parseSingleArgWithOptionalVault(args)

		var password *crypto.Password
		np := rpc.VaultService{ Vault: vault, Service: serviceName }
		err := rpcClient.Call("Query.Get", &np, &password)

		if err != nil {
			Logger.Error(err)
			return
		}

		Logger.Info(password.Password)
	},
}

var vaultCmd = &cobra.Command{
	Use:   "vault",
	Short: "Add, delete or list vaults",
}

var addVaultCmd = &cobra.Command{
	Use:   "add",
	Short: "add a vault",
	Args: cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		vault := args[0]
		
		var placeholder int
		err := rpcClient.Call("Query.AddVault", &vault, &placeholder)

		if err != nil {
			Logger.Error(err)
			return
		}

		Logger.Infof("Vault %s was added\n", vault)
	},
}

var deleteVaultCmd = &cobra.Command{
	Use:   "delete",
	Short: "delete a vault",
	Args: cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		vault := args[0]

		var placeholder int
		err := rpcClient.Call("Query.DeleteVault", &vault, &placeholder)

		if err != nil {
			Logger.Error(err)
			return
		}

		Logger.Infof("Vault %s was deleted\n", vault)
	},
}

var listVaultsCmd = &cobra.Command{
	Use:   "list",
	Short: "list all vaults",
	Run: func(cmd *cobra.Command, args []string) {
		var reply []string
		err := rpcClient.Call("Query.ListVaults", 0, &reply)

		if err != nil {
			Logger.Error(err)
			return
		}

		Logger.Info("Vaults:")
		for _, ns := range reply {
			Logger.Info(ns)
		}
	},
}

var peerCmd = &cobra.Command{
	Use:   "peer",
	Short: "Add or remove peers. Get your own peering information",
}


var infoCmd = &cobra.Command{
	Use:   "info",
	Short: "print your own peerstring",
	Run: func(cmd *cobra.Command, args []string) {
		var result *string
		err := rpcClient.Call("Query.GetPeerString", 0, &result)

		if err != nil {
			Logger.Error(err)
			return
		}

		Logger.Info(*result)
	},
}


var addPeerCmd = &cobra.Command{
	Use:   "add",
	Short: "add a peer",
	Args: cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		vault, peerString := parseSingleArgWithOptionalVault(args)

		var success *bool
		np := rpc.VaultPeer{ Vault: vault, Peer: peerString }
		err := rpcClient.Call("Query.AddPeer", &np, &success)

		if err != nil {
			Logger.Error(err)
			return
		}

		if *success {
			Logger.Infof("Added peer: %s", peerString)
		} else {
			Logger.Infof("Could not add peer: %s", peerString)
		}
	},
}

var removePeerCmd = &cobra.Command{
	Use:   "remove",
	Short: "remove a peer",
	Args: cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		vault, peerString := parseSingleArgWithOptionalVault(args)

		var success *bool
		np := rpc.VaultPeer{ Vault: vault, Peer: peerString }
		err := rpcClient.Call("Query.DeletePeer", &np, &success)

		if err != nil {
			Logger.Error(err)
			return
		}

		if *success {
			Logger.Infof("Removed peer: %s", peerString)
		} else {
			Logger.Infof("Could not find peer: %s", peerString)
		}
	},
}

var deleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "delete a Password",
	Args: cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		vault, serviceName := parseSingleArgWithOptionalVault(args)

		var success *bool
		np := rpc.VaultService{ Vault: vault, Service: serviceName }
		err := rpcClient.Call("Query.Delete", &np, &success)

		if err != nil {
			Logger.Error(err)
			return
		}

		if *success {
			Logger.Infof("Deleted password: %s", serviceName)
		} else {
			Logger.Infof("Could not find password: %s", serviceName)
		}
	},
}

func init() {
	rootCmd.PersistentFlags().StringVar(&dbPath, "db", "", "db path")
	rootCmd.PersistentFlags().BoolVar(&debug, "debug", false, "enable debug mode")
	rootCmd.MarkPersistentFlagRequired("db")

	peerCmd.AddCommand(addPeerCmd)
	peerCmd.AddCommand(removePeerCmd)
	peerCmd.AddCommand(infoCmd)

	vaultCmd.AddCommand(addVaultCmd)
	vaultCmd.AddCommand(deleteVaultCmd)
	vaultCmd.AddCommand(listVaultsCmd)

	rootCmd.AddCommand(listCmd)
	rootCmd.AddCommand(generateCmd)
	rootCmd.AddCommand(showCmd)
	rootCmd.AddCommand(deleteCmd)
	rootCmd.AddCommand(peerCmd)
	rootCmd.AddCommand(vaultCmd)
}

func main() {
	cobra.OnInitialize(func() { 
		var tmpClient *RPC.Client
		tmpClient, err := rpc.Receive(dbPath)
		rpcClient = tmpClient

		if err != nil {
			Logger.Fatalf("dialing: %s\n", err)
			return
		}

		InitLogger(debug) 
	})
	if err := rootCmd.Execute(); err != nil {
		Logger.Error(err)
		os.Exit(1)
	}
}