diff options
author | Alex Pilon <apilon@hashicorp.com> | 2019-02-22 18:24:22 -0500 |
---|---|---|
committer | Alex Pilon <apilon@hashicorp.com> | 2019-02-22 18:24:22 -0500 |
commit | 07971ca38143c5faf951d152fba370ddcbe26ad5 (patch) | |
tree | 09af1ef91c782de921efc83113907184c8adecee /vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go | |
parent | 9b6f05970a001f683b9c886c652de81f00cd5f00 (diff) | |
download | terraform-provider-statuscake-07971ca38143c5faf951d152fba370ddcbe26ad5.tar.gz terraform-provider-statuscake-07971ca38143c5faf951d152fba370ddcbe26ad5.tar.zst terraform-provider-statuscake-07971ca38143c5faf951d152fba370ddcbe26ad5.zip |
deps: use go modules for dep mgmt
run go mod tidy
remove govendor from makefile and travis config
set appropriate env vars for go modules
Diffstat (limited to 'vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go')
-rw-r--r-- | vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go | 628 |
1 files changed, 0 insertions, 628 deletions
diff --git a/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go b/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go deleted file mode 100644 index e967176..0000000 --- a/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.go +++ /dev/null | |||
@@ -1,628 +0,0 @@ | |||
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(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(&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(&rsa) | ||
310 | } | ||
311 | |||
312 | //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) | ||
313 | |||
314 | func GetsockoptByte(fd, level, opt int) (value byte, err error) { | ||
315 | var n byte | ||
316 | vallen := _Socklen(1) | ||
317 | err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) | ||
318 | return n, err | ||
319 | } | ||
320 | |||
321 | func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) { | ||
322 | vallen := _Socklen(4) | ||
323 | err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) | ||
324 | return value, err | ||
325 | } | ||
326 | |||
327 | func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) { | ||
328 | var value IPMreq | ||
329 | vallen := _Socklen(SizeofIPMreq) | ||
330 | err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) | ||
331 | return &value, err | ||
332 | } | ||
333 | |||
334 | func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) { | ||
335 | var value IPv6Mreq | ||
336 | vallen := _Socklen(SizeofIPv6Mreq) | ||
337 | err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) | ||
338 | return &value, err | ||
339 | } | ||
340 | |||
341 | func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) { | ||
342 | var value IPv6MTUInfo | ||
343 | vallen := _Socklen(SizeofIPv6MTUInfo) | ||
344 | err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) | ||
345 | return &value, err | ||
346 | } | ||
347 | |||
348 | func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) { | ||
349 | var value ICMPv6Filter | ||
350 | vallen := _Socklen(SizeofICMPv6Filter) | ||
351 | err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) | ||
352 | return &value, err | ||
353 | } | ||
354 | |||
355 | //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) | ||
356 | //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) | ||
357 | //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
358 | |||
359 | func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { | ||
360 | var msg Msghdr | ||
361 | var rsa RawSockaddrAny | ||
362 | msg.Name = (*byte)(unsafe.Pointer(&rsa)) | ||
363 | msg.Namelen = uint32(SizeofSockaddrAny) | ||
364 | var iov Iovec | ||
365 | if len(p) > 0 { | ||
366 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | ||
367 | iov.SetLen(len(p)) | ||
368 | } | ||
369 | var dummy byte | ||
370 | if len(oob) > 0 { | ||
371 | // receive at least one normal byte | ||
372 | if len(p) == 0 { | ||
373 | iov.Base = &dummy | ||
374 | iov.SetLen(1) | ||
375 | } | ||
376 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | ||
377 | msg.SetControllen(len(oob)) | ||
378 | } | ||
379 | msg.Iov = &iov | ||
380 | msg.Iovlen = 1 | ||
381 | if n, err = recvmsg(fd, &msg, flags); err != nil { | ||
382 | return | ||
383 | } | ||
384 | oobn = int(msg.Controllen) | ||
385 | recvflags = int(msg.Flags) | ||
386 | // source address is only specified if the socket is unconnected | ||
387 | if rsa.Addr.Family != AF_UNSPEC { | ||
388 | from, err = anyToSockaddr(&rsa) | ||
389 | } | ||
390 | return | ||
391 | } | ||
392 | |||
393 | //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
394 | |||
395 | func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { | ||
396 | _, err = SendmsgN(fd, p, oob, to, flags) | ||
397 | return | ||
398 | } | ||
399 | |||
400 | func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { | ||
401 | var ptr unsafe.Pointer | ||
402 | var salen _Socklen | ||
403 | if to != nil { | ||
404 | ptr, salen, err = to.sockaddr() | ||
405 | if err != nil { | ||
406 | return 0, err | ||
407 | } | ||
408 | } | ||
409 | var msg Msghdr | ||
410 | msg.Name = (*byte)(unsafe.Pointer(ptr)) | ||
411 | msg.Namelen = uint32(salen) | ||
412 | var iov Iovec | ||
413 | if len(p) > 0 { | ||
414 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | ||
415 | iov.SetLen(len(p)) | ||
416 | } | ||
417 | var dummy byte | ||
418 | if len(oob) > 0 { | ||
419 | // send at least one normal byte | ||
420 | if len(p) == 0 { | ||
421 | iov.Base = &dummy | ||
422 | iov.SetLen(1) | ||
423 | } | ||
424 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | ||
425 | msg.SetControllen(len(oob)) | ||
426 | } | ||
427 | msg.Iov = &iov | ||
428 | msg.Iovlen = 1 | ||
429 | if n, err = sendmsg(fd, &msg, flags); err != nil { | ||
430 | return 0, err | ||
431 | } | ||
432 | if len(oob) > 0 && len(p) == 0 { | ||
433 | n = 0 | ||
434 | } | ||
435 | return n, nil | ||
436 | } | ||
437 | |||
438 | //sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) | ||
439 | |||
440 | func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { | ||
441 | var change, event unsafe.Pointer | ||
442 | if len(changes) > 0 { | ||
443 | change = unsafe.Pointer(&changes[0]) | ||
444 | } | ||
445 | if len(events) > 0 { | ||
446 | event = unsafe.Pointer(&events[0]) | ||
447 | } | ||
448 | return kevent(kq, change, len(changes), event, len(events), timeout) | ||
449 | } | ||
450 | |||
451 | //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL | ||
452 | |||
453 | // sysctlmib translates name to mib number and appends any additional args. | ||
454 | func sysctlmib(name string, args ...int) ([]_C_int, error) { | ||
455 | // Translate name to mib number. | ||
456 | mib, err := nametomib(name) | ||
457 | if err != nil { | ||
458 | return nil, err | ||
459 | } | ||
460 | |||
461 | for _, a := range args { | ||
462 | mib = append(mib, _C_int(a)) | ||
463 | } | ||
464 | |||
465 | return mib, nil | ||
466 | } | ||
467 | |||
468 | func Sysctl(name string) (string, error) { | ||
469 | return SysctlArgs(name) | ||
470 | } | ||
471 | |||
472 | func SysctlArgs(name string, args ...int) (string, error) { | ||
473 | mib, err := sysctlmib(name, args...) | ||
474 | if err != nil { | ||
475 | return "", err | ||
476 | } | ||
477 | |||
478 | // Find size. | ||
479 | n := uintptr(0) | ||
480 | if err := sysctl(mib, nil, &n, nil, 0); err != nil { | ||
481 | return "", err | ||
482 | } | ||
483 | if n == 0 { | ||
484 | return "", nil | ||
485 | } | ||
486 | |||
487 | // Read into buffer of that size. | ||
488 | buf := make([]byte, n) | ||
489 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
490 | return "", err | ||
491 | } | ||
492 | |||
493 | // Throw away terminating NUL. | ||
494 | if n > 0 && buf[n-1] == '\x00' { | ||
495 | n-- | ||
496 | } | ||
497 | return string(buf[0:n]), nil | ||
498 | } | ||
499 | |||
500 | func SysctlUint32(name string) (uint32, error) { | ||
501 | return SysctlUint32Args(name) | ||
502 | } | ||
503 | |||
504 | func SysctlUint32Args(name string, args ...int) (uint32, error) { | ||
505 | mib, err := sysctlmib(name, args...) | ||
506 | if err != nil { | ||
507 | return 0, err | ||
508 | } | ||
509 | |||
510 | n := uintptr(4) | ||
511 | buf := make([]byte, 4) | ||
512 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
513 | return 0, err | ||
514 | } | ||
515 | if n != 4 { | ||
516 | return 0, EIO | ||
517 | } | ||
518 | return *(*uint32)(unsafe.Pointer(&buf[0])), nil | ||
519 | } | ||
520 | |||
521 | func SysctlUint64(name string, args ...int) (uint64, error) { | ||
522 | mib, err := sysctlmib(name, args...) | ||
523 | if err != nil { | ||
524 | return 0, err | ||
525 | } | ||
526 | |||
527 | n := uintptr(8) | ||
528 | buf := make([]byte, 8) | ||
529 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
530 | return 0, err | ||
531 | } | ||
532 | if n != 8 { | ||
533 | return 0, EIO | ||
534 | } | ||
535 | return *(*uint64)(unsafe.Pointer(&buf[0])), nil | ||
536 | } | ||
537 | |||
538 | func SysctlRaw(name string, args ...int) ([]byte, error) { | ||
539 | mib, err := sysctlmib(name, args...) | ||
540 | if err != nil { | ||
541 | return nil, err | ||
542 | } | ||
543 | |||
544 | // Find size. | ||
545 | n := uintptr(0) | ||
546 | if err := sysctl(mib, nil, &n, nil, 0); err != nil { | ||
547 | return nil, err | ||
548 | } | ||
549 | if n == 0 { | ||
550 | return nil, nil | ||
551 | } | ||
552 | |||
553 | // Read into buffer of that size. | ||
554 | buf := make([]byte, n) | ||
555 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | ||
556 | return nil, err | ||
557 | } | ||
558 | |||
559 | // The actual call may return less than the original reported required | ||
560 | // size so ensure we deal with that. | ||
561 | return buf[:n], nil | ||
562 | } | ||
563 | |||
564 | //sys utimes(path string, timeval *[2]Timeval) (err error) | ||
565 | |||
566 | func Utimes(path string, tv []Timeval) error { | ||
567 | if tv == nil { | ||
568 | return utimes(path, nil) | ||
569 | } | ||
570 | if len(tv) != 2 { | ||
571 | return EINVAL | ||
572 | } | ||
573 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
574 | } | ||
575 | |||
576 | func UtimesNano(path string, ts []Timespec) error { | ||
577 | if ts == nil { | ||
578 | return utimes(path, nil) | ||
579 | } | ||
580 | // TODO: The BSDs can do utimensat with SYS_UTIMENSAT but it | ||
581 | // isn't supported by darwin so this uses utimes instead | ||
582 | if len(ts) != 2 { | ||
583 | return EINVAL | ||
584 | } | ||
585 | // Not as efficient as it could be because Timespec and | ||
586 | // Timeval have different types in the different OSes | ||
587 | tv := [2]Timeval{ | ||
588 | NsecToTimeval(TimespecToNsec(ts[0])), | ||
589 | NsecToTimeval(TimespecToNsec(ts[1])), | ||
590 | } | ||
591 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
592 | } | ||
593 | |||
594 | //sys futimes(fd int, timeval *[2]Timeval) (err error) | ||
595 | |||
596 | func Futimes(fd int, tv []Timeval) error { | ||
597 | if tv == nil { | ||
598 | return futimes(fd, nil) | ||
599 | } | ||
600 | if len(tv) != 2 { | ||
601 | return EINVAL | ||
602 | } | ||
603 | return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
604 | } | ||
605 | |||
606 | //sys fcntl(fd int, cmd int, arg int) (val int, err error) | ||
607 | |||
608 | // TODO: wrap | ||
609 | // Acct(name nil-string) (err error) | ||
610 | // Gethostuuid(uuid *byte, timeout *Timespec) (err error) | ||
611 | // Madvise(addr *byte, len int, behav int) (err error) | ||
612 | // Mprotect(addr *byte, len int, prot int) (err error) | ||
613 | // Msync(addr *byte, len int, flags int) (err error) | ||
614 | // Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error) | ||
615 | |||
616 | var mapper = &mmapper{ | ||
617 | active: make(map[*byte][]byte), | ||
618 | mmap: mmap, | ||
619 | munmap: munmap, | ||
620 | } | ||
621 | |||
622 | func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { | ||
623 | return mapper.Mmap(fd, offset, length, prot, flags) | ||
624 | } | ||
625 | |||
626 | func Munmap(b []byte) (err error) { | ||
627 | return mapper.Munmap(b) | ||
628 | } | ||