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