diff options
author | appilon <apilon@hashicorp.com> | 2019-02-27 16:43:31 -0500 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-02-27 16:43:31 -0500 |
commit | 844b5a68d8af4791755b8f0ad293cc99f5959183 (patch) | |
tree | 255c250a5c9d4801c74092d33b7337d8c14438ff /vendor/golang.org/x/sys/unix/syscall_bsd.go | |
parent | 303b299eeb6b06e939e35905e4b34cb410dd9dc3 (diff) | |
parent | 15c0b25d011f37e7c20aeca9eaf461f78285b8d9 (diff) | |
download | terraform-provider-statuscake-844b5a68d8af4791755b8f0ad293cc99f5959183.tar.gz terraform-provider-statuscake-844b5a68d8af4791755b8f0ad293cc99f5959183.tar.zst terraform-provider-statuscake-844b5a68d8af4791755b8f0ad293cc99f5959183.zip |
Merge pull request #27 from terraform-providers/go-modules-2019-02-22
[MODULES] Switch to Go Modules
Diffstat (limited to 'vendor/golang.org/x/sys/unix/syscall_bsd.go')
-rw-r--r-- | vendor/golang.org/x/sys/unix/syscall_bsd.go | 624 |
1 files changed, 624 insertions, 0 deletions
diff --git a/vendor/golang.org/x/sys/unix/syscall_bsd.go b/vendor/golang.org/x/sys/unix/syscall_bsd.go new file mode 100644 index 0000000..33c8b5f --- /dev/null +++ b/vendor/golang.org/x/sys/unix/syscall_bsd.go | |||
@@ -0,0 +1,624 @@ | |||
1 | // Copyright 2009 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 darwin dragonfly freebsd netbsd openbsd | ||
6 | |||
7 | // BSD system call wrappers shared by *BSD based systems | ||
8 | // including OS X (Darwin) and FreeBSD. Like the other | ||
9 | // syscall_*.go files it is compiled as Go code but also | ||
10 | // used as input to mksyscall which parses the //sys | ||
11 | // lines and generates system call stubs. | ||
12 | |||
13 | package unix | ||
14 | |||
15 | import ( | ||
16 | "runtime" | ||
17 | "syscall" | ||
18 | "unsafe" | ||
19 | ) | ||
20 | |||
21 | /* | ||
22 | * Wrapped | ||
23 | */ | ||
24 | |||
25 | //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) | ||
26 | //sysnb setgroups(ngid int, gid *_Gid_t) (err error) | ||
27 | |||
28 | func Getgroups() (gids []int, err error) { | ||
29 | n, err := getgroups(0, nil) | ||
30 | if err != nil { | ||
31 | return nil, err | ||
32 | } | ||
33 | if n == 0 { | ||
34 | return nil, nil | ||
35 | } | ||
36 | |||
37 | // Sanity check group count. Max is 16 on BSD. | ||
38 | if n < 0 || n > 1000 { | ||
39 | return nil, EINVAL | ||
40 | } | ||
41 | |||
42 | a := make([]_Gid_t, n) | ||
43 | n, err = getgroups(n, &a[0]) | ||
44 | if err != nil { | ||
45 | return nil, err | ||
46 | } | ||
47 | gids = make([]int, n) | ||
48 | for i, v := range a[0:n] { | ||
49 | gids[i] = int(v) | ||
50 | } | ||
51 | return | ||
52 | } | ||
53 | |||
54 | func Setgroups(gids []int) (err error) { | ||
55 | if len(gids) == 0 { | ||
56 | return setgroups(0, nil) | ||
57 | } | ||
58 | |||
59 | a := make([]_Gid_t, len(gids)) | ||
60 | for i, v := range gids { | ||
61 | a[i] = _Gid_t(v) | ||
62 | } | ||
63 | return setgroups(len(a), &a[0]) | ||
64 | } | ||
65 | |||
66 | func ReadDirent(fd int, buf []byte) (n int, err error) { | ||
67 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. | ||
68 | // 64 bits should be enough. (32 bits isn't even on 386). Since the | ||
69 | // actual system call is getdirentries64, 64 is a good guess. | ||
70 | // TODO(rsc): Can we use a single global basep for all calls? | ||
71 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) | ||
72 | return Getdirentries(fd, buf, base) | ||
73 | } | ||
74 | |||
75 | // Wait status is 7 bits at bottom, either 0 (exited), | ||
76 | // 0x7F (stopped), or a signal number that caused an exit. | ||
77 | // The 0x80 bit is whether there was a core dump. | ||
78 | // An extra number (exit code, signal causing a stop) | ||
79 | // is in the high bits. | ||
80 | |||
81 | type WaitStatus uint32 | ||
82 | |||
83 | const ( | ||
84 | mask = 0x7F | ||
85 | core = 0x80 | ||
86 | shift = 8 | ||
87 | |||
88 | exited = 0 | ||
89 | stopped = 0x7F | ||
90 | ) | ||
91 | |||
92 | func (w WaitStatus) Exited() bool { return w&mask == exited } | ||
93 | |||
94 | func (w WaitStatus) ExitStatus() int { | ||
95 | if w&mask != exited { | ||
96 | return -1 | ||
97 | } | ||
98 | return int(w >> shift) | ||
99 | } | ||
100 | |||
101 | func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } | ||
102 | |||
103 | func (w WaitStatus) Signal() syscall.Signal { | ||
104 | sig := syscall.Signal(w & mask) | ||
105 | if sig == stopped || sig == 0 { | ||
106 | return -1 | ||
107 | } | ||
108 | return sig | ||
109 | } | ||
110 | |||
111 | func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } | ||
112 | |||
113 | func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP } | ||
114 | |||
115 | func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP } | ||
116 | |||
117 | func (w WaitStatus) StopSignal() syscall.Signal { | ||
118 | if !w.Stopped() { | ||
119 | return -1 | ||
120 | } | ||
121 | return syscall.Signal(w>>shift) & 0xFF | ||
122 | } | ||
123 | |||
124 | func (w WaitStatus) TrapCause() int { return -1 } | ||
125 | |||
126 | //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) | ||
127 | |||
128 | func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { | ||
129 | var status _C_int | ||
130 | wpid, err = wait4(pid, &status, options, rusage) | ||
131 | if wstatus != nil { | ||
132 | *wstatus = WaitStatus(status) | ||
133 | } | ||
134 | return | ||
135 | } | ||
136 | |||
137 | //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) | ||
138 | //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | ||
139 | //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | ||
140 | //sysnb socket(domain int, typ int, proto int) (fd int, err error) | ||
141 | //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) | ||
142 | //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) | ||
143 | //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | ||
144 | //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | ||
145 | //sys Shutdown(s int, how int) (err error) | ||
146 | |||
147 | func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
148 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
149 | return nil, 0, EINVAL | ||
150 | } | ||
151 | sa.raw.Len = SizeofSockaddrInet4 | ||
152 | sa.raw.Family = AF_INET | ||
153 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
154 | p[0] = byte(sa.Port >> 8) | ||
155 | p[1] = byte(sa.Port) | ||
156 | for i := 0; i < len(sa.Addr); i++ { | ||
157 | sa.raw.Addr[i] = sa.Addr[i] | ||
158 | } | ||
159 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | ||
160 | } | ||
161 | |||
162 | func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
163 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
164 | return nil, 0, EINVAL | ||
165 | } | ||
166 | sa.raw.Len = SizeofSockaddrInet6 | ||
167 | sa.raw.Family = AF_INET6 | ||
168 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
169 | p[0] = byte(sa.Port >> 8) | ||
170 | p[1] = byte(sa.Port) | ||
171 | sa.raw.Scope_id = sa.ZoneId | ||
172 | for i := 0; i < len(sa.Addr); i++ { | ||
173 | sa.raw.Addr[i] = sa.Addr[i] | ||
174 | } | ||
175 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | ||
176 | } | ||
177 | |||
178 | func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
179 | name := sa.Name | ||
180 | n := len(name) | ||
181 | if n >= len(sa.raw.Path) || n == 0 { | ||
182 | return nil, 0, EINVAL | ||
183 | } | ||
184 | sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL | ||
185 | sa.raw.Family = AF_UNIX | ||
186 | for i := 0; i < n; i++ { | ||
187 | sa.raw.Path[i] = int8(name[i]) | ||
188 | } | ||
189 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | ||
190 | } | ||
191 | |||
192 | func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
193 | if sa.Index == 0 { | ||
194 | return nil, 0, EINVAL | ||
195 | } | ||
196 | sa.raw.Len = sa.Len | ||
197 | sa.raw.Family = AF_LINK | ||
198 | sa.raw.Index = sa.Index | ||
199 | sa.raw.Type = sa.Type | ||
200 | sa.raw.Nlen = sa.Nlen | ||
201 | sa.raw.Alen = sa.Alen | ||
202 | sa.raw.Slen = sa.Slen | ||
203 | for i := 0; i < len(sa.raw.Data); i++ { | ||
204 | sa.raw.Data[i] = sa.Data[i] | ||
205 | } | ||
206 | return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil | ||
207 | } | ||
208 | |||
209 | func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { | ||
210 | switch rsa.Addr.Family { | ||
211 | case AF_LINK: | ||
212 | pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa)) | ||
213 | sa := new(SockaddrDatalink) | ||
214 | sa.Len = pp.Len | ||
215 | sa.Family = pp.Family | ||
216 | sa.Index = pp.Index | ||
217 | sa.Type = pp.Type | ||
218 | sa.Nlen = pp.Nlen | ||
219 | sa.Alen = pp.Alen | ||
220 | sa.Slen = pp.Slen | ||
221 | for i := 0; i < len(sa.Data); i++ { | ||
222 | sa.Data[i] = pp.Data[i] | ||
223 | } | ||
224 | return sa, nil | ||
225 | |||
226 | case AF_UNIX: | ||
227 | pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) | ||
228 | if pp.Len < 2 || pp.Len > SizeofSockaddrUnix { | ||
229 | return nil, EINVAL | ||
230 | } | ||
231 | sa := new(SockaddrUnix) | ||
232 | |||
233 | // Some BSDs include the trailing NUL in the length, whereas | ||
234 | // others do not. Work around this by subtracting the leading | ||
235 | // family and len. The path is then scanned to see if a NUL | ||
236 | // terminator still exists within the length. | ||
237 | n := int(pp.Len) - 2 // subtract leading Family, Len | ||
238 | for i := 0; i < n; i++ { | ||
239 | if pp.Path[i] == 0 { | ||
240 | // found early NUL; assume Len included the NUL | ||
241 | // or was overestimating. | ||
242 | n = i | ||
243 | break | ||
244 | } | ||
245 | } | ||
246 | bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] | ||
247 | sa.Name = string(bytes) | ||
248 | return sa, nil | ||
249 | |||
250 | case AF_INET: | ||
251 | pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) | ||
252 | sa := new(SockaddrInet4) | ||
253 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
254 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
255 | for i := 0; i < len(sa.Addr); i++ { | ||
256 | sa.Addr[i] = pp.Addr[i] | ||
257 | } | ||
258 | return sa, nil | ||
259 | |||
260 | case AF_INET6: | ||
261 | pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) | ||
262 | sa := new(SockaddrInet6) | ||
263 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
264 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
265 | sa.ZoneId = pp.Scope_id | ||
266 | for i := 0; i < len(sa.Addr); i++ { | ||
267 | sa.Addr[i] = pp.Addr[i] | ||
268 | } | ||
269 | return sa, nil | ||
270 | } | ||
271 | return nil, EAFNOSUPPORT | ||
272 | } | ||
273 | |||
274 | func Accept(fd int) (nfd int, sa Sockaddr, err error) { | ||
275 | var rsa RawSockaddrAny | ||
276 | var len _Socklen = SizeofSockaddrAny | ||
277 | nfd, err = accept(fd, &rsa, &len) | ||
278 | if err != nil { | ||
279 | return | ||
280 | } | ||
281 | if runtime.GOOS == "darwin" && len == 0 { | ||
282 | // Accepted socket has no address. | ||
283 | // This is likely due to a bug in xnu kernels, | ||
284 | // where instead of ECONNABORTED error socket | ||
285 | // is accepted, but has no address. | ||
286 | Close(nfd) | ||
287 | return 0, nil, ECONNABORTED | ||
288 | } | ||
289 | sa, err = anyToSockaddr(fd, &rsa) | ||
290 | if err != nil { | ||
291 | Close(nfd) | ||
292 | nfd = 0 | ||
293 | } | ||
294 | return | ||
295 | } | ||
296 | |||
297 | func Getsockname(fd int) (sa Sockaddr, err error) { | ||
298 | var rsa RawSockaddrAny | ||
299 | var len _Socklen = SizeofSockaddrAny | ||
300 | if err = getsockname(fd, &rsa, &len); err != nil { | ||
301 | return | ||
302 | } | ||
303 | // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be | ||
304 | // reported upstream. | ||
305 | if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { | ||
306 | rsa.Addr.Family = AF_UNIX | ||
307 | rsa.Addr.Len = SizeofSockaddrUnix | ||
308 | } | ||
309 | return anyToSockaddr(fd, &rsa) | ||
310 | } | ||
311 | |||
312 | //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) | ||
313 | |||
314 | // GetsockoptString returns the string value of the socket option opt for the | ||
315 | // socket associated with fd at the given socket level. | ||
316 | func GetsockoptString(fd, level, opt int) (string, error) { | ||
317 | buf := make([]byte, 256) | ||
318 | vallen := _Socklen(len(buf)) | ||
319 | err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) | ||
320 | if err != nil { | ||
321 | return "", err | ||
322 | } | ||
323 | return string(buf[:vallen-1]), nil | ||
324 | } | ||
325 | |||
326 | //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) | ||
327 | //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) | ||
328 | //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
329 | |||
330 | func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { | ||
331 | var msg Msghdr | ||
332 | var rsa RawSockaddrAny | ||
333 | msg.Name = (*byte)(unsafe.Pointer(&rsa)) | ||
334 | msg.Namelen = uint32(SizeofSockaddrAny) | ||
335 | var iov Iovec | ||
336 | if len(p) > 0 { | ||
337 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | ||
338 | iov.SetLen(len(p)) | ||
339 | } | ||
340 | var dummy byte | ||
341 | if len(oob) > 0 { | ||
342 | // receive at least one normal byte | ||
343 | if len(p) == 0 { | ||
344 | iov.Base = &dummy | ||
345 | iov.SetLen(1) | ||
346 | } | ||
347 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | ||
348 | msg.SetControllen(len(oob)) | ||
349 | } | ||
350 | msg.Iov = &iov | ||
351 | msg.Iovlen = 1 | ||
352 | if n, err = recvmsg(fd, &msg, flags); err != nil { | ||
353 | return | ||
354 | } | ||
355 | oobn = int(msg.Controllen) | ||
356 | recvflags = int(msg.Flags) | ||
357 | // source address is only specified if the socket is unconnected | ||
358 | if rsa.Addr.Family != AF_UNSPEC { | ||
359 | from, err = anyToSockaddr(fd, &rsa) | ||
360 | } | ||
361 | return | ||
362 | } | ||
363 | |||
364 | //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
365 | |||
366 | func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { | ||
367 | _, err = SendmsgN(fd, p, oob, to, flags) | ||
368 | return | ||
369 | } | ||
370 | |||
371 | func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { | ||
372 | var ptr unsafe.Pointer | ||
373 | var salen _Socklen | ||
374 | if to != nil { | ||
375 | ptr, salen, err = to.sockaddr() | ||
376 | if err != nil { | ||
377 | return 0, err | ||
378 | } | ||
379 | } | ||
380 | var msg Msghdr | ||
381 | msg.Name = (*byte)(unsafe.Pointer(ptr)) | ||
382 | msg.Namelen = uint32(salen) | ||
383 | var iov Iovec | ||
384 | if len(p) > 0 { | ||
385 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | ||
386 | iov.SetLen(len(p)) | ||
387 | } | ||
388 | var dummy byte | ||
389 | if len(oob) > 0 { | ||
390 | // send at least one normal byte | ||
391 | if len(p) == 0 { | ||
392 | iov.Base = &dummy | ||
393 | iov.SetLen(1) | ||
394 | } | ||
395 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | ||
396 | msg.SetControllen(len(oob)) | ||
397 | } | ||
398 | msg.Iov = &iov | ||
399 | msg.Iovlen = 1 | ||
400 | if n, err = sendmsg(fd, &msg, flags); err != nil { | ||
401 | return 0, err | ||
402 | } | ||
403 | if len(oob) > 0 && len(p) == 0 { | ||
404 | n = 0 | ||
405 | } | ||
406 | return n, nil | ||
407 | } | ||
408 | |||
409 | //sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) | ||
410 | |||
411 | func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { | ||
412 | var change, event unsafe.Pointer | ||
413 | if len(changes) > 0 { | ||
414 | change = unsafe.Pointer(&changes[0]) | ||
415 | } | ||
416 | if len(events) > 0 { | ||
417 | event = unsafe.Pointer(&events[0]) | ||
418 | } | ||
419 | return kevent(kq, change, len(changes), event, len(events), timeout) | ||
420 | } | ||
421 | |||
422 | //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL | ||
423 | |||
424 | // sysctlmib translates name to mib number and appends any additional args. | ||
425 | func sysctlmib(name string, args ...int) ([]_C_int, error) { | ||
426 | // Translate name to mib number. | ||
427 | mib, err := nametomib(name) | ||
428 | if err != nil { | ||
429 | return nil, err | ||
430 | } | ||
431 | |||
432 | for _, a := range args { | ||
433 | mib = append(mib, _C_int(a)) | ||
434 | } | ||
435 | |||
436 | return mib, nil | ||
437 | } | ||
438 | |||
439 | func Sysctl(name string) (string, error) { | ||
440 | return SysctlArgs(name) | ||
441 | } | ||
442 | |||
443 | func SysctlArgs(name string, args ...int) (string, error) { | ||
444 | buf, err := SysctlRaw(name, args...) | ||
445 | if err != nil { | ||
446 | return "", err | ||
447 | } | ||
448 | n := len(buf) | ||
449 | |||
450 | // Throw away terminating NUL. | ||
451 | if n > 0 && buf[n-1] == '\x00' { | ||
452 | n-- | ||
453 | } | ||
454 | return string(buf[0:n]), nil | ||
455 | } | ||
456 | |||
457 | func SysctlUint32(name string) (uint32, error) { | ||
458 | return SysctlUint32Args(name) | ||
459 | } | ||
460 | |||
461 | func SysctlUint32Args(name string, args ...int) (uint32, error) { | ||
462 | mib, err := sysctlmib(name, args...) | ||
463 | if err != nil { | ||
464 | return 0, err | ||
465 | } | ||
466 | |||
467 | n := uintptr(4) | ||
468 | buf := make([]byte, 4) | ||
469 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
470 | return 0, err | ||
471 | } | ||
472 | if n != 4 { | ||
473 | return 0, EIO | ||
474 | } | ||
475 | return *(*uint32)(unsafe.Pointer(&buf[0])), nil | ||
476 | } | ||
477 | |||
478 | func SysctlUint64(name string, args ...int) (uint64, error) { | ||
479 | mib, err := sysctlmib(name, args...) | ||
480 | if err != nil { | ||
481 | return 0, err | ||
482 | } | ||
483 | |||
484 | n := uintptr(8) | ||
485 | buf := make([]byte, 8) | ||
486 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
487 | return 0, err | ||
488 | } | ||
489 | if n != 8 { | ||
490 | return 0, EIO | ||
491 | } | ||
492 | return *(*uint64)(unsafe.Pointer(&buf[0])), nil | ||
493 | } | ||
494 | |||
495 | func SysctlRaw(name string, args ...int) ([]byte, error) { | ||
496 | mib, err := sysctlmib(name, args...) | ||
497 | if err != nil { | ||
498 | return nil, err | ||
499 | } | ||
500 | |||
501 | // Find size. | ||
502 | n := uintptr(0) | ||
503 | if err := sysctl(mib, nil, &n, nil, 0); err != nil { | ||
504 | return nil, err | ||
505 | } | ||
506 | if n == 0 { | ||
507 | return nil, nil | ||
508 | } | ||
509 | |||
510 | // Read into buffer of that size. | ||
511 | buf := make([]byte, n) | ||
512 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
513 | return nil, err | ||
514 | } | ||
515 | |||
516 | // The actual call may return less than the original reported required | ||
517 | // size so ensure we deal with that. | ||
518 | return buf[:n], nil | ||
519 | } | ||
520 | |||
521 | //sys utimes(path string, timeval *[2]Timeval) (err error) | ||
522 | |||
523 | func Utimes(path string, tv []Timeval) error { | ||
524 | if tv == nil { | ||
525 | return utimes(path, nil) | ||
526 | } | ||
527 | if len(tv) != 2 { | ||
528 | return EINVAL | ||
529 | } | ||
530 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
531 | } | ||
532 | |||
533 | func UtimesNano(path string, ts []Timespec) error { | ||
534 | if ts == nil { | ||
535 | err := utimensat(AT_FDCWD, path, nil, 0) | ||
536 | if err != ENOSYS { | ||
537 | return err | ||
538 | } | ||
539 | return utimes(path, nil) | ||
540 | } | ||
541 | if len(ts) != 2 { | ||
542 | return EINVAL | ||
543 | } | ||
544 | // Darwin setattrlist can set nanosecond timestamps | ||
545 | err := setattrlistTimes(path, ts, 0) | ||
546 | if err != ENOSYS { | ||
547 | return err | ||
548 | } | ||
549 | err = utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) | ||
550 | if err != ENOSYS { | ||
551 | return err | ||
552 | } | ||
553 | // Not as efficient as it could be because Timespec and | ||
554 | // Timeval have different types in the different OSes | ||
555 | tv := [2]Timeval{ | ||
556 | NsecToTimeval(TimespecToNsec(ts[0])), | ||
557 | NsecToTimeval(TimespecToNsec(ts[1])), | ||
558 | } | ||
559 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
560 | } | ||
561 | |||
562 | func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { | ||
563 | if ts == nil { | ||
564 | return utimensat(dirfd, path, nil, flags) | ||
565 | } | ||
566 | if len(ts) != 2 { | ||
567 | return EINVAL | ||
568 | } | ||
569 | err := setattrlistTimes(path, ts, flags) | ||
570 | if err != ENOSYS { | ||
571 | return err | ||
572 | } | ||
573 | return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) | ||
574 | } | ||
575 | |||
576 | //sys futimes(fd int, timeval *[2]Timeval) (err error) | ||
577 | |||
578 | func Futimes(fd int, tv []Timeval) error { | ||
579 | if tv == nil { | ||
580 | return futimes(fd, nil) | ||
581 | } | ||
582 | if len(tv) != 2 { | ||
583 | return EINVAL | ||
584 | } | ||
585 | return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
586 | } | ||
587 | |||
588 | //sys fcntl(fd int, cmd int, arg int) (val int, err error) | ||
589 | |||
590 | //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) | ||
591 | |||
592 | func Poll(fds []PollFd, timeout int) (n int, err error) { | ||
593 | if len(fds) == 0 { | ||
594 | return poll(nil, 0, timeout) | ||
595 | } | ||
596 | return poll(&fds[0], len(fds), timeout) | ||
597 | } | ||
598 | |||
599 | // TODO: wrap | ||
600 | // Acct(name nil-string) (err error) | ||
601 | // Gethostuuid(uuid *byte, timeout *Timespec) (err error) | ||
602 | // Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error) | ||
603 | |||
604 | var mapper = &mmapper{ | ||
605 | active: make(map[*byte][]byte), | ||
606 | mmap: mmap, | ||
607 | munmap: munmap, | ||
608 | } | ||
609 | |||
610 | func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { | ||
611 | return mapper.Mmap(fd, offset, length, prot, flags) | ||
612 | } | ||
613 | |||
614 | func Munmap(b []byte) (err error) { | ||
615 | return mapper.Munmap(b) | ||
616 | } | ||
617 | |||
618 | //sys Madvise(b []byte, behav int) (err error) | ||
619 | //sys Mlock(b []byte) (err error) | ||
620 | //sys Mlockall(flags int) (err error) | ||
621 | //sys Mprotect(b []byte, prot int) (err error) | ||
622 | //sys Msync(b []byte, flags int) (err error) | ||
623 | //sys Munlock(b []byte) (err error) | ||
624 | //sys Munlockall() (err error) | ||