// 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);
}
|
