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