Subversion Repositories openrisc

// Copyright 2011 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.

// +build darwin freebsd linux netbsd openbsd

// Socket control messages

package syscall

import (
        "unsafe"
)

// Round the length of a raw sockaddr up to align it propery.
func cmsgAlignOf(salen int) int {
        salign := int(sizeofPtr)
        // NOTE: It seems like 64-bit Darwin kernel still requires 32-bit
        // aligned access to BSD subsystem.
        if darwinAMD64 {
                salign = 4
        }
        if salen == 0 {
                return salign
        }
        return (salen + salign - 1) & ^(salign - 1)
}

// CmsgLen returns the value to store in the Len field of the Cmsghdr
// structure, taking into account any necessary alignment.
func CmsgLen(datalen int) int {
        return cmsgAlignOf(SizeofCmsghdr) + datalen
}

// CmsgSpace returns the number of bytes an ancillary element with
// payload of the passed data length occupies.
func CmsgSpace(datalen int) int {
        return cmsgAlignOf(SizeofCmsghdr) + cmsgAlignOf(datalen)
}

func cmsgData(cmsg *Cmsghdr) unsafe.Pointer {
        return unsafe.Pointer(uintptr(unsafe.Pointer(cmsg)) + uintptr(SizeofCmsghdr))
}

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
                }
                m := SocketControlMessage{}
                m.Header = *h
                m.Data = dbuf[:int(h.Len)-cmsgAlignOf(SizeofCmsghdr)]
                cmsgs = append(cmsgs, m)
                buf = buf[cmsgAlignOf(int(h.Len)):]
        }

        return cmsgs, e
}

func socketControlMessageHeaderAndData(buf []byte) (*Cmsghdr, []byte, error) {
        h := (*Cmsghdr)(unsafe.Pointer(&buf[0]))
        if int(h.Len) < SizeofCmsghdr || int(h.Len) > len(buf) {
                return nil, nil, EINVAL
        }
        return h, buf[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))
        for _, fd := range fds {
                *(*int32)(unsafe.Pointer(data)) = int32(fd)
                data += 4
        }

        return buf
}

// 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 {
                return nil, EINVAL
        }
        if msg.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])))
                j++
        }
        return fds, nil
}