syscall: simplify socket control messages

R=golang-dev, iant
CC=golang-dev
https://golang.org/cl/7016044

src/pkg/syscall/sockcmsg_linux.go

@@ -6,33 +6,31 @@
 
 package syscall
 
-import (
-	"unsafe"
-)
+import "unsafe"
 
 // UnixCredentials encodes credentials into a socket control message
 // for sending to another process. This can be used for
 // authentication.
 func UnixCredentials(ucred *Ucred) []byte {
-	buf := make([]byte, CmsgSpace(SizeofUcred))
-	cmsg := (*Cmsghdr)(unsafe.Pointer(&buf[0]))
-	cmsg.Level = SOL_SOCKET
-	cmsg.Type = SCM_CREDENTIALS
-	cmsg.SetLen(CmsgLen(SizeofUcred))
-	*((*Ucred)(cmsgData(cmsg))) = *ucred
-	return buf
+	b := make([]byte, CmsgSpace(SizeofUcred))
+	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
+	h.Level = SOL_SOCKET
+	h.Type = SCM_CREDENTIALS
+	h.SetLen(CmsgLen(SizeofUcred))
+	*((*Ucred)(cmsgData(h))) = *ucred
+	return b
 }
 
 // ParseUnixCredentials decodes a socket control message that contains
 // credentials in a Ucred structure. To receive such a message, the
 // SO_PASSCRED option must be enabled on the socket.
-func ParseUnixCredentials(msg *SocketControlMessage) (*Ucred, error) {
-	if msg.Header.Level != SOL_SOCKET {
+func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) {
+	if m.Header.Level != SOL_SOCKET {
 		return nil, EINVAL
 	}
-	if msg.Header.Type != SCM_CREDENTIALS {
+	if m.Header.Type != SCM_CREDENTIALS {
 		return nil, EINVAL
 	}
-	ucred := *(*Ucred)(unsafe.Pointer(&msg.Data[0]))
+	ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
 	return &ucred, nil
 }

src/pkg/syscall/sockcmsg_unix.go

@@ -8,9 +8,7 @@
 
 package syscall
 
-import (
-	"unsafe"
-)
+import "unsafe"
 
 // Round the length of a raw sockaddr up to align it propery.
 func cmsgAlignOf(salen int) int {
@@ -38,77 +36,69 @@ func CmsgSpace(datalen int) int {
 	return cmsgAlignOf(SizeofCmsghdr) + cmsgAlignOf(datalen)
 }
 
-func cmsgData(cmsg *Cmsghdr) unsafe.Pointer {
-	return unsafe.Pointer(uintptr(unsafe.Pointer(cmsg)) + SizeofCmsghdr)
+func cmsgData(h *Cmsghdr) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + SizeofCmsghdr)
 }
 
+// SocketControlMessage represents a socket control message.
 type SocketControlMessage struct {
 	Header Cmsghdr
 	Data   []byte
 }
 
-func ParseSocketControlMessage(buf []byte) ([]SocketControlMessage, error) {
-	var (
-		h     *Cmsghdr
-		dbuf  []byte
-		e     error
-		cmsgs []SocketControlMessage
-	)
-
-	for len(buf) >= CmsgLen(0) {
-		h, dbuf, e = socketControlMessageHeaderAndData(buf)
-		if e != nil {
-			break
+// ParseSocketControlMessage parses b as an array of socket control
+// messages.
+func ParseSocketControlMessage(b []byte) ([]SocketControlMessage, error) {
+	var msgs []SocketControlMessage
+	for len(b) >= CmsgLen(0) {
+		h, dbuf, err := socketControlMessageHeaderAndData(b)
+		if err != nil {
+			return nil, err
 		}
-		m := SocketControlMessage{}
-		m.Header = *h
-		m.Data = dbuf[:int(h.Len)-cmsgAlignOf(SizeofCmsghdr)]
-		cmsgs = append(cmsgs, m)
-		buf = buf[cmsgAlignOf(int(h.Len)):]
+		m := SocketControlMessage{Header: *h, Data: dbuf[:int(h.Len)-cmsgAlignOf(SizeofCmsghdr)]}
+		msgs = append(msgs, m)
+		b = b[cmsgAlignOf(int(h.Len)):]
 	}
-
-	return cmsgs, e
+	return msgs, nil
 }
 
-func socketControlMessageHeaderAndData(buf []byte) (*Cmsghdr, []byte, error) {
-	h := (*Cmsghdr)(unsafe.Pointer(&buf[0]))
-	if h.Len < SizeofCmsghdr || int(h.Len) > len(buf) {
+func socketControlMessageHeaderAndData(b []byte) (*Cmsghdr, []byte, error) {
+	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
+	if h.Len < SizeofCmsghdr || int(h.Len) > len(b) {
 		return nil, nil, EINVAL
 	}
-	return h, buf[cmsgAlignOf(SizeofCmsghdr):], nil
+	return h, b[cmsgAlignOf(SizeofCmsghdr):], nil
 }
 
 // UnixRights encodes a set of open file descriptors into a socket
 // control message for sending to another process.
 func UnixRights(fds ...int) []byte {
 	datalen := len(fds) * 4
-	buf := make([]byte, CmsgSpace(datalen))
-	cmsg := (*Cmsghdr)(unsafe.Pointer(&buf[0]))
-	cmsg.Level = SOL_SOCKET
-	cmsg.Type = SCM_RIGHTS
-	cmsg.SetLen(CmsgLen(datalen))
-
-	data := uintptr(cmsgData(cmsg))
+	b := make([]byte, CmsgSpace(datalen))
+	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
+	h.Level = SOL_SOCKET
+	h.Type = SCM_RIGHTS
+	h.SetLen(CmsgLen(datalen))
+	data := uintptr(cmsgData(h))
 	for _, fd := range fds {
 		*(*int32)(unsafe.Pointer(data)) = int32(fd)
 		data += 4
 	}
-
-	return buf
+	return b
 }
 
 // ParseUnixRights decodes a socket control message that contains an
 // integer array of open file descriptors from another process.
-func ParseUnixRights(msg *SocketControlMessage) ([]int, error) {
-	if msg.Header.Level != SOL_SOCKET {
+func ParseUnixRights(m *SocketControlMessage) ([]int, error) {
+	if m.Header.Level != SOL_SOCKET {
 		return nil, EINVAL
 	}
-	if msg.Header.Type != SCM_RIGHTS {
+	if m.Header.Type != SCM_RIGHTS {
 		return nil, EINVAL
 	}
-	fds := make([]int, len(msg.Data)>>2)
-	for i, j := 0, 0; i < len(msg.Data); i += 4 {
-		fds[j] = int(*(*int32)(unsafe.Pointer(&msg.Data[i])))
+	fds := make([]int, len(m.Data)>>2)
+	for i, j := 0, 0; i < len(m.Data); i += 4 {
+		fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
 		j++
 	}
 	return fds, nil