1 // Copyright 2011 The Go Authors. All rights reserved.

     2 // Use of this source code is governed by a BSD-style

     3 // license that can be found in the LICENSE file.

     4 

     5 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris

     6 

     7 // Socket control messages

     8 

     9 package unix

    10 

    11 import "unsafe"

    12 

    13 // Round the length of a raw sockaddr up to align it properly.

    14 func cmsgAlignOf(salen int) int {

    15 	salign := sizeofPtr

    16 	// NOTE: It seems like 64-bit Darwin, DragonFly BSD and

    17 	// Solaris kernels still require 32-bit aligned access to

    18 	// network subsystem.

    19 	if darwin64Bit || dragonfly64Bit || solaris64Bit {

    20 		salign = 4

    21 	}

    22 	return (salen + salign - 1) & ^(salign - 1)

    23 }

    24 

    25 // CmsgLen returns the value to store in the Len field of the Cmsghdr

    26 // structure, taking into account any necessary alignment.

    27 func CmsgLen(datalen int) int {

    28 	return cmsgAlignOf(SizeofCmsghdr) + datalen

    29 }

    30 

    31 // CmsgSpace returns the number of bytes an ancillary element with

    32 // payload of the passed data length occupies.

    33 func CmsgSpace(datalen int) int {

    34 	return cmsgAlignOf(SizeofCmsghdr) + cmsgAlignOf(datalen)

    35 }

    36 

    37 func cmsgData(h *Cmsghdr) unsafe.Pointer {

    38 	return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)))

    39 }

    40 

    41 // SocketControlMessage represents a socket control message.

    42 type SocketControlMessage struct {

    43 	Header Cmsghdr

    44 	Data   []byte

    45 }

    46 

    47 // ParseSocketControlMessage parses b as an array of socket control

    48 // messages.

    49 func ParseSocketControlMessage(b []byte) ([]SocketControlMessage, error) {

    50 	var msgs []SocketControlMessage

    51 	i := 0

    52 	for i+CmsgLen(0) <= len(b) {

    53 		h, dbuf, err := socketControlMessageHeaderAndData(b[i:])

    54 		if err != nil {

    55 			return nil, err

    56 		}

    57 		m := SocketControlMessage{Header: *h, Data: dbuf}

    58 		msgs = append(msgs, m)

    59 		i += cmsgAlignOf(int(h.Len))

    60 	}

    61 	return msgs, nil

    62 }

    63 

    64 func socketControlMessageHeaderAndData(b []byte) (*Cmsghdr, []byte, error) {

    65 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))

    66 	if h.Len < SizeofCmsghdr || uint64(h.Len) > uint64(len(b)) {

    67 		return nil, nil, EINVAL

    68 	}

    69 	return h, b[cmsgAlignOf(SizeofCmsghdr):h.Len], nil

    70 }

    71 

    72 // UnixRights encodes a set of open file descriptors into a socket

    73 // control message for sending to another process.

    74 func UnixRights(fds ...int) []byte {

    75 	datalen := len(fds) * 4

    76 	b := make([]byte, CmsgSpace(datalen))

    77 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))

    78 	h.Level = SOL_SOCKET

    79 	h.Type = SCM_RIGHTS

    80 	h.SetLen(CmsgLen(datalen))

    81 	data := cmsgData(h)

    82 	for _, fd := range fds {

    83 		*(*int32)(data) = int32(fd)

    84 		data = unsafe.Pointer(uintptr(data) + 4)

    85 	}

    86 	return b

    87 }

    88 

    89 // ParseUnixRights decodes a socket control message that contains an

    90 // integer array of open file descriptors from another process.

    91 func ParseUnixRights(m *SocketControlMessage) ([]int, error) {

    92 	if m.Header.Level != SOL_SOCKET {

    93 		return nil, EINVAL

    94 	}

    95 	if m.Header.Type != SCM_RIGHTS {

    96 		return nil, EINVAL

    97 	}

    98 	fds := make([]int, len(m.Data)>>2)

    99 	for i, j := 0, 0; i < len(m.Data); i += 4 {

   100 		fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))

   101 		j++

   102 	}

   103 	return fds, nil

   104 }