URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [syscall/] [socket_linux.go] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log


// socket_linux.go -- Socket handling specific to GNU/Linux.
 
// Copyright 2010 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.
 
package syscall
 
import "unsafe"
 
const SizeofSockaddrInet4 = 16
const SizeofSockaddrInet6 = 28
const SizeofSockaddrUnix = 110
const SizeofSockaddrLinklayer = 20
const SizeofSockaddrNetlink = 12
 
type SockaddrLinklayer struct {
        Protocol uint16
        Ifindex  int
        Hatype   uint16
        Pkttype  uint8
        Halen    uint8
        Addr     [8]byte
        raw      RawSockaddrLinklayer
}
 
func (sa *SockaddrLinklayer) sockaddr() (*RawSockaddrAny, Socklen_t, error) {
        if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
                return nil, 0, EINVAL
        }
        sa.raw.Family = AF_PACKET
        sa.raw.Protocol = sa.Protocol
        sa.raw.Ifindex = int32(sa.Ifindex)
        sa.raw.Hatype = sa.Hatype
        sa.raw.Pkttype = sa.Pkttype
        sa.raw.Halen = sa.Halen
        for i := 0; i < len(sa.Addr); i++ {
                sa.raw.Addr[i] = sa.Addr[i]
        }
        return (*RawSockaddrAny)(unsafe.Pointer(&sa.raw)), SizeofSockaddrLinklayer, nil
}
 
type SockaddrNetlink struct {
        Family uint16
        Pad    uint16
        Pid    uint32
        Groups uint32
        raw    RawSockaddrNetlink
}
 
func (sa *SockaddrNetlink) sockaddr() (*RawSockaddrAny, Socklen_t, error) {
        sa.raw.Family = AF_NETLINK
        sa.raw.Pad = sa.Pad
        sa.raw.Pid = sa.Pid
        sa.raw.Groups = sa.Groups
        return (*RawSockaddrAny)(unsafe.Pointer(&sa.raw)), SizeofSockaddrNetlink, nil
}
 
type RawSockaddrInet4 struct {
        Family uint16
        Port uint16
        Addr [4]byte /* in_addr */
        Zero [8]uint8
}
 
func (sa *RawSockaddrInet4) setLen() Socklen_t {
        return SizeofSockaddrInet4
}
 
type RawSockaddrInet6 struct {
        Family uint16
        Port uint16
        Flowinfo uint32
        Addr [16]byte /* in6_addr */
        Scope_id uint32
}
 
func (sa *RawSockaddrInet6) setLen() Socklen_t {
        return SizeofSockaddrInet6
}
 
type RawSockaddrUnix struct {
        Family uint16
        Path [108]int8
}
 
func (sa *RawSockaddrUnix) setLen(int) {
}
 
func (sa *RawSockaddrUnix) getLen() (int, error) {
        if sa.Path[0] == 0 {
                // "Abstract" Unix domain socket.
                // Rewrite leading NUL as @ for textual display.
                // (This is the standard convention.)
                // Not friendly to overwrite in place,
                // but the callers below don't care.
                sa.Path[0] = '@'
        }
 
        // Assume path ends at NUL.
        // This is not technically the GNU/Linux semantics for
        // abstract Unix domain sockets--they are supposed
        // to be uninterpreted fixed-size binary blobs--but
        // everyone uses this convention.
        n := 0
        for n < len(sa.Path) - 3 && sa.Path[n] != 0 {
                n++
        }
 
        return n, nil
}
 
type RawSockaddrLinklayer struct {
        Family   uint16
        Protocol uint16
        Ifindex  int32
        Hatype   uint16
        Pkttype  uint8
        Halen    uint8
        Addr     [8]uint8
}
 
type RawSockaddrNetlink struct {
        Family uint16
        Pad    uint16
        Pid    uint32
        Groups uint32
}
 
type RawSockaddr struct {
        Family uint16
        Data [14]int8
}
 
// BindToDevice binds the socket associated with fd to device.
func BindToDevice(fd int, device string) (err error) {
        return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)
}
 
func anyToSockaddrOS(rsa *RawSockaddrAny) (Sockaddr, error) {
        switch rsa.Addr.Family {
        case AF_NETLINK:
                pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
                sa := new(SockaddrNetlink)
                sa.Family = pp.Family
                sa.Pad = pp.Pad
                sa.Pid = pp.Pid
                sa.Groups = pp.Groups
                return sa, nil
 
        case AF_PACKET:
                pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
                sa := new(SockaddrLinklayer)
                sa.Protocol = pp.Protocol
                sa.Ifindex = int(pp.Ifindex)
                sa.Hatype = pp.Hatype
                sa.Pkttype = pp.Pkttype
                sa.Halen = pp.Halen
                for i := 0; i < len(sa.Addr); i++ {
                        sa.Addr[i] = pp.Addr[i]
                }
                return sa, nil
        }
        return nil, EAFNOSUPPORT
}
 
//sysnb EpollCreate(size int) (fd int, err error)
//epoll_create(size int) int
 
//sysnb EpollCreate1(flags int) (fd int, err error)
//epoll_create1(flags int) int
 
//sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error)
//epoll_ctl(epfd int, op int, fd int, event *EpollEvent) int
 
//sys   EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
//epoll_wait(epfd int, events *EpollEvent, maxevents int, timeout int) int

Line No.	Rev	Author	Line
1	747	jeremybenn	`// socket_linux.go -- Socket handling specific to GNU/Linux.`
2
3			`// Copyright 2010 The Go Authors. All rights reserved.`
4			`// Use of this source code is governed by a BSD-style`
5			`// license that can be found in the LICENSE file.`
6
7			`package syscall`
8
9			`import "unsafe"`
10
11			`const SizeofSockaddrInet4 = 16`
12			`const SizeofSockaddrInet6 = 28`
13			`const SizeofSockaddrUnix = 110`
14			`const SizeofSockaddrLinklayer = 20`
15			`const SizeofSockaddrNetlink = 12`
16
17			`type SockaddrLinklayer struct {`
18			`Protocol uint16`
19			`Ifindex int`
20			`Hatype uint16`
21			`Pkttype uint8`
22			`Halen uint8`
23			`Addr [8]byte`
24			`raw RawSockaddrLinklayer`
25			`}`
26
27			`func (sa SockaddrLinklayer) sockaddr() (RawSockaddrAny, Socklen_t, error) {`
28			`if sa.Ifindex < 0 \|\| sa.Ifindex > 0x7fffffff {`
29			`return nil, 0, EINVAL`
30			`}`
31			`sa.raw.Family = AF_PACKET`
32			`sa.raw.Protocol = sa.Protocol`
33			`sa.raw.Ifindex = int32(sa.Ifindex)`
34			`sa.raw.Hatype = sa.Hatype`
35			`sa.raw.Pkttype = sa.Pkttype`
36			`sa.raw.Halen = sa.Halen`
37			`for i := 0; i < len(sa.Addr); i++ {`
38			`sa.raw.Addr[i] = sa.Addr[i]`
39			`}`
40			`return (*RawSockaddrAny)(unsafe.Pointer(&sa.raw)), SizeofSockaddrLinklayer, nil`
41			`}`
42
43			`type SockaddrNetlink struct {`
44			`Family uint16`
45			`Pad uint16`
46			`Pid uint32`
47			`Groups uint32`
48			`raw RawSockaddrNetlink`
49			`}`
50
51			`func (sa SockaddrNetlink) sockaddr() (RawSockaddrAny, Socklen_t, error) {`
52			`sa.raw.Family = AF_NETLINK`
53			`sa.raw.Pad = sa.Pad`
54			`sa.raw.Pid = sa.Pid`
55			`sa.raw.Groups = sa.Groups`
56			`return (*RawSockaddrAny)(unsafe.Pointer(&sa.raw)), SizeofSockaddrNetlink, nil`
57			`}`
58
59			`type RawSockaddrInet4 struct {`
60			`Family uint16`
61			`Port uint16`
62			`Addr [4]byte /* in_addr */`
63			`Zero [8]uint8`
64			`}`
65
66			`func (sa *RawSockaddrInet4) setLen() Socklen_t {`
67			`return SizeofSockaddrInet4`
68			`}`
69
70			`type RawSockaddrInet6 struct {`
71			`Family uint16`
72			`Port uint16`
73			`Flowinfo uint32`
74			`Addr [16]byte /* in6_addr */`
75			`Scope_id uint32`
76			`}`
77
78			`func (sa *RawSockaddrInet6) setLen() Socklen_t {`
79			`return SizeofSockaddrInet6`
80			`}`
81
82			`type RawSockaddrUnix struct {`
83			`Family uint16`
84			`Path [108]int8`
85			`}`
86
87			`func (sa *RawSockaddrUnix) setLen(int) {`
88			`}`
89
90			`func (sa *RawSockaddrUnix) getLen() (int, error) {`
91			`if sa.Path[0] == 0 {`
92			`// "Abstract" Unix domain socket.`
93			`// Rewrite leading NUL as @ for textual display.`
94			`// (This is the standard convention.)`
95			`// Not friendly to overwrite in place,`
96			`// but the callers below don't care.`
97			`sa.Path[0] = '@'`
98			`}`
99
100			`// Assume path ends at NUL.`
101			`// This is not technically the GNU/Linux semantics for`
102			`// abstract Unix domain sockets--they are supposed`
103			`// to be uninterpreted fixed-size binary blobs--but`
104			`// everyone uses this convention.`
105			`n := 0`
106			`for n < len(sa.Path) - 3 && sa.Path[n] != 0 {`
107			`n++`
108			`}`
109
110			`return n, nil`
111			`}`
112
113			`type RawSockaddrLinklayer struct {`
114			`Family uint16`
115			`Protocol uint16`
116			`Ifindex int32`
117			`Hatype uint16`
118			`Pkttype uint8`
119			`Halen uint8`
120			`Addr [8]uint8`
121			`}`
122
123			`type RawSockaddrNetlink struct {`
124			`Family uint16`
125			`Pad uint16`
126			`Pid uint32`
127			`Groups uint32`
128			`}`
129
130			`type RawSockaddr struct {`
131			`Family uint16`
132			`Data [14]int8`
133			`}`
134
135			`// BindToDevice binds the socket associated with fd to device.`
136			`func BindToDevice(fd int, device string) (err error) {`
137			`return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)`
138			`}`
139
140			`func anyToSockaddrOS(rsa *RawSockaddrAny) (Sockaddr, error) {`
141			`switch rsa.Addr.Family {`
142			`case AF_NETLINK:`
143			`pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))`
144			`sa := new(SockaddrNetlink)`
145			`sa.Family = pp.Family`
146			`sa.Pad = pp.Pad`
147			`sa.Pid = pp.Pid`
148			`sa.Groups = pp.Groups`
149			`return sa, nil`
150
151			`case AF_PACKET:`
152			`pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))`
153			`sa := new(SockaddrLinklayer)`
154			`sa.Protocol = pp.Protocol`
155			`sa.Ifindex = int(pp.Ifindex)`
156			`sa.Hatype = pp.Hatype`
157			`sa.Pkttype = pp.Pkttype`
158			`sa.Halen = pp.Halen`
159			`for i := 0; i < len(sa.Addr); i++ {`
160			`sa.Addr[i] = pp.Addr[i]`
161			`}`
162			`return sa, nil`
163			`}`
164			`return nil, EAFNOSUPPORT`
165			`}`
166
167			`//sysnb EpollCreate(size int) (fd int, err error)`
168			`//epoll_create(size int) int`
169
170			`//sysnb EpollCreate1(flags int) (fd int, err error)`
171			`//epoll_create1(flags int) int`
172
173			`//sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error)`
174			`//epoll_ctl(epfd int, op int, fd int, event *EpollEvent) int`
175
176			`//sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)`
177			`//epoll_wait(epfd int, events *EpollEvent, maxevents int, timeout int) int`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [syscall/] [socket_linux.go] - Blame information for rev 801