mv rpc -> internal/rpc

internal/rpc/rpc.go

@@ -0,0 +1,208 @@
+package rpc
+
+import (
+	"fmt"
+	"net"
+	"net/rpc"
+	"net/http"
+
+  "os"
+  "os/signal"
+  "syscall"
+
+	"github.com/k4lipso/pentapass/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 NamespaceService struct {
+	Namespace string
+	Service string
+}
+
+type NamespacePeer struct {
+	Namespace string
+	Peer string
+}
+
+func (t *Query) Generate(np *NamespaceService, reply *crypto.Password) error {
+	val, ok := StorageHandler.Namespaces[np.Namespace]
+
+	if !ok {
+		return fmt.Errorf("Namespace 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 *NamespaceService, reply *crypto.Password) error {
+	namespace := np.Namespace
+	val, ok := StorageHandler.Namespaces[namespace]
+
+	if !ok {
+		return fmt.Errorf("Namespace 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 *NamespacePeer, success *bool) error {
+	namespace := np.Namespace
+	val, ok := StorageHandler.Namespaces[namespace]
+
+	if !ok {
+		return fmt.Errorf("Namespace 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 *NamespacePeer, success *bool) error {
+	namespace := np.Namespace
+	val, ok := StorageHandler.Namespaces[namespace]
+
+	if !ok {
+		return fmt.Errorf("Namespace 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 *NamespaceService, success *bool) error {
+	namespace := np.Namespace
+	val, ok := StorageHandler.Namespaces[namespace]
+
+	if !ok {
+		return fmt.Errorf("Namespace does not exist")
+	}
+
+	err := val.Delete(np.Service)
+	if err != nil {
+		*success = false
+		return err
+	}
+
+	*success = true
+	return nil
+}
+
+func (t *Query) AddNamespace(namespace *string, _ *int) error {
+	_, err := StorageHandler.AddNamespace(*namespace)
+	return err
+}
+
+func (t *Query) DeleteNamespace(namespace *string, _ *int) error {
+	err := StorageHandler.DeleteNamespace(*namespace)
+	return err
+}
+
+func (t *Query) ListNamespaces(_ *int, reply *[]string) error {
+	*reply = StorageHandler.ListNamespaces()
+	return nil
+}
+
+func (t *Query) GetAllNames(namespace *string, reply *[]string) error {
+	Logger.Infof("Listing content of %s", *namespace)
+
+	val, ok := StorageHandler.Namespaces[*namespace]
+
+	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
+}