pentapass/internal/rpc/rpc.go

package rpc

import (
	"fmt"
	"net"
	"net/rpc"
	"net/http"

  "os"
  "os/signal"
  "syscall"

	"github.com/k4lipso/pentapass/internal/storage"
	"github.com/k4lipso/pentapass/internal/crypto"
	"github.com/k4lipso/pentapass/internal/crypto/age"
	. "github.com/k4lipso/pentapass/internal/log"
)

var StorageHandler *storage.StorageHandler

type Query int

type VaultService struct {
	Vault string
	Service string
}

type VaultPeer struct {
	Vault string
	Peer string
}

func (t *Query) Generate(np *VaultService, reply *crypto.Password) error {
	val, ok := StorageHandler.Vaults[np.Vault]

	if !ok {
		return fmt.Errorf("Vault does not exist")
	}

	password := crypto.NewPassword(crypto.DEFAULT_LENGTH)
	password.Service = np.Service

	data, err := password.ToJson()
	if err != nil {
		return err
	}

	encryptedPassword, err := age.Encrypt(data, val.GetRecipients())
	if err != nil {
		return err
	}
	
	err = val.Put(password.Service, string(encryptedPassword))
	if err != nil {
		return err
	}

	*reply = *password
	return nil
}

func (t *Query) Get(np *VaultService, reply *crypto.Password) error {
	vault := np.Vault
	val, ok := StorageHandler.Vaults[vault]

	if !ok {
		return fmt.Errorf("Vault does not exist")
	}

	v, err := val.GetPassword(np.Service)
	if err != nil {
		return err
	}

	*reply = v
	return nil
}

//func (t *Query) Add(password *crypto.Password, reply *[]string) error {
//	return nil
//}

func (t *Query) GetPeerString(_ *int, result *string) error {
	*result = StorageHandler.Host.ID().String() + "/" + StorageHandler.Key.Recipient().String()
	return nil
}

func (t *Query) AddPeer(np *VaultPeer, success *bool) error {
	vault := np.Vault
	val, ok := StorageHandler.Vaults[vault]

	if !ok {
		return fmt.Errorf("Vault does not exist")
	}

	peer, err := storage.PeerFromString(np.Peer)

	if err != nil {
		Logger.Infof("Error parsing peer string: %s\n", err)
		*success = false
		return err
	}

	val.AddPeer(peer)
	*success = true
	StorageHandler.UpdateConfig()
	return nil
}

func (t *Query) DeletePeer(np *VaultPeer, success *bool) error {
	vault := np.Vault
	val, ok := StorageHandler.Vaults[vault]

	if !ok {
		return fmt.Errorf("Vault does not exist")
	}

	peer, err := storage.PeerFromString(np.Peer)

	if err != nil {
		Logger.Infof("Error parsing peer string: %s\n", err)
		*success = false
		return err
	}

	val.RemovePeer(peer)
	*success = true
	StorageHandler.UpdateConfig()
	return nil
}

func (t *Query) Delete(np *VaultService, success *bool) error {
	vault := np.Vault
	val, ok := StorageHandler.Vaults[vault]

	if !ok {
		return fmt.Errorf("Vault does not exist")
	}

	err := val.Delete(np.Service)
	if err != nil {
		*success = false
		return err
	}

	*success = true
	return nil
}

func (t *Query) AddVault(vault *string, _ *int) error {
	_, err := StorageHandler.AddVault(*vault)
	return err
}

func (t *Query) DeleteVault(vault *string, _ *int) error {
	err := StorageHandler.DeleteVault(*vault)
	return err
}

func (t *Query) ListVaults(_ *int, reply *[]string) error {
	*reply = StorageHandler.ListVaults()
	return nil
}

func (t *Query) GetAllNames(vault *string, reply *[]string) error {
	Logger.Infof("Listing content of %s", *vault)

	val, ok := StorageHandler.Vaults[*vault]

	if !ok {
		return fmt.Errorf("Namesapce does not exist")
	}

	*reply = val.GetAllNames()
	return nil
}

func Serve(path string) {
	query := new(Query)
	rpc.Register(query)
	rpc.HandleHTTP()
	l, err := net.Listen("unix", path + "/rpc_test.socket")

	if err != nil {
		Logger.Errorf("Error while listening on unix socket: %s\n", err)
	}

	go http.Serve(l, nil)

	sigc := make(chan os.Signal, 1)
  signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
  func(ln net.Listener, c chan os.Signal) {
    sig := <-c
    Logger.Infof("Caught signal %s: shutting down.\n", sig)
    ln.Close()
    os.Exit(0)
  }(l, sigc)
}

func Receive(path string) (*rpc.Client, error) {
	client, err := rpc.DialHTTP("unix", path + "/rpc_test.socket")

	if err != nil {
		Logger.Errorf("Cant connect to RPC server: %s\n", err)
	}

	return client, err
}