diff options
Diffstat (limited to 'vendor/golang.org/x/sys/unix/syscall_aix.go')
-rw-r--r-- | vendor/golang.org/x/sys/unix/syscall_aix.go | 547 |
1 files changed, 547 insertions, 0 deletions
diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go new file mode 100644 index 0000000..f8eac17 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/syscall_aix.go | |||
@@ -0,0 +1,547 @@ | |||
1 | // Copyright 2018 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 | ||
6 | |||
7 | // Aix system calls. | ||
8 | // This file is compiled as ordinary Go code, | ||
9 | // but it is also input to mksyscall, | ||
10 | // which parses the //sys lines and generates system call stubs. | ||
11 | // Note that sometimes we use a lowercase //sys name and | ||
12 | // wrap it in our own nicer implementation. | ||
13 | |||
14 | package unix | ||
15 | |||
16 | import ( | ||
17 | "syscall" | ||
18 | "unsafe" | ||
19 | ) | ||
20 | |||
21 | /* | ||
22 | * Wrapped | ||
23 | */ | ||
24 | |||
25 | //sys utimes(path string, times *[2]Timeval) (err error) | ||
26 | func Utimes(path string, tv []Timeval) error { | ||
27 | if len(tv) != 2 { | ||
28 | return EINVAL | ||
29 | } | ||
30 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
31 | } | ||
32 | |||
33 | //sys utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) | ||
34 | func UtimesNano(path string, ts []Timespec) error { | ||
35 | if len(ts) != 2 { | ||
36 | return EINVAL | ||
37 | } | ||
38 | return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) | ||
39 | } | ||
40 | |||
41 | func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { | ||
42 | if ts == nil { | ||
43 | return utimensat(dirfd, path, nil, flags) | ||
44 | } | ||
45 | if len(ts) != 2 { | ||
46 | return EINVAL | ||
47 | } | ||
48 | return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) | ||
49 | } | ||
50 | |||
51 | func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
52 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
53 | return nil, 0, EINVAL | ||
54 | } | ||
55 | sa.raw.Family = AF_INET | ||
56 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
57 | p[0] = byte(sa.Port >> 8) | ||
58 | p[1] = byte(sa.Port) | ||
59 | for i := 0; i < len(sa.Addr); i++ { | ||
60 | sa.raw.Addr[i] = sa.Addr[i] | ||
61 | } | ||
62 | return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil | ||
63 | } | ||
64 | |||
65 | func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
66 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
67 | return nil, 0, EINVAL | ||
68 | } | ||
69 | sa.raw.Family = AF_INET6 | ||
70 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
71 | p[0] = byte(sa.Port >> 8) | ||
72 | p[1] = byte(sa.Port) | ||
73 | sa.raw.Scope_id = sa.ZoneId | ||
74 | for i := 0; i < len(sa.Addr); i++ { | ||
75 | sa.raw.Addr[i] = sa.Addr[i] | ||
76 | } | ||
77 | return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil | ||
78 | } | ||
79 | |||
80 | func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
81 | name := sa.Name | ||
82 | n := len(name) | ||
83 | if n > len(sa.raw.Path) { | ||
84 | return nil, 0, EINVAL | ||
85 | } | ||
86 | if n == len(sa.raw.Path) && name[0] != '@' { | ||
87 | return nil, 0, EINVAL | ||
88 | } | ||
89 | sa.raw.Family = AF_UNIX | ||
90 | for i := 0; i < n; i++ { | ||
91 | sa.raw.Path[i] = uint8(name[i]) | ||
92 | } | ||
93 | // length is family (uint16), name, NUL. | ||
94 | sl := _Socklen(2) | ||
95 | if n > 0 { | ||
96 | sl += _Socklen(n) + 1 | ||
97 | } | ||
98 | if sa.raw.Path[0] == '@' { | ||
99 | sa.raw.Path[0] = 0 | ||
100 | // Don't count trailing NUL for abstract address. | ||
101 | sl-- | ||
102 | } | ||
103 | |||
104 | return unsafe.Pointer(&sa.raw), sl, nil | ||
105 | } | ||
106 | |||
107 | func Getsockname(fd int) (sa Sockaddr, err error) { | ||
108 | var rsa RawSockaddrAny | ||
109 | var len _Socklen = SizeofSockaddrAny | ||
110 | if err = getsockname(fd, &rsa, &len); err != nil { | ||
111 | return | ||
112 | } | ||
113 | return anyToSockaddr(fd, &rsa) | ||
114 | } | ||
115 | |||
116 | //sys getcwd(buf []byte) (err error) | ||
117 | |||
118 | const ImplementsGetwd = true | ||
119 | |||
120 | func Getwd() (ret string, err error) { | ||
121 | for len := uint64(4096); ; len *= 2 { | ||
122 | b := make([]byte, len) | ||
123 | err := getcwd(b) | ||
124 | if err == nil { | ||
125 | i := 0 | ||
126 | for b[i] != 0 { | ||
127 | i++ | ||
128 | } | ||
129 | return string(b[0:i]), nil | ||
130 | } | ||
131 | if err != ERANGE { | ||
132 | return "", err | ||
133 | } | ||
134 | } | ||
135 | } | ||
136 | |||
137 | func Getcwd(buf []byte) (n int, err error) { | ||
138 | err = getcwd(buf) | ||
139 | if err == nil { | ||
140 | i := 0 | ||
141 | for buf[i] != 0 { | ||
142 | i++ | ||
143 | } | ||
144 | n = i + 1 | ||
145 | } | ||
146 | return | ||
147 | } | ||
148 | |||
149 | func Getgroups() (gids []int, err error) { | ||
150 | n, err := getgroups(0, nil) | ||
151 | if err != nil { | ||
152 | return nil, err | ||
153 | } | ||
154 | if n == 0 { | ||
155 | return nil, nil | ||
156 | } | ||
157 | |||
158 | // Sanity check group count. Max is 16 on BSD. | ||
159 | if n < 0 || n > 1000 { | ||
160 | return nil, EINVAL | ||
161 | } | ||
162 | |||
163 | a := make([]_Gid_t, n) | ||
164 | n, err = getgroups(n, &a[0]) | ||
165 | if err != nil { | ||
166 | return nil, err | ||
167 | } | ||
168 | gids = make([]int, n) | ||
169 | for i, v := range a[0:n] { | ||
170 | gids[i] = int(v) | ||
171 | } | ||
172 | return | ||
173 | } | ||
174 | |||
175 | func Setgroups(gids []int) (err error) { | ||
176 | if len(gids) == 0 { | ||
177 | return setgroups(0, nil) | ||
178 | } | ||
179 | |||
180 | a := make([]_Gid_t, len(gids)) | ||
181 | for i, v := range gids { | ||
182 | a[i] = _Gid_t(v) | ||
183 | } | ||
184 | return setgroups(len(a), &a[0]) | ||
185 | } | ||
186 | |||
187 | /* | ||
188 | * Socket | ||
189 | */ | ||
190 | |||
191 | //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) | ||
192 | |||
193 | func Accept(fd int) (nfd int, sa Sockaddr, err error) { | ||
194 | var rsa RawSockaddrAny | ||
195 | var len _Socklen = SizeofSockaddrAny | ||
196 | nfd, err = accept(fd, &rsa, &len) | ||
197 | if nfd == -1 { | ||
198 | return | ||
199 | } | ||
200 | sa, err = anyToSockaddr(fd, &rsa) | ||
201 | if err != nil { | ||
202 | Close(nfd) | ||
203 | nfd = 0 | ||
204 | } | ||
205 | return | ||
206 | } | ||
207 | |||
208 | func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { | ||
209 | // Recvmsg not implemented on AIX | ||
210 | sa := new(SockaddrUnix) | ||
211 | return -1, -1, -1, sa, ENOSYS | ||
212 | } | ||
213 | |||
214 | func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { | ||
215 | _, err = SendmsgN(fd, p, oob, to, flags) | ||
216 | return | ||
217 | } | ||
218 | |||
219 | func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { | ||
220 | // SendmsgN not implemented on AIX | ||
221 | return -1, ENOSYS | ||
222 | } | ||
223 | |||
224 | func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { | ||
225 | switch rsa.Addr.Family { | ||
226 | |||
227 | case AF_UNIX: | ||
228 | pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) | ||
229 | sa := new(SockaddrUnix) | ||
230 | |||
231 | // Some versions of AIX have a bug in getsockname (see IV78655). | ||
232 | // We can't rely on sa.Len being set correctly. | ||
233 | n := SizeofSockaddrUnix - 3 // substract leading Family, Len, terminating NUL. | ||
234 | for i := 0; i < n; i++ { | ||
235 | if pp.Path[i] == 0 { | ||
236 | n = i | ||
237 | break | ||
238 | } | ||
239 | } | ||
240 | |||
241 | bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] | ||
242 | sa.Name = string(bytes) | ||
243 | return sa, nil | ||
244 | |||
245 | case AF_INET: | ||
246 | pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) | ||
247 | sa := new(SockaddrInet4) | ||
248 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
249 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
250 | for i := 0; i < len(sa.Addr); i++ { | ||
251 | sa.Addr[i] = pp.Addr[i] | ||
252 | } | ||
253 | return sa, nil | ||
254 | |||
255 | case AF_INET6: | ||
256 | pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) | ||
257 | sa := new(SockaddrInet6) | ||
258 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
259 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
260 | sa.ZoneId = pp.Scope_id | ||
261 | for i := 0; i < len(sa.Addr); i++ { | ||
262 | sa.Addr[i] = pp.Addr[i] | ||
263 | } | ||
264 | return sa, nil | ||
265 | } | ||
266 | return nil, EAFNOSUPPORT | ||
267 | } | ||
268 | |||
269 | func Gettimeofday(tv *Timeval) (err error) { | ||
270 | err = gettimeofday(tv, nil) | ||
271 | return | ||
272 | } | ||
273 | |||
274 | // TODO | ||
275 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { | ||
276 | return -1, ENOSYS | ||
277 | } | ||
278 | |||
279 | //sys getdirent(fd int, buf []byte) (n int, err error) | ||
280 | func ReadDirent(fd int, buf []byte) (n int, err error) { | ||
281 | return getdirent(fd, buf) | ||
282 | } | ||
283 | |||
284 | //sys wait4(pid Pid_t, status *_C_int, options int, rusage *Rusage) (wpid Pid_t, err error) | ||
285 | func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { | ||
286 | var status _C_int | ||
287 | var r Pid_t | ||
288 | err = ERESTART | ||
289 | // AIX wait4 may return with ERESTART errno, while the processus is still | ||
290 | // active. | ||
291 | for err == ERESTART { | ||
292 | r, err = wait4(Pid_t(pid), &status, options, rusage) | ||
293 | } | ||
294 | wpid = int(r) | ||
295 | if wstatus != nil { | ||
296 | *wstatus = WaitStatus(status) | ||
297 | } | ||
298 | return | ||
299 | } | ||
300 | |||
301 | /* | ||
302 | * Wait | ||
303 | */ | ||
304 | |||
305 | type WaitStatus uint32 | ||
306 | |||
307 | func (w WaitStatus) Stopped() bool { return w&0x40 != 0 } | ||
308 | func (w WaitStatus) StopSignal() Signal { | ||
309 | if !w.Stopped() { | ||
310 | return -1 | ||
311 | } | ||
312 | return Signal(w>>8) & 0xFF | ||
313 | } | ||
314 | |||
315 | func (w WaitStatus) Exited() bool { return w&0xFF == 0 } | ||
316 | func (w WaitStatus) ExitStatus() int { | ||
317 | if !w.Exited() { | ||
318 | return -1 | ||
319 | } | ||
320 | return int((w >> 8) & 0xFF) | ||
321 | } | ||
322 | |||
323 | func (w WaitStatus) Signaled() bool { return w&0x40 == 0 && w&0xFF != 0 } | ||
324 | func (w WaitStatus) Signal() Signal { | ||
325 | if !w.Signaled() { | ||
326 | return -1 | ||
327 | } | ||
328 | return Signal(w>>16) & 0xFF | ||
329 | } | ||
330 | |||
331 | func (w WaitStatus) Continued() bool { return w&0x01000000 != 0 } | ||
332 | |||
333 | func (w WaitStatus) CoreDump() bool { return w&0x200 != 0 } | ||
334 | |||
335 | func (w WaitStatus) TrapCause() int { return -1 } | ||
336 | |||
337 | //sys ioctl(fd int, req uint, arg uintptr) (err error) | ||
338 | |||
339 | // ioctl itself should not be exposed directly, but additional get/set | ||
340 | // functions for specific types are permissible. | ||
341 | |||
342 | // IoctlSetInt performs an ioctl operation which sets an integer value | ||
343 | // on fd, using the specified request number. | ||
344 | func IoctlSetInt(fd int, req uint, value int) error { | ||
345 | return ioctl(fd, req, uintptr(value)) | ||
346 | } | ||
347 | |||
348 | func ioctlSetWinsize(fd int, req uint, value *Winsize) error { | ||
349 | return ioctl(fd, req, uintptr(unsafe.Pointer(value))) | ||
350 | } | ||
351 | |||
352 | func ioctlSetTermios(fd int, req uint, value *Termios) error { | ||
353 | return ioctl(fd, req, uintptr(unsafe.Pointer(value))) | ||
354 | } | ||
355 | |||
356 | // IoctlGetInt performs an ioctl operation which gets an integer value | ||
357 | // from fd, using the specified request number. | ||
358 | func IoctlGetInt(fd int, req uint) (int, error) { | ||
359 | var value int | ||
360 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
361 | return value, err | ||
362 | } | ||
363 | |||
364 | func IoctlGetWinsize(fd int, req uint) (*Winsize, error) { | ||
365 | var value Winsize | ||
366 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
367 | return &value, err | ||
368 | } | ||
369 | |||
370 | func IoctlGetTermios(fd int, req uint) (*Termios, error) { | ||
371 | var value Termios | ||
372 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
373 | return &value, err | ||
374 | } | ||
375 | |||
376 | // fcntl must never be called with cmd=F_DUP2FD because it doesn't work on AIX | ||
377 | // There is no way to create a custom fcntl and to keep //sys fcntl easily, | ||
378 | // Therefore, the programmer must call dup2 instead of fcntl in this case. | ||
379 | |||
380 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. | ||
381 | //sys FcntlInt(fd uintptr, cmd int, arg int) (r int,err error) = fcntl | ||
382 | |||
383 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. | ||
384 | //sys FcntlFlock(fd uintptr, cmd int, lk *Flock_t) (err error) = fcntl | ||
385 | |||
386 | //sys fcntl(fd int, cmd int, arg int) (val int, err error) | ||
387 | |||
388 | func Flock(fd int, how int) (err error) { | ||
389 | return syscall.Flock(fd, how) | ||
390 | } | ||
391 | |||
392 | /* | ||
393 | * Direct access | ||
394 | */ | ||
395 | |||
396 | //sys Acct(path string) (err error) | ||
397 | //sys Chdir(path string) (err error) | ||
398 | //sys Chroot(path string) (err error) | ||
399 | //sys Close(fd int) (err error) | ||
400 | //sys Dup(oldfd int) (fd int, err error) | ||
401 | //sys Exit(code int) | ||
402 | //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) | ||
403 | //sys Fchdir(fd int) (err error) | ||
404 | //sys Fchmod(fd int, mode uint32) (err error) | ||
405 | //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) | ||
406 | //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) | ||
407 | //sys Fdatasync(fd int) (err error) | ||
408 | //sys Fsync(fd int) (err error) | ||
409 | // readdir_r | ||
410 | //sysnb Getpgid(pid int) (pgid int, err error) | ||
411 | |||
412 | //sys Getpgrp() (pid int) | ||
413 | |||
414 | //sysnb Getpid() (pid int) | ||
415 | //sysnb Getppid() (ppid int) | ||
416 | //sys Getpriority(which int, who int) (prio int, err error) | ||
417 | //sysnb Getrusage(who int, rusage *Rusage) (err error) | ||
418 | //sysnb Getsid(pid int) (sid int, err error) | ||
419 | //sysnb Kill(pid int, sig Signal) (err error) | ||
420 | //sys Klogctl(typ int, buf []byte) (n int, err error) = syslog | ||
421 | //sys Mkdir(dirfd int, path string, mode uint32) (err error) | ||
422 | //sys Mkdirat(dirfd int, path string, mode uint32) (err error) | ||
423 | //sys Mkfifo(path string, mode uint32) (err error) | ||
424 | //sys Mknod(path string, mode uint32, dev int) (err error) | ||
425 | //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) | ||
426 | //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) | ||
427 | //sys Open(path string, mode int, perm uint32) (fd int, err error) = open64 | ||
428 | //sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) | ||
429 | //sys read(fd int, p []byte) (n int, err error) | ||
430 | //sys Readlink(path string, buf []byte) (n int, err error) | ||
431 | //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) | ||
432 | //sys Setdomainname(p []byte) (err error) | ||
433 | //sys Sethostname(p []byte) (err error) | ||
434 | //sysnb Setpgid(pid int, pgid int) (err error) | ||
435 | //sysnb Setsid() (pid int, err error) | ||
436 | //sysnb Settimeofday(tv *Timeval) (err error) | ||
437 | |||
438 | //sys Setuid(uid int) (err error) | ||
439 | //sys Setgid(uid int) (err error) | ||
440 | |||
441 | //sys Setpriority(which int, who int, prio int) (err error) | ||
442 | //sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) | ||
443 | //sys Sync() | ||
444 | //sysnb Times(tms *Tms) (ticks uintptr, err error) | ||
445 | //sysnb Umask(mask int) (oldmask int) | ||
446 | //sysnb Uname(buf *Utsname) (err error) | ||
447 | //TODO umount | ||
448 | // //sys Unmount(target string, flags int) (err error) = umount | ||
449 | //sys Unlink(path string) (err error) | ||
450 | //sys Unlinkat(dirfd int, path string, flags int) (err error) | ||
451 | //sys Ustat(dev int, ubuf *Ustat_t) (err error) | ||
452 | //sys write(fd int, p []byte) (n int, err error) | ||
453 | //sys readlen(fd int, p *byte, np int) (n int, err error) = read | ||
454 | //sys writelen(fd int, p *byte, np int) (n int, err error) = write | ||
455 | |||
456 | //sys Dup2(oldfd int, newfd int) (err error) | ||
457 | //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = posix_fadvise64 | ||
458 | //sys Fchown(fd int, uid int, gid int) (err error) | ||
459 | //sys Fstat(fd int, stat *Stat_t) (err error) | ||
460 | //sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = fstatat | ||
461 | //sys Fstatfs(fd int, buf *Statfs_t) (err error) | ||
462 | //sys Ftruncate(fd int, length int64) (err error) | ||
463 | //sysnb Getegid() (egid int) | ||
464 | //sysnb Geteuid() (euid int) | ||
465 | //sysnb Getgid() (gid int) | ||
466 | //sysnb Getuid() (uid int) | ||
467 | //sys Lchown(path string, uid int, gid int) (err error) | ||
468 | //sys Listen(s int, n int) (err error) | ||
469 | //sys Lstat(path string, stat *Stat_t) (err error) | ||
470 | //sys Pause() (err error) | ||
471 | //sys Pread(fd int, p []byte, offset int64) (n int, err error) = pread64 | ||
472 | //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) = pwrite64 | ||
473 | //TODO Select | ||
474 | // //sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) | ||
475 | //sys Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) | ||
476 | //sysnb Setregid(rgid int, egid int) (err error) | ||
477 | //sysnb Setreuid(ruid int, euid int) (err error) | ||
478 | //sys Shutdown(fd int, how int) (err error) | ||
479 | //sys Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) | ||
480 | //sys Stat(path string, stat *Stat_t) (err error) | ||
481 | //sys Statfs(path string, buf *Statfs_t) (err error) | ||
482 | //sys Truncate(path string, length int64) (err error) | ||
483 | |||
484 | //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | ||
485 | //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | ||
486 | //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) | ||
487 | //sysnb setgroups(n int, list *_Gid_t) (err error) | ||
488 | //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) | ||
489 | //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) | ||
490 | //sysnb socket(domain int, typ int, proto int) (fd int, err error) | ||
491 | //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) | ||
492 | //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | ||
493 | //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | ||
494 | //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) | ||
495 | //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) | ||
496 | //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
497 | //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) | ||
498 | |||
499 | //sys munmap(addr uintptr, length uintptr) (err error) | ||
500 | |||
501 | var mapper = &mmapper{ | ||
502 | active: make(map[*byte][]byte), | ||
503 | mmap: mmap, | ||
504 | munmap: munmap, | ||
505 | } | ||
506 | |||
507 | func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { | ||
508 | return mapper.Mmap(fd, offset, length, prot, flags) | ||
509 | } | ||
510 | |||
511 | func Munmap(b []byte) (err error) { | ||
512 | return mapper.Munmap(b) | ||
513 | } | ||
514 | |||
515 | //sys Madvise(b []byte, advice int) (err error) | ||
516 | //sys Mprotect(b []byte, prot int) (err error) | ||
517 | //sys Mlock(b []byte) (err error) | ||
518 | //sys Mlockall(flags int) (err error) | ||
519 | //sys Msync(b []byte, flags int) (err error) | ||
520 | //sys Munlock(b []byte) (err error) | ||
521 | //sys Munlockall() (err error) | ||
522 | |||
523 | //sysnb pipe(p *[2]_C_int) (err error) | ||
524 | |||
525 | func Pipe(p []int) (err error) { | ||
526 | if len(p) != 2 { | ||
527 | return EINVAL | ||
528 | } | ||
529 | var pp [2]_C_int | ||
530 | err = pipe(&pp) | ||
531 | p[0] = int(pp[0]) | ||
532 | p[1] = int(pp[1]) | ||
533 | return | ||
534 | } | ||
535 | |||
536 | //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) | ||
537 | |||
538 | func Poll(fds []PollFd, timeout int) (n int, err error) { | ||
539 | if len(fds) == 0 { | ||
540 | return poll(nil, 0, timeout) | ||
541 | } | ||
542 | return poll(&fds[0], len(fds), timeout) | ||
543 | } | ||
544 | |||
545 | //sys gettimeofday(tv *Timeval, tzp *Timezone) (err error) | ||
546 | //sysnb Time(t *Time_t) (tt Time_t, err error) | ||
547 | //sys Utime(path string, buf *Utimbuf) (err error) | ||