schastsp/client/client.go

package client

import (
	"errors"
	"fmt"
	"git.xdrm.io/schastsp/internal/keyset"
	"git.xdrm.io/schastsp/context"
	"git.xdrm.io/schastsp/internal/scha"
	"io"
)

const DEBUG = false

/* (1) Structure
---------------------------------------------------------*/
type T struct {
	ctx      *context.T // shared context
	key      *keyset.T  // current key
	sync     *keyset.T  // next bufferised key
	fkey     *config    // key file management
	fsync    *config    // sync file management
}

/* (2) Constructor
*
* @ctx<context.T>					Shared context
* @saveDir<string>					Configuration path
*
---------------------------------------------------------*/
func New(ctx *context.T, saveDir string) (*T, error) {

	var err error

	inst := new(T)

	/* (1) Store context */
	if ctx == nil { return nil, errors.New("Context must not be nil"); }
	inst.ctx = ctx

	/* (2) Get file management for KEY */
	inst.fkey, err = Config(saveDir, "key")
	if err != nil { return nil, err }

	/* (3) Get file management for SYNC */
	inst.fsync, err = Config(saveDir, "sync")
	if err != nil { return nil, err }

	/* (4) Restore from config */
	inst.updateConfig()

	return inst, nil

}

/* (3) Processes and sends a new request
*
* @w<io.Writer>						Writer to send into
*
* @return err<error>				Error
*
---------------------------------------------------------*/
func (c *T) Send(w io.Writer) error {

	/* (1) Generate the request */
	x1 := make([]byte, scha.HSIZE)
	x2 := make([]byte, scha.HSIZE)

	err := c.generateRequest(x1, x2)
	if err != nil { return err }

	/* (2) Write request into writer */
	written, err := w.Write(x1)
	if err != nil { return err }
	if written != len(x1) { return errors.New("Cannot write x1") }

	written, err = w.Write(x2)
	if err != nil { return err }
	if written != len(x1) { return errors.New("Cannot write x2") }

	return nil
}

/* (4) Receives and processes a response
*
* @w<io.Reader>						Reader to receive from
*
* @return err<error>				Error
*
---------------------------------------------------------*/
func (c *T) Receive(r io.Reader) error {

	/* (1) Read error code
	---------------------------------------------------------*/
	errCode := make([]byte, 1)
	read, err := r.Read(errCode)
	if err != nil { return err }
	if uint16(read) != 1 { return errors.New("Cannot read error code") }

	if DEBUG { fmt.Printf("ERROR CODE : %d\n", errCode[0]) }

	/* (2) Manage success
	---------------------------------------------------------*/
	if errCode[0] == 0 {

		/* (1) If pending migration -> migrate */
		if c.key.MigrationCode() == 2 {
			c.migrateKey()
			if DEBUG { fmt.Printf("*** VALIDATED MIGRATION\n") }
		}

		/* (2) No error anyway */
		return nil

	}

	/* (3) Manage rescue
	---------------------------------------------------------*/
	/* (1) Read y1 */
	y1 := make([]byte, scha.HSIZE)
	read, err = r.Read(y1)
	if err != nil { return err }
	if uint16(read) != scha.HSIZE { return errors.New("Cannot read y1") }

	/* (2) Read y2 */
	y2 := make([]byte, scha.HSIZE)
	read, err = r.Read(y2)
	if err != nil { return err }
	if uint16(read) != scha.HSIZE { return errors.New("Cannot read enough y2") }

	/* (3) Manage rescue mode */
	err = c.rescue(y1, y2)
	if err != nil { return err }

	if DEBUG { fmt.Printf("*** MIGRATION PREPARED\n") }

	return nil

}




/* (5) Returns a synchronisation key (first server connection)
*
* @return key<[]byte>				Synchronisation key
* @return err<error>
*
---------------------------------------------------------*/
func (c *T) SynchronisationKey() ([]byte, error) {

	/* (1) Reset keys so no value can be guessed*/
	c.migrateKey(); // 1: copies 'sync' into 'key'
	c.migrateKey(); // 2: copies random new 'sync' into 'key' (old 'sync)

	/* (2) Get current hash */
	hash, err := c.key.CurrentHash()
	if err != nil { return nil, err }

	/* (3) Decrement key so 'hash' is valid */
	c.key.Decrement()

	/* (4) Return key */
	return hash, nil;
}