// Copyright 2009 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// SRPC constants, data structures, and parsing.

package srpc

import (
	"math";
	"os";
	"strconv";
	"syscall";
	"unsafe";
)

// An Errno is an SRPC status code.
type Errno uint32

const (
	OK	Errno	= 256 + iota;
	ErrBreak;
	ErrMessageTruncated;
	ErrNoMemory;
	ErrProtocolMismatch;
	ErrBadRPCNumber;
	ErrBadArgType;
	ErrTooFewArgs;
	ErrTooManyArgs;
	ErrInArgTypeMismatch;
	ErrOutArgTypeMismatch;
	ErrInternalError;
	ErrAppError;
)

var errstr = [...]string{
	OK - OK: "ok",
	ErrBreak - OK: "break",
	ErrMessageTruncated - OK: "message truncated",
	ErrNoMemory - OK: "out of memory",
	ErrProtocolMismatch - OK: "protocol mismatch",
	ErrBadRPCNumber - OK: "invalid RPC method number",
	ErrBadArgType - OK: "unexpected argument type",
	ErrTooFewArgs - OK: "too few arguments",
	ErrTooManyArgs - OK: "too many arguments",
	ErrInArgTypeMismatch - OK: "input argument type mismatch",
	ErrOutArgTypeMismatch - OK: "output argument type mismatch",
	ErrInternalError - OK: "internal error",
	ErrAppError - OK: "application error",
}

func (e Errno) String() string {
	if e < OK || int(e-OK) >= len(errstr) {
		return "Errno(" + strconv.Itoa64(int64(e)) + ")"
	}
	return errstr[e-OK];
}

// A *msgHdr is the data argument to the imc_recvmsg
// and imc_sendmsg system calls.  Because it contains unchecked
// counts trusted by the system calls, the data structure is unsafe
// to expose to package clients.
type msgHdr struct {
	iov	*iov;
	niov	int32;
	desc	*int32;
	ndesc	int32;
	flags	uint32;
}

// A single region for I/O.  Just as unsafe as msgHdr.
type iov struct {
	base	*byte;
	len	int32;
}

// A msg is the Go representation of a message.
type msg struct {
	rdata	[]byte;		// data being consumed during message parsing
	rdesc	[]int32;	// file descriptors being consumed during message parsing
	wdata	[]byte;		// data being generated when replying

	// parsed version of message
	protocol	uint32;
	requestId	uint64;
	isReq		bool;
	rpcNumber	uint32;
	gotHeader	bool;
	status		Errno;		// error code sent in response
	Arg		[]interface{};	// method arguments
	Ret		[]interface{};	// method results
	Size		[]int;		// max sizes for arrays in method results
	fmt		string;		// accumulated format string of arg+":"+ret
}

// A msgReceiver receives messages from a file descriptor.
type msgReceiver struct {
	fd	int;
	data	[128 * 1024]byte;
	desc	[8]int32;
	hdr	msgHdr;
	iov	iov;
}

func (r *msgReceiver) recv() (*msg, os.Error) {
	// Init pointers to buffers where syscall recvmsg can write.
	r.iov.base = &r.data[0];
	r.iov.len = int32(len(r.data));
	r.hdr.iov = &r.iov;
	r.hdr.niov = 1;
	r.hdr.desc = &r.desc[0];
	r.hdr.ndesc = int32(len(r.desc));
	n, _, e := syscall.Syscall(syscall.SYS_IMC_RECVMSG, uintptr(r.fd), uintptr(unsafe.Pointer(&r.hdr)), 0);
	if e != 0 {
		return nil, os.NewSyscallError("imc_recvmsg", int(e))
	}

	// Make a copy of the data so that the next recvmsg doesn't
	// smash it.  The system call did not update r.iov.len.  Instead it
	// returned the total byte count as n.
	m := new(msg);
	m.rdata = make([]byte, n);
	copy(m.rdata, &r.data);

	// Make a copy of the desc too.
	// The system call *did* update r.hdr.ndesc.
	if r.hdr.ndesc > 0 {
		m.rdesc = make([]int32, r.hdr.ndesc);
		for i := range m.rdesc {
			m.rdesc[i] = r.desc[i]
		}
	}

	return m, nil;
}

// A msgSender sends messages on a file descriptor.
type msgSender struct {
	fd	int;
	hdr	msgHdr;
	iov	iov;
}

func (s *msgSender) send(m *msg) os.Error {
	if len(m.wdata) > 0 {
		s.iov.base = &m.wdata[0]
	}
	s.iov.len = int32(len(m.wdata));
	s.hdr.iov = &s.iov;
	s.hdr.niov = 1;
	s.hdr.desc = nil;
	s.hdr.ndesc = 0;
	_, _, e := syscall.Syscall(syscall.SYS_IMC_SENDMSG, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0);
	if e != 0 {
		return os.NewSyscallError("imc_sendmsg", int(e))
	}
	return nil;
}

// Reading from msg.rdata.
func (m *msg) uint8() uint8 {
	if m.status != OK {
		return 0
	}
	if len(m.rdata) < 1 {
		m.status = ErrMessageTruncated;
		return 0;
	}
	x := m.rdata[0];
	m.rdata = m.rdata[1:];
	return x;
}

func (m *msg) uint32() uint32 {
	if m.status != OK {
		return 0
	}
	if len(m.rdata) < 4 {
		m.status = ErrMessageTruncated;
		return 0;
	}
	b := m.rdata[0:4];
	x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24;
	m.rdata = m.rdata[4:];
	return x;
}

func (m *msg) uint64() uint64 {
	if m.status != OK {
		return 0
	}
	if len(m.rdata) < 8 {
		m.status = ErrMessageTruncated;
		return 0;
	}
	b := m.rdata[0:8];
	x := uint64(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24);
	x |= uint64(uint32(b[4])|uint32(b[5])<<8|uint32(b[6])<<16|uint32(b[7])<<24) << 32;
	m.rdata = m.rdata[8:];
	return x;
}

func (m *msg) bytes(n int) []byte {
	if m.status != OK {
		return nil
	}
	if len(m.rdata) < n {
		m.status = ErrMessageTruncated;
		return nil;
	}
	x := m.rdata[0:n];
	m.rdata = m.rdata[n:];
	return x;
}

// Writing to msg.wdata.
func (m *msg) grow(n int) []byte {
	i := len(m.wdata);
	if i+n > cap(m.wdata) {
		a := make([]byte, i, (i+n)*2);
		copy(a, m.wdata);
		m.wdata = a;
	}
	m.wdata = m.wdata[0 : i+n];
	return m.wdata[i : i+n];
}

func (m *msg) wuint8(x uint8)	{ m.grow(1)[0] = x }

func (m *msg) wuint32(x uint32) {
	b := m.grow(4);
	b[0] = byte(x);
	b[1] = byte(x >> 8);
	b[2] = byte(x >> 16);
	b[3] = byte(x >> 24);
}

func (m *msg) wuint64(x uint64) {
	b := m.grow(8);
	lo := uint32(x);
	b[0] = byte(lo);
	b[1] = byte(lo >> 8);
	b[2] = byte(lo >> 16);
	b[3] = byte(lo >> 24);
	hi := uint32(x >> 32);
	b[4] = byte(hi);
	b[5] = byte(hi >> 8);
	b[6] = byte(hi >> 16);
	b[7] = byte(hi >> 24);
}

func (m *msg) wbytes(p []byte)	{ copy(m.grow(len(p)), p) }

func (m *msg) wstring(s string) {
	b := m.grow(len(s));
	for i := range b {
		b[i] = s[i]
	}
}

// Parsing of RPC header and arguments.
//
// The header format is:
//	protocol uint32;
//	requestId uint64;
//	isReq bool;
//	rpcNumber uint32;
//	status uint32;  // only for response
//
// Then a sequence of values follow, preceded by the length:
//	nvalue uint32;
//
// Each value begins with a one-byte type followed by
// type-specific data.
//
//	type uint8;
//	'b':	x bool;
//	'C':	len uint32; x [len]byte;
//	'd':	x float64;
//	'D':	len uint32; x [len]float64;
//	'h':	x int;	// handle aka file descriptor
//	'i':	x int32;
//	'I':	len uint32; x [len]int32;
//	's':	len uint32; x [len]byte;
//
// If this is a request, a sequence of pseudo-values follows,
// preceded by its length (nvalue uint32).
//
// Each pseudo-value is a one-byte type as above,
// followed by a maximum length (len uint32)
// for the 'C', 'D', 'I', and 's' types.
//
// In the Go msg, we represent each argument by
// an empty interface containing the type of x in the
// corresponding case.

// The current protocol number.
const protocol = 0xc0da0002

func (m *msg) unpackHeader() {
	m.protocol = m.uint32();
	m.requestId = m.uint64();
	m.isReq = m.uint8() != 0;
	m.rpcNumber = m.uint32();
	m.gotHeader = m.status == OK;	// signal that header parsed successfully
	if m.gotHeader && !m.isReq {
		status := Errno(m.uint32());
		m.gotHeader = m.status == OK;	// still ok?
		if m.gotHeader {
			m.status = status
		}
	}
}

func (m *msg) packHeader() {
	m.wuint32(m.protocol);
	m.wuint64(m.requestId);
	if m.isReq {
		m.wuint8(1)
	} else {
		m.wuint8(0)
	}
	m.wuint32(m.rpcNumber);
	if !m.isReq {
		m.wuint32(uint32(m.status))
	}
}

func (m *msg) unpackValues(v []interface{}) {
	for i := range v {
		t := m.uint8();
		m.fmt += string(t);
		switch t {
		default:
			if m.status == OK {
				m.status = ErrBadArgType
			}
			return;
		case 'b':	// bool[1]
			v[i] = m.uint8() > 0
		case 'C':	// char array
			v[i] = m.bytes(int(m.uint32()))
		case 'd':	// double
			v[i] = math.Float64frombits(m.uint64())
		case 'D':	// double array
			a := make([]float64, int(m.uint32()));
			for j := range a {
				a[j] = math.Float64frombits(m.uint64())
			}
			v[i] = a;
		case 'h':	// file descriptor (handle)
			if len(m.rdesc) == 0 {
				if m.status == OK {
					m.status = ErrBadArgType
				}
				return;
			}
			v[i] = int(m.rdesc[0]);
			m.rdesc = m.rdesc[1:];
		case 'i':	// int
			v[i] = int32(m.uint32())
		case 'I':	// int array
			a := make([]int32, int(m.uint32()));
			for j := range a {
				a[j] = int32(m.uint32())
			}
			v[i] = a;
		case 's':	// string
			v[i] = string(m.bytes(int(m.uint32())))
		}
	}
}

func (m *msg) packValues(v []interface{}) {
	for i := range v {
		switch x := v[i].(type) {
		default:
			if m.status == OK {
				m.status = ErrInternalError
			}
			return;
		case bool:
			m.wuint8('b');
			if x {
				m.wuint8(1)
			} else {
				m.wuint8(0)
			}
		case []byte:
			m.wuint8('C');
			m.wuint32(uint32(len(x)));
			m.wbytes(x);
		case float64:
			m.wuint8('d');
			m.wuint64(math.Float64bits(x));
		case []float64:
			m.wuint8('D');
			m.wuint32(uint32(len(x)));
			for _, f := range x {
				m.wuint64(math.Float64bits(f))
			}
		case int32:
			m.wuint8('i');
			m.wuint32(uint32(x));
		case []int32:
			m.wuint8('I');
			m.wuint32(uint32(len(x)));
			for _, i := range x {
				m.wuint32(uint32(i))
			}
		case string:
			m.wuint8('s');
			m.wuint32(uint32(len(x)));
			m.wstring(x);
		}
	}
}

func (m *msg) unpackRequest() {
	m.status = OK;
	if m.unpackHeader(); m.status != OK {
		return
	}
	if m.protocol != protocol || !m.isReq {
		m.status = ErrProtocolMismatch;
		return;
	}

	// type-tagged argument values
	m.Arg = make([]interface{}, m.uint32());
	m.unpackValues(m.Arg);
	if m.status != OK {
		return
	}

	// type-tagged expected return sizes.
	// fill in zero values for each return value
	// and save sizes.
	m.fmt += ":";
	m.Ret = make([]interface{}, m.uint32());
	m.Size = make([]int, len(m.Ret));
	for i := range m.Ret {
		t := m.uint8();
		m.fmt += string(t);
		switch t {
		default:
			if m.status == OK {
				m.status = ErrBadArgType
			}
			return;
		case 'b':	// bool[1]
			m.Ret[i] = false
		case 'C':	// char array
			m.Size[i] = int(m.uint32());
			m.Ret[i] = []byte(nil);
		case 'd':	// double
			m.Ret[i] = float64(0)
		case 'D':	// double array
			m.Size[i] = int(m.uint32());
			m.Ret[i] = []float64(nil);
		case 'h':	// file descriptor (handle)
			m.Ret[i] = int(-1)
		case 'i':	// int
			m.Ret[i] = int32(0)
		case 'I':	// int array
			m.Size[i] = int(m.uint32());
			m.Ret[i] = []int32(nil);
		case 's':	// string
			m.Size[i] = int(m.uint32());
			m.Ret[i] = "";
		}
	}
}

func (m *msg) packRequest() {
	m.packHeader();
	m.wuint32(uint32(len(m.Arg)));
	m.packValues(m.Arg);
	m.wuint32(uint32(len(m.Ret)));
	for i, v := range m.Ret {
		switch x := v.(type) {
		case bool:
			m.wuint8('b')
		case []byte:
			m.wuint8('C');
			m.wuint32(uint32(m.Size[i]));
		case float64:
			m.wuint8('d')
		case []float64:
			m.wuint8('D');
			m.wuint32(uint32(m.Size[i]));
		case int:
			m.wuint8('h')
		case int32:
			m.wuint8('i')
		case []int32:
			m.wuint8('I');
			m.wuint32(uint32(m.Size[i]));
		case string:
			m.wuint8('s');
			m.wuint32(uint32(m.Size[i]));
		}
	}
}

func (m *msg) unpackResponse() {
	m.status = OK;
	if m.unpackHeader(); m.status != OK {
		return
	}
	if m.protocol != protocol || m.isReq {
		m.status = ErrProtocolMismatch;
		return;
	}

	// type-tagged return values
	m.fmt = "";
	m.Ret = make([]interface{}, m.uint32());
	m.unpackValues(m.Ret);
}

func (m *msg) packResponse() {
	m.packHeader();
	m.wuint32(uint32(len(m.Ret)));
	m.packValues(m.Ret);
}