|
66
|
1 // Copyright 2009,2010 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 // Darwin system calls.
|
|
|
6 // This file is compiled as ordinary Go code,
|
|
|
7 // but it is also input to mksyscall,
|
|
|
8 // which parses the //sys lines and generates system call stubs.
|
|
|
9 // Note that sometimes we use a lowercase //sys name and wrap
|
|
|
10 // it in our own nicer implementation, either here or in
|
|
|
11 // syscall_bsd.go or syscall_unix.go.
|
|
|
12
|
|
|
13 package unix
|
|
|
14
|
|
|
15 import (
|
|
|
16 "fmt"
|
|
|
17 "runtime"
|
|
|
18 "syscall"
|
|
|
19 "unsafe"
|
|
|
20 )
|
|
|
21
|
|
68
|
22 //sys closedir(dir uintptr) (err error)
|
|
|
23 //sys readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno)
|
|
|
24
|
|
|
25 func fdopendir(fd int) (dir uintptr, err error) {
|
|
|
26 r0, _, e1 := syscall_syscallPtr(libc_fdopendir_trampoline_addr, uintptr(fd), 0, 0)
|
|
|
27 dir = uintptr(r0)
|
|
|
28 if e1 != 0 {
|
|
|
29 err = errnoErr(e1)
|
|
|
30 }
|
|
|
31 return
|
|
|
32 }
|
|
|
33
|
|
|
34 var libc_fdopendir_trampoline_addr uintptr
|
|
|
35
|
|
|
36 //go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
|
|
|
37
|
|
|
38 func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
|
|
|
39 // Simulate Getdirentries using fdopendir/readdir_r/closedir.
|
|
|
40 // We store the number of entries to skip in the seek
|
|
|
41 // offset of fd. See issue #31368.
|
|
|
42 // It's not the full required semantics, but should handle the case
|
|
|
43 // of calling Getdirentries or ReadDirent repeatedly.
|
|
|
44 // It won't handle assigning the results of lseek to *basep, or handle
|
|
|
45 // the directory being edited underfoot.
|
|
|
46 skip, err := Seek(fd, 0, 1 /* SEEK_CUR */)
|
|
|
47 if err != nil {
|
|
|
48 return 0, err
|
|
|
49 }
|
|
|
50
|
|
|
51 // We need to duplicate the incoming file descriptor
|
|
|
52 // because the caller expects to retain control of it, but
|
|
|
53 // fdopendir expects to take control of its argument.
|
|
|
54 // Just Dup'ing the file descriptor is not enough, as the
|
|
|
55 // result shares underlying state. Use Openat to make a really
|
|
|
56 // new file descriptor referring to the same directory.
|
|
|
57 fd2, err := Openat(fd, ".", O_RDONLY, 0)
|
|
|
58 if err != nil {
|
|
|
59 return 0, err
|
|
|
60 }
|
|
|
61 d, err := fdopendir(fd2)
|
|
|
62 if err != nil {
|
|
|
63 Close(fd2)
|
|
|
64 return 0, err
|
|
|
65 }
|
|
|
66 defer closedir(d)
|
|
|
67
|
|
|
68 var cnt int64
|
|
|
69 for {
|
|
|
70 var entry Dirent
|
|
|
71 var entryp *Dirent
|
|
|
72 e := readdir_r(d, &entry, &entryp)
|
|
|
73 if e != 0 {
|
|
|
74 return n, errnoErr(e)
|
|
|
75 }
|
|
|
76 if entryp == nil {
|
|
|
77 break
|
|
|
78 }
|
|
|
79 if skip > 0 {
|
|
|
80 skip--
|
|
|
81 cnt++
|
|
|
82 continue
|
|
|
83 }
|
|
|
84
|
|
|
85 reclen := int(entry.Reclen)
|
|
|
86 if reclen > len(buf) {
|
|
|
87 // Not enough room. Return for now.
|
|
|
88 // The counter will let us know where we should start up again.
|
|
|
89 // Note: this strategy for suspending in the middle and
|
|
|
90 // restarting is O(n^2) in the length of the directory. Oh well.
|
|
|
91 break
|
|
|
92 }
|
|
|
93
|
|
|
94 // Copy entry into return buffer.
|
|
|
95 s := unsafe.Slice((*byte)(unsafe.Pointer(&entry)), reclen)
|
|
|
96 copy(buf, s)
|
|
|
97
|
|
|
98 buf = buf[reclen:]
|
|
|
99 n += reclen
|
|
|
100 cnt++
|
|
|
101 }
|
|
|
102 // Set the seek offset of the input fd to record
|
|
|
103 // how many files we've already returned.
|
|
|
104 _, err = Seek(fd, cnt, 0 /* SEEK_SET */)
|
|
|
105 if err != nil {
|
|
|
106 return n, err
|
|
|
107 }
|
|
|
108
|
|
|
109 return n, nil
|
|
|
110 }
|
|
|
111
|
|
66
|
112 // SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
|
|
|
113 type SockaddrDatalink struct {
|
|
|
114 Len uint8
|
|
|
115 Family uint8
|
|
|
116 Index uint16
|
|
|
117 Type uint8
|
|
|
118 Nlen uint8
|
|
|
119 Alen uint8
|
|
|
120 Slen uint8
|
|
|
121 Data [12]int8
|
|
|
122 raw RawSockaddrDatalink
|
|
|
123 }
|
|
|
124
|
|
|
125 // SockaddrCtl implements the Sockaddr interface for AF_SYSTEM type sockets.
|
|
|
126 type SockaddrCtl struct {
|
|
|
127 ID uint32
|
|
|
128 Unit uint32
|
|
|
129 raw RawSockaddrCtl
|
|
|
130 }
|
|
|
131
|
|
|
132 func (sa *SockaddrCtl) sockaddr() (unsafe.Pointer, _Socklen, error) {
|
|
|
133 sa.raw.Sc_len = SizeofSockaddrCtl
|
|
|
134 sa.raw.Sc_family = AF_SYSTEM
|
|
|
135 sa.raw.Ss_sysaddr = AF_SYS_CONTROL
|
|
|
136 sa.raw.Sc_id = sa.ID
|
|
|
137 sa.raw.Sc_unit = sa.Unit
|
|
|
138 return unsafe.Pointer(&sa.raw), SizeofSockaddrCtl, nil
|
|
|
139 }
|
|
|
140
|
|
|
141 // SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
|
|
|
142 // SockaddrVM provides access to Darwin VM sockets: a mechanism that enables
|
|
|
143 // bidirectional communication between a hypervisor and its guest virtual
|
|
|
144 // machines.
|
|
|
145 type SockaddrVM struct {
|
|
|
146 // CID and Port specify a context ID and port address for a VM socket.
|
|
|
147 // Guests have a unique CID, and hosts may have a well-known CID of:
|
|
|
148 // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
|
|
|
149 // - VMADDR_CID_LOCAL: refers to local communication (loopback).
|
|
|
150 // - VMADDR_CID_HOST: refers to other processes on the host.
|
|
|
151 CID uint32
|
|
|
152 Port uint32
|
|
|
153 raw RawSockaddrVM
|
|
|
154 }
|
|
|
155
|
|
|
156 func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
|
|
|
157 sa.raw.Len = SizeofSockaddrVM
|
|
|
158 sa.raw.Family = AF_VSOCK
|
|
|
159 sa.raw.Port = sa.Port
|
|
|
160 sa.raw.Cid = sa.CID
|
|
|
161
|
|
|
162 return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
|
|
|
163 }
|
|
|
164
|
|
|
165 func anyToSockaddrGOOS(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
|
|
|
166 switch rsa.Addr.Family {
|
|
|
167 case AF_SYSTEM:
|
|
|
168 pp := (*RawSockaddrCtl)(unsafe.Pointer(rsa))
|
|
|
169 if pp.Ss_sysaddr == AF_SYS_CONTROL {
|
|
|
170 sa := new(SockaddrCtl)
|
|
|
171 sa.ID = pp.Sc_id
|
|
|
172 sa.Unit = pp.Sc_unit
|
|
|
173 return sa, nil
|
|
|
174 }
|
|
|
175 case AF_VSOCK:
|
|
|
176 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
|
|
|
177 sa := &SockaddrVM{
|
|
|
178 CID: pp.Cid,
|
|
|
179 Port: pp.Port,
|
|
|
180 }
|
|
|
181 return sa, nil
|
|
|
182 }
|
|
|
183 return nil, EAFNOSUPPORT
|
|
|
184 }
|
|
|
185
|
|
|
186 // Some external packages rely on SYS___SYSCTL being defined to implement their
|
|
|
187 // own sysctl wrappers. Provide it here, even though direct syscalls are no
|
|
|
188 // longer supported on darwin.
|
|
|
189 const SYS___SYSCTL = SYS_SYSCTL
|
|
|
190
|
|
|
191 // Translate "kern.hostname" to []_C_int{0,1,2,3}.
|
|
|
192 func nametomib(name string) (mib []_C_int, err error) {
|
|
|
193 const siz = unsafe.Sizeof(mib[0])
|
|
|
194
|
|
|
195 // NOTE(rsc): It seems strange to set the buffer to have
|
|
|
196 // size CTL_MAXNAME+2 but use only CTL_MAXNAME
|
|
|
197 // as the size. I don't know why the +2 is here, but the
|
|
|
198 // kernel uses +2 for its own implementation of this function.
|
|
|
199 // I am scared that if we don't include the +2 here, the kernel
|
|
|
200 // will silently write 2 words farther than we specify
|
|
|
201 // and we'll get memory corruption.
|
|
|
202 var buf [CTL_MAXNAME + 2]_C_int
|
|
|
203 n := uintptr(CTL_MAXNAME) * siz
|
|
|
204
|
|
|
205 p := (*byte)(unsafe.Pointer(&buf[0]))
|
|
|
206 bytes, err := ByteSliceFromString(name)
|
|
|
207 if err != nil {
|
|
|
208 return nil, err
|
|
|
209 }
|
|
|
210
|
|
|
211 // Magic sysctl: "setting" 0.3 to a string name
|
|
|
212 // lets you read back the array of integers form.
|
|
|
213 if err = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); err != nil {
|
|
|
214 return nil, err
|
|
|
215 }
|
|
|
216 return buf[0 : n/siz], nil
|
|
|
217 }
|
|
|
218
|
|
|
219 func direntIno(buf []byte) (uint64, bool) {
|
|
|
220 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
|
|
|
221 }
|
|
|
222
|
|
|
223 func direntReclen(buf []byte) (uint64, bool) {
|
|
|
224 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
|
|
|
225 }
|
|
|
226
|
|
|
227 func direntNamlen(buf []byte) (uint64, bool) {
|
|
|
228 return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
|
|
|
229 }
|
|
|
230
|
|
|
231 func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
|
|
|
232 func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
|
|
|
233
|
|
|
234 //sysnb pipe(p *[2]int32) (err error)
|
|
|
235
|
|
|
236 func Pipe(p []int) (err error) {
|
|
|
237 if len(p) != 2 {
|
|
|
238 return EINVAL
|
|
|
239 }
|
|
|
240 var x [2]int32
|
|
|
241 err = pipe(&x)
|
|
|
242 if err == nil {
|
|
|
243 p[0] = int(x[0])
|
|
|
244 p[1] = int(x[1])
|
|
|
245 }
|
|
|
246 return
|
|
|
247 }
|
|
|
248
|
|
|
249 func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
|
|
|
250 var _p0 unsafe.Pointer
|
|
|
251 var bufsize uintptr
|
|
|
252 if len(buf) > 0 {
|
|
|
253 _p0 = unsafe.Pointer(&buf[0])
|
|
|
254 bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
|
|
|
255 }
|
|
|
256 return getfsstat(_p0, bufsize, flags)
|
|
|
257 }
|
|
|
258
|
|
|
259 func xattrPointer(dest []byte) *byte {
|
|
|
260 // It's only when dest is set to NULL that the OS X implementations of
|
|
|
261 // getxattr() and listxattr() return the current sizes of the named attributes.
|
|
|
262 // An empty byte array is not sufficient. To maintain the same behaviour as the
|
|
|
263 // linux implementation, we wrap around the system calls and pass in NULL when
|
|
|
264 // dest is empty.
|
|
|
265 var destp *byte
|
|
|
266 if len(dest) > 0 {
|
|
|
267 destp = &dest[0]
|
|
|
268 }
|
|
|
269 return destp
|
|
|
270 }
|
|
|
271
|
|
|
272 //sys getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
|
|
|
273
|
|
|
274 func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
|
|
|
275 return getxattr(path, attr, xattrPointer(dest), len(dest), 0, 0)
|
|
|
276 }
|
|
|
277
|
|
|
278 func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
|
|
|
279 return getxattr(link, attr, xattrPointer(dest), len(dest), 0, XATTR_NOFOLLOW)
|
|
|
280 }
|
|
|
281
|
|
|
282 //sys fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
|
|
|
283
|
|
|
284 func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
|
|
|
285 return fgetxattr(fd, attr, xattrPointer(dest), len(dest), 0, 0)
|
|
|
286 }
|
|
|
287
|
|
|
288 //sys setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error)
|
|
|
289
|
|
|
290 func Setxattr(path string, attr string, data []byte, flags int) (err error) {
|
|
|
291 // The parameters for the OS X implementation vary slightly compared to the
|
|
|
292 // linux system call, specifically the position parameter:
|
|
|
293 //
|
|
|
294 // linux:
|
|
|
295 // int setxattr(
|
|
|
296 // const char *path,
|
|
|
297 // const char *name,
|
|
|
298 // const void *value,
|
|
|
299 // size_t size,
|
|
|
300 // int flags
|
|
|
301 // );
|
|
|
302 //
|
|
|
303 // darwin:
|
|
|
304 // int setxattr(
|
|
|
305 // const char *path,
|
|
|
306 // const char *name,
|
|
|
307 // void *value,
|
|
|
308 // size_t size,
|
|
|
309 // u_int32_t position,
|
|
|
310 // int options
|
|
|
311 // );
|
|
|
312 //
|
|
|
313 // position specifies the offset within the extended attribute. In the
|
|
|
314 // current implementation, only the resource fork extended attribute makes
|
|
|
315 // use of this argument. For all others, position is reserved. We simply
|
|
|
316 // default to setting it to zero.
|
|
|
317 return setxattr(path, attr, xattrPointer(data), len(data), 0, flags)
|
|
|
318 }
|
|
|
319
|
|
|
320 func Lsetxattr(link string, attr string, data []byte, flags int) (err error) {
|
|
|
321 return setxattr(link, attr, xattrPointer(data), len(data), 0, flags|XATTR_NOFOLLOW)
|
|
|
322 }
|
|
|
323
|
|
|
324 //sys fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error)
|
|
|
325
|
|
|
326 func Fsetxattr(fd int, attr string, data []byte, flags int) (err error) {
|
|
|
327 return fsetxattr(fd, attr, xattrPointer(data), len(data), 0, 0)
|
|
|
328 }
|
|
|
329
|
|
|
330 //sys removexattr(path string, attr string, options int) (err error)
|
|
|
331
|
|
|
332 func Removexattr(path string, attr string) (err error) {
|
|
|
333 // We wrap around and explicitly zero out the options provided to the OS X
|
|
|
334 // implementation of removexattr, we do so for interoperability with the
|
|
|
335 // linux variant.
|
|
|
336 return removexattr(path, attr, 0)
|
|
|
337 }
|
|
|
338
|
|
|
339 func Lremovexattr(link string, attr string) (err error) {
|
|
|
340 return removexattr(link, attr, XATTR_NOFOLLOW)
|
|
|
341 }
|
|
|
342
|
|
|
343 //sys fremovexattr(fd int, attr string, options int) (err error)
|
|
|
344
|
|
|
345 func Fremovexattr(fd int, attr string) (err error) {
|
|
|
346 return fremovexattr(fd, attr, 0)
|
|
|
347 }
|
|
|
348
|
|
|
349 //sys listxattr(path string, dest *byte, size int, options int) (sz int, err error)
|
|
|
350
|
|
|
351 func Listxattr(path string, dest []byte) (sz int, err error) {
|
|
|
352 return listxattr(path, xattrPointer(dest), len(dest), 0)
|
|
|
353 }
|
|
|
354
|
|
|
355 func Llistxattr(link string, dest []byte) (sz int, err error) {
|
|
|
356 return listxattr(link, xattrPointer(dest), len(dest), XATTR_NOFOLLOW)
|
|
|
357 }
|
|
|
358
|
|
|
359 //sys flistxattr(fd int, dest *byte, size int, options int) (sz int, err error)
|
|
|
360
|
|
|
361 func Flistxattr(fd int, dest []byte) (sz int, err error) {
|
|
|
362 return flistxattr(fd, xattrPointer(dest), len(dest), 0)
|
|
|
363 }
|
|
|
364
|
|
|
365 //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)
|
|
|
366
|
|
|
367 /*
|
|
|
368 * Wrapped
|
|
|
369 */
|
|
|
370
|
|
|
371 //sys fcntl(fd int, cmd int, arg int) (val int, err error)
|
|
|
372
|
|
|
373 //sys kill(pid int, signum int, posix int) (err error)
|
|
|
374
|
|
|
375 func Kill(pid int, signum syscall.Signal) (err error) { return kill(pid, int(signum), 1) }
|
|
|
376
|
|
|
377 //sys ioctl(fd int, req uint, arg uintptr) (err error)
|
|
|
378
|
|
|
379 func IoctlCtlInfo(fd int, ctlInfo *CtlInfo) error {
|
|
|
380 err := ioctl(fd, CTLIOCGINFO, uintptr(unsafe.Pointer(ctlInfo)))
|
|
|
381 runtime.KeepAlive(ctlInfo)
|
|
|
382 return err
|
|
|
383 }
|
|
|
384
|
|
|
385 // IfreqMTU is struct ifreq used to get or set a network device's MTU.
|
|
|
386 type IfreqMTU struct {
|
|
|
387 Name [IFNAMSIZ]byte
|
|
|
388 MTU int32
|
|
|
389 }
|
|
|
390
|
|
|
391 // IoctlGetIfreqMTU performs the SIOCGIFMTU ioctl operation on fd to get the MTU
|
|
|
392 // of the network device specified by ifname.
|
|
|
393 func IoctlGetIfreqMTU(fd int, ifname string) (*IfreqMTU, error) {
|
|
|
394 var ifreq IfreqMTU
|
|
|
395 copy(ifreq.Name[:], ifname)
|
|
|
396 err := ioctl(fd, SIOCGIFMTU, uintptr(unsafe.Pointer(&ifreq)))
|
|
|
397 return &ifreq, err
|
|
|
398 }
|
|
|
399
|
|
|
400 // IoctlSetIfreqMTU performs the SIOCSIFMTU ioctl operation on fd to set the MTU
|
|
|
401 // of the network device specified by ifreq.Name.
|
|
|
402 func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
|
|
|
403 err := ioctl(fd, SIOCSIFMTU, uintptr(unsafe.Pointer(ifreq)))
|
|
|
404 runtime.KeepAlive(ifreq)
|
|
|
405 return err
|
|
|
406 }
|
|
|
407
|
|
|
408 //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
|
|
|
409
|
|
|
410 func Uname(uname *Utsname) error {
|
|
|
411 mib := []_C_int{CTL_KERN, KERN_OSTYPE}
|
|
|
412 n := unsafe.Sizeof(uname.Sysname)
|
|
|
413 if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil {
|
|
|
414 return err
|
|
|
415 }
|
|
|
416
|
|
|
417 mib = []_C_int{CTL_KERN, KERN_HOSTNAME}
|
|
|
418 n = unsafe.Sizeof(uname.Nodename)
|
|
|
419 if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil {
|
|
|
420 return err
|
|
|
421 }
|
|
|
422
|
|
|
423 mib = []_C_int{CTL_KERN, KERN_OSRELEASE}
|
|
|
424 n = unsafe.Sizeof(uname.Release)
|
|
|
425 if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil {
|
|
|
426 return err
|
|
|
427 }
|
|
|
428
|
|
|
429 mib = []_C_int{CTL_KERN, KERN_VERSION}
|
|
|
430 n = unsafe.Sizeof(uname.Version)
|
|
|
431 if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil {
|
|
|
432 return err
|
|
|
433 }
|
|
|
434
|
|
|
435 // The version might have newlines or tabs in it, convert them to
|
|
|
436 // spaces.
|
|
|
437 for i, b := range uname.Version {
|
|
|
438 if b == '\n' || b == '\t' {
|
|
|
439 if i == len(uname.Version)-1 {
|
|
|
440 uname.Version[i] = 0
|
|
|
441 } else {
|
|
|
442 uname.Version[i] = ' '
|
|
|
443 }
|
|
|
444 }
|
|
|
445 }
|
|
|
446
|
|
|
447 mib = []_C_int{CTL_HW, HW_MACHINE}
|
|
|
448 n = unsafe.Sizeof(uname.Machine)
|
|
|
449 if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil {
|
|
|
450 return err
|
|
|
451 }
|
|
|
452
|
|
|
453 return nil
|
|
|
454 }
|
|
|
455
|
|
|
456 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
|
|
|
457 if raceenabled {
|
|
|
458 raceReleaseMerge(unsafe.Pointer(&ioSync))
|
|
|
459 }
|
|
|
460 var length = int64(count)
|
|
|
461 err = sendfile(infd, outfd, *offset, &length, nil, 0)
|
|
|
462 written = int(length)
|
|
|
463 return
|
|
|
464 }
|
|
|
465
|
|
|
466 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
|
|
|
467 var value IPMreqn
|
|
|
468 vallen := _Socklen(SizeofIPMreqn)
|
|
|
469 errno := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
|
|
|
470 return &value, errno
|
|
|
471 }
|
|
|
472
|
|
|
473 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
|
|
|
474 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
|
|
|
475 }
|
|
|
476
|
|
|
477 // GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
|
|
|
478 // The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
|
|
|
479 func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
|
|
|
480 x := new(Xucred)
|
|
|
481 vallen := _Socklen(SizeofXucred)
|
|
|
482 err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
|
|
|
483 return x, err
|
|
|
484 }
|
|
|
485
|
|
|
486 func GetsockoptTCPConnectionInfo(fd, level, opt int) (*TCPConnectionInfo, error) {
|
|
|
487 var value TCPConnectionInfo
|
|
|
488 vallen := _Socklen(SizeofTCPConnectionInfo)
|
|
|
489 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
|
|
|
490 return &value, err
|
|
|
491 }
|
|
|
492
|
|
|
493 func SysctlKinfoProc(name string, args ...int) (*KinfoProc, error) {
|
|
|
494 mib, err := sysctlmib(name, args...)
|
|
|
495 if err != nil {
|
|
|
496 return nil, err
|
|
|
497 }
|
|
|
498
|
|
|
499 var kinfo KinfoProc
|
|
|
500 n := uintptr(SizeofKinfoProc)
|
|
|
501 if err := sysctl(mib, (*byte)(unsafe.Pointer(&kinfo)), &n, nil, 0); err != nil {
|
|
|
502 return nil, err
|
|
|
503 }
|
|
|
504 if n != SizeofKinfoProc {
|
|
|
505 return nil, EIO
|
|
|
506 }
|
|
|
507 return &kinfo, nil
|
|
|
508 }
|
|
|
509
|
|
|
510 func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) {
|
|
|
511 mib, err := sysctlmib(name, args...)
|
|
|
512 if err != nil {
|
|
|
513 return nil, err
|
|
|
514 }
|
|
|
515
|
|
|
516 // Find size.
|
|
|
517 n := uintptr(0)
|
|
|
518 if err := sysctl(mib, nil, &n, nil, 0); err != nil {
|
|
|
519 return nil, err
|
|
|
520 }
|
|
|
521 if n == 0 {
|
|
|
522 return nil, nil
|
|
|
523 }
|
|
|
524 if n%SizeofKinfoProc != 0 {
|
|
|
525 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
|
|
|
526 }
|
|
|
527
|
|
|
528 // Read into buffer of that size.
|
|
|
529 buf := make([]KinfoProc, n/SizeofKinfoProc)
|
|
|
530 if err := sysctl(mib, (*byte)(unsafe.Pointer(&buf[0])), &n, nil, 0); err != nil {
|
|
|
531 return nil, err
|
|
|
532 }
|
|
|
533 if n%SizeofKinfoProc != 0 {
|
|
|
534 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
|
|
|
535 }
|
|
|
536
|
|
|
537 // The actual call may return less than the original reported required
|
|
|
538 // size so ensure we deal with that.
|
|
|
539 return buf[:n/SizeofKinfoProc], nil
|
|
|
540 }
|
|
|
541
|
|
|
542 //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
|
|
|
543
|
|
|
544 //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
|
|
|
545 //sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error)
|
|
|
546 //sys shmdt(addr uintptr) (err error)
|
|
|
547 //sys shmget(key int, size int, flag int) (id int, err error)
|
|
|
548
|
|
|
549 /*
|
|
|
550 * Exposed directly
|
|
|
551 */
|
|
|
552 //sys Access(path string, mode uint32) (err error)
|
|
|
553 //sys Adjtime(delta *Timeval, olddelta *Timeval) (err error)
|
|
|
554 //sys Chdir(path string) (err error)
|
|
|
555 //sys Chflags(path string, flags int) (err error)
|
|
|
556 //sys Chmod(path string, mode uint32) (err error)
|
|
|
557 //sys Chown(path string, uid int, gid int) (err error)
|
|
|
558 //sys Chroot(path string) (err error)
|
|
|
559 //sys ClockGettime(clockid int32, time *Timespec) (err error)
|
|
|
560 //sys Close(fd int) (err error)
|
|
|
561 //sys Clonefile(src string, dst string, flags int) (err error)
|
|
|
562 //sys Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int) (err error)
|
|
|
563 //sys Dup(fd int) (nfd int, err error)
|
|
|
564 //sys Dup2(from int, to int) (err error)
|
|
|
565 //sys Exchangedata(path1 string, path2 string, options int) (err error)
|
|
|
566 //sys Exit(code int)
|
|
|
567 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
|
|
|
568 //sys Fchdir(fd int) (err error)
|
|
|
569 //sys Fchflags(fd int, flags int) (err error)
|
|
|
570 //sys Fchmod(fd int, mode uint32) (err error)
|
|
|
571 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
|
|
|
572 //sys Fchown(fd int, uid int, gid int) (err error)
|
|
|
573 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
|
|
|
574 //sys Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error)
|
|
|
575 //sys Flock(fd int, how int) (err error)
|
|
|
576 //sys Fpathconf(fd int, name int) (val int, err error)
|
|
|
577 //sys Fsync(fd int) (err error)
|
|
|
578 //sys Ftruncate(fd int, length int64) (err error)
|
|
|
579 //sys Getcwd(buf []byte) (n int, err error)
|
|
|
580 //sys Getdtablesize() (size int)
|
|
|
581 //sysnb Getegid() (egid int)
|
|
|
582 //sysnb Geteuid() (uid int)
|
|
|
583 //sysnb Getgid() (gid int)
|
|
|
584 //sysnb Getpgid(pid int) (pgid int, err error)
|
|
|
585 //sysnb Getpgrp() (pgrp int)
|
|
|
586 //sysnb Getpid() (pid int)
|
|
|
587 //sysnb Getppid() (ppid int)
|
|
|
588 //sys Getpriority(which int, who int) (prio int, err error)
|
|
|
589 //sysnb Getrlimit(which int, lim *Rlimit) (err error)
|
|
|
590 //sysnb Getrusage(who int, rusage *Rusage) (err error)
|
|
|
591 //sysnb Getsid(pid int) (sid int, err error)
|
|
|
592 //sysnb Gettimeofday(tp *Timeval) (err error)
|
|
|
593 //sysnb Getuid() (uid int)
|
|
|
594 //sysnb Issetugid() (tainted bool)
|
|
|
595 //sys Kqueue() (fd int, err error)
|
|
|
596 //sys Lchown(path string, uid int, gid int) (err error)
|
|
|
597 //sys Link(path string, link string) (err error)
|
|
|
598 //sys Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error)
|
|
|
599 //sys Listen(s int, backlog int) (err error)
|
|
|
600 //sys Mkdir(path string, mode uint32) (err error)
|
|
|
601 //sys Mkdirat(dirfd int, path string, mode uint32) (err error)
|
|
|
602 //sys Mkfifo(path string, mode uint32) (err error)
|
|
|
603 //sys Mknod(path string, mode uint32, dev int) (err error)
|
|
|
604 //sys Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error)
|
|
|
605 //sys Open(path string, mode int, perm uint32) (fd int, err error)
|
|
|
606 //sys Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error)
|
|
|
607 //sys Pathconf(path string, name int) (val int, err error)
|
|
|
608 //sys pread(fd int, p []byte, offset int64) (n int, err error)
|
|
|
609 //sys pwrite(fd int, p []byte, offset int64) (n int, err error)
|
|
|
610 //sys read(fd int, p []byte) (n int, err error)
|
|
|
611 //sys Readlink(path string, buf []byte) (n int, err error)
|
|
|
612 //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error)
|
|
|
613 //sys Rename(from string, to string) (err error)
|
|
|
614 //sys Renameat(fromfd int, from string, tofd int, to string) (err error)
|
|
|
615 //sys Revoke(path string) (err error)
|
|
|
616 //sys Rmdir(path string) (err error)
|
|
|
617 //sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK
|
|
|
618 //sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
|
|
|
619 //sys Setegid(egid int) (err error)
|
|
|
620 //sysnb Seteuid(euid int) (err error)
|
|
|
621 //sysnb Setgid(gid int) (err error)
|
|
|
622 //sys Setlogin(name string) (err error)
|
|
|
623 //sysnb Setpgid(pid int, pgid int) (err error)
|
|
|
624 //sys Setpriority(which int, who int, prio int) (err error)
|
|
|
625 //sys Setprivexec(flag int) (err error)
|
|
|
626 //sysnb Setregid(rgid int, egid int) (err error)
|
|
|
627 //sysnb Setreuid(ruid int, euid int) (err error)
|
|
|
628 //sysnb Setrlimit(which int, lim *Rlimit) (err error)
|
|
|
629 //sysnb Setsid() (pid int, err error)
|
|
|
630 //sysnb Settimeofday(tp *Timeval) (err error)
|
|
|
631 //sysnb Setuid(uid int) (err error)
|
|
|
632 //sys Symlink(path string, link string) (err error)
|
|
|
633 //sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
|
|
|
634 //sys Sync() (err error)
|
|
|
635 //sys Truncate(path string, length int64) (err error)
|
|
|
636 //sys Umask(newmask int) (oldmask int)
|
|
|
637 //sys Undelete(path string) (err error)
|
|
|
638 //sys Unlink(path string) (err error)
|
|
|
639 //sys Unlinkat(dirfd int, path string, flags int) (err error)
|
|
|
640 //sys Unmount(path string, flags int) (err error)
|
|
|
641 //sys write(fd int, p []byte) (n int, err error)
|
|
|
642 //sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
|
|
|
643 //sys munmap(addr uintptr, length uintptr) (err error)
|
|
|
644 //sys readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ
|
|
|
645 //sys writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE
|
|
|
646
|
|
|
647 /*
|
|
|
648 * Unimplemented
|
|
|
649 */
|
|
|
650 // Profil
|
|
|
651 // Sigaction
|
|
|
652 // Sigprocmask
|
|
|
653 // Getlogin
|
|
|
654 // Sigpending
|
|
|
655 // Sigaltstack
|
|
|
656 // Ioctl
|
|
|
657 // Reboot
|
|
|
658 // Execve
|
|
|
659 // Vfork
|
|
|
660 // Sbrk
|
|
|
661 // Sstk
|
|
|
662 // Ovadvise
|
|
|
663 // Mincore
|
|
|
664 // Setitimer
|
|
|
665 // Swapon
|
|
|
666 // Select
|
|
|
667 // Sigsuspend
|
|
|
668 // Readv
|
|
|
669 // Writev
|
|
|
670 // Nfssvc
|
|
|
671 // Getfh
|
|
|
672 // Quotactl
|
|
|
673 // Csops
|
|
|
674 // Waitid
|
|
|
675 // Add_profil
|
|
|
676 // Kdebug_trace
|
|
|
677 // Sigreturn
|
|
|
678 // Atsocket
|
|
|
679 // Kqueue_from_portset_np
|
|
|
680 // Kqueue_portset
|
|
|
681 // Getattrlist
|
|
|
682 // Setattrlist
|
|
|
683 // Getdirentriesattr
|
|
|
684 // Searchfs
|
|
|
685 // Delete
|
|
|
686 // Copyfile
|
|
|
687 // Watchevent
|
|
|
688 // Waitevent
|
|
|
689 // Modwatch
|
|
|
690 // Fsctl
|
|
|
691 // Initgroups
|
|
|
692 // Posix_spawn
|
|
|
693 // Nfsclnt
|
|
|
694 // Fhopen
|
|
|
695 // Minherit
|
|
|
696 // Semsys
|
|
|
697 // Msgsys
|
|
|
698 // Shmsys
|
|
|
699 // Semctl
|
|
|
700 // Semget
|
|
|
701 // Semop
|
|
|
702 // Msgctl
|
|
|
703 // Msgget
|
|
|
704 // Msgsnd
|
|
|
705 // Msgrcv
|
|
|
706 // Shm_open
|
|
|
707 // Shm_unlink
|
|
|
708 // Sem_open
|
|
|
709 // Sem_close
|
|
|
710 // Sem_unlink
|
|
|
711 // Sem_wait
|
|
|
712 // Sem_trywait
|
|
|
713 // Sem_post
|
|
|
714 // Sem_getvalue
|
|
|
715 // Sem_init
|
|
|
716 // Sem_destroy
|
|
|
717 // Open_extended
|
|
|
718 // Umask_extended
|
|
|
719 // Stat_extended
|
|
|
720 // Lstat_extended
|
|
|
721 // Fstat_extended
|
|
|
722 // Chmod_extended
|
|
|
723 // Fchmod_extended
|
|
|
724 // Access_extended
|
|
|
725 // Settid
|
|
|
726 // Gettid
|
|
|
727 // Setsgroups
|
|
|
728 // Getsgroups
|
|
|
729 // Setwgroups
|
|
|
730 // Getwgroups
|
|
|
731 // Mkfifo_extended
|
|
|
732 // Mkdir_extended
|
|
|
733 // Identitysvc
|
|
|
734 // Shared_region_check_np
|
|
|
735 // Shared_region_map_np
|
|
|
736 // __pthread_mutex_destroy
|
|
|
737 // __pthread_mutex_init
|
|
|
738 // __pthread_mutex_lock
|
|
|
739 // __pthread_mutex_trylock
|
|
|
740 // __pthread_mutex_unlock
|
|
|
741 // __pthread_cond_init
|
|
|
742 // __pthread_cond_destroy
|
|
|
743 // __pthread_cond_broadcast
|
|
|
744 // __pthread_cond_signal
|
|
|
745 // Setsid_with_pid
|
|
|
746 // __pthread_cond_timedwait
|
|
|
747 // Aio_fsync
|
|
|
748 // Aio_return
|
|
|
749 // Aio_suspend
|
|
|
750 // Aio_cancel
|
|
|
751 // Aio_error
|
|
|
752 // Aio_read
|
|
|
753 // Aio_write
|
|
|
754 // Lio_listio
|
|
|
755 // __pthread_cond_wait
|
|
|
756 // Iopolicysys
|
|
|
757 // __pthread_kill
|
|
|
758 // __pthread_sigmask
|
|
|
759 // __sigwait
|
|
|
760 // __disable_threadsignal
|
|
|
761 // __pthread_markcancel
|
|
|
762 // __pthread_canceled
|
|
|
763 // __semwait_signal
|
|
|
764 // Proc_info
|
|
|
765 // sendfile
|
|
|
766 // Stat64_extended
|
|
|
767 // Lstat64_extended
|
|
|
768 // Fstat64_extended
|
|
|
769 // __pthread_chdir
|
|
|
770 // __pthread_fchdir
|
|
|
771 // Audit
|
|
|
772 // Auditon
|
|
|
773 // Getauid
|
|
|
774 // Setauid
|
|
|
775 // Getaudit
|
|
|
776 // Setaudit
|
|
|
777 // Getaudit_addr
|
|
|
778 // Setaudit_addr
|
|
|
779 // Auditctl
|
|
|
780 // Bsdthread_create
|
|
|
781 // Bsdthread_terminate
|
|
|
782 // Stack_snapshot
|
|
|
783 // Bsdthread_register
|
|
|
784 // Workq_open
|
|
|
785 // Workq_ops
|
|
|
786 // __mac_execve
|
|
|
787 // __mac_syscall
|
|
|
788 // __mac_get_file
|
|
|
789 // __mac_set_file
|
|
|
790 // __mac_get_link
|
|
|
791 // __mac_set_link
|
|
|
792 // __mac_get_proc
|
|
|
793 // __mac_set_proc
|
|
|
794 // __mac_get_fd
|
|
|
795 // __mac_set_fd
|
|
|
796 // __mac_get_pid
|
|
|
797 // __mac_get_lcid
|
|
|
798 // __mac_get_lctx
|
|
|
799 // __mac_set_lctx
|
|
|
800 // Setlcid
|
|
|
801 // Read_nocancel
|
|
|
802 // Write_nocancel
|
|
|
803 // Open_nocancel
|
|
|
804 // Close_nocancel
|
|
|
805 // Wait4_nocancel
|
|
|
806 // Recvmsg_nocancel
|
|
|
807 // Sendmsg_nocancel
|
|
|
808 // Recvfrom_nocancel
|
|
|
809 // Accept_nocancel
|
|
|
810 // Fcntl_nocancel
|
|
|
811 // Select_nocancel
|
|
|
812 // Fsync_nocancel
|
|
|
813 // Connect_nocancel
|
|
|
814 // Sigsuspend_nocancel
|
|
|
815 // Readv_nocancel
|
|
|
816 // Writev_nocancel
|
|
|
817 // Sendto_nocancel
|
|
|
818 // Pread_nocancel
|
|
|
819 // Pwrite_nocancel
|
|
|
820 // Waitid_nocancel
|
|
|
821 // Poll_nocancel
|
|
|
822 // Msgsnd_nocancel
|
|
|
823 // Msgrcv_nocancel
|
|
|
824 // Sem_wait_nocancel
|
|
|
825 // Aio_suspend_nocancel
|
|
|
826 // __sigwait_nocancel
|
|
|
827 // __semwait_signal_nocancel
|
|
|
828 // __mac_mount
|
|
|
829 // __mac_get_mount
|
|
|
830 // __mac_getfsstat
|
