meowlib/client/peer.go

package client

import (
	"fmt"
	"io"
	"os"
	"time"

	"forge.redroom.link/yves/meowlib"
	"github.com/google/uuid"
	"google.golang.org/protobuf/proto"
)

type Peer struct {
	Name string `json:"name,omitempty"`
	//	Conversation        []InternalMessage `json:"conversation,omitempty"`
	// My own keys for that peer
	MyIdentity     meowlib.KeyPair  `json:"my_identity,omitempty"`
	MyEncryptionKp meowlib.KeyPair  `json:"my_encryption_kp,omitempty"`
	MyLookupKp     meowlib.KeyPair  `json:"my_lookup_kp,omitempty"`
	MyPullServers  []meowlib.Server `json:"my_pull_servers,omitempty"`
	// Peer keys and infos
	Contact      meowlib.ContactCard `json:"contact,omitempty"`
	InvitationId string              `json:"invitation_id,omitempty"`
	// Internal management attributes
	Visible             bool      `json:"visible,omitempty"`
	VisiblePassword     string    `json:"visible_password,omitempty"`
	PasswordType        string    `json:"password_type,omitempty"`
	Blocked             bool      `json:"blocked,omitempty"`
	MessageNotification string    `json:"message_notification,omitempty"`
	OnionMode           bool      `json:"onion_mode,omitempty"`
	LastMessage         time.Time `json:"last_message,omitempty"`
	DbIds               []string  `json:"db_ids,omitempty"`
	DbPassword          string    `json:"db_password,omitempty"`
}

type PeerList []Peer

type Group struct {
	Name    string `json:"name,omitempty"`
	Members []Peer `json:"members,omitempty"`
}

func (pl *PeerList) GetFromPublicKey(publickey string) *Peer {
	for _, peer := range *pl {
		if peer.Contact.ContactPublicKey == publickey {
			return &peer
		}
	}
	return nil
}

func (pl *PeerList) GetFromName(name string) *Peer {
	for _, peer := range *pl {
		if peer.Contact.Name == name {
			return &peer
		}
	}
	return nil
}

func (p *Peer) BuildSimpleUserMessage(message []byte) (*meowlib.UserMessage, error) {
	var msg meowlib.UserMessage
	msg.From = p.MyIdentity.Public
	msg.Data = message
	msg.Type = "1"
	msg.Status = &meowlib.UserMessage_ConversationStatus{}
	msg.Status.LocalUuid = uuid.New().String()
	return &msg, nil
}

func (p *Peer) BuildFileMessage(filename string, message []byte) ([]meowlib.UserMessage, error) {
	var msgs []meowlib.UserMessage
	fi, err := os.Stat(filename)
	if err != nil {
		return nil, err
	}

	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	// declare chunk size
	maxSz := GetConfig().Chunksize

	// create buffer
	b := make([]byte, maxSz)
	chunk := 0
	for {
		// read content to buffer
		readTotal, err := file.Read(b)
		if err != nil {
			if err != io.EOF {
				return nil, err
			}
			break
		}
		var msg meowlib.UserMessage
		msg.From = p.MyIdentity.Public
		msg.File.Filename = fi.Name()
		msg.File.Chunk = uint32(chunk)
		msg.File.Data = b[:readTotal]
		msg.File.Size = uint64(fi.Size())
		msg.Type = "2"
		if chunk == 0 {
			msg.Status = &meowlib.UserMessage_ConversationStatus{}
			msg.Status.LocalUuid = uuid.New().String()
		}
		msgs = append(msgs, msg)
		chunk++
	}
	return msgs, nil
}

func (p *Peer) SerializeUserMessage(msg *meowlib.UserMessage) ([]byte, error) {
	out, err := proto.Marshal(msg)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AsymEncryptMessage prepares a message to send to a specific peer contact
func (p *Peer) AsymEncryptMessage(Message []byte) (EncryptedMessage []byte, Signature []byte, Servers []*meowlib.Server, err error) {
	EncryptedMessage, Signature, err = meowlib.AsymEncryptAndSign(p.Contact.EncryptionPublicKey, p.MyIdentity.Private, Message)
	if err != nil {
		fmt.Println(err.Error())
		return nil, nil, nil, err
	}
	return EncryptedMessage, Signature, p.Contact.PullServers, err
}

// AsymDecryptMessage reads a message from a specific peer contact
func (p *Peer) AsymDecryptMessage(Message []byte, Signature []byte) (DecryptedMessage []byte, err error) {
	DecryptedMessage, err = meowlib.AsymDecryptAndCheck(p.MyIdentity.Private, p.Contact.ContactPublicKey, Message, Signature)
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	return DecryptedMessage, err
}

// PackUserMessage will package the previously encrypted message for sending it to the peer in protobuff format
func (p *Peer) PackUserMessage(message []byte, signature []byte) meowlib.PackedUserMessage {
	var msg meowlib.PackedUserMessage
	msg.Destination = p.Contact.LookupPublicKey
	msg.Payload = message
	msg.Signature = signature
	return msg
}

func (ints *InternalServer) UnPackUserMessage(protoPackedMessage []byte) (payload []byte, signature []byte, err error) {
	msg := &meowlib.PackedServerMessage{}
	if err := proto.Unmarshal(protoPackedMessage, msg); err != nil {
		return nil, nil, err
	}
	return msg.Payload, msg.Signature, nil
}

func (p *Peer) GetConversationRequest() meowlib.ToServerMessage_ConversationRequest {
	var cr meowlib.ToServerMessage_ConversationRequest
	return cr
}

func (p *Peer) StoreMessage(msg []byte) {

}

func (p *Peer) LoadMessage(uid string) {

}

func (p *Peer) LoadLastMessages(qty int) {

}

func (p *Peer) GetLastMessageUuid(msg []byte) {

}