initial commit
[freebsd-arm:freebsd-arm.git] / compat / svr4 / syscalls.master
1  $FreeBSD$
2 ;       from: @(#)syscalls.master       8.1 (Berkeley) 7/19/93
3 ;
4 ; System call name/number master file (or rather, slave, from SVR4).
5 ; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h.
6
7 ; Columns: number type nargs name alt{name,tag,rtyp}/comments
8 ;       number  system call number, must be in order
9 ;       audit   the audit event associated with the system call
10 ;               A value of AUE_NULL means no auditing, but it also means that
11 ;               there is no audit event for the call at this time. For the
12 ;               case where the event exists, but we don't want auditing, the
13 ;               event should be #defined to AUE_NULL in audit_kevents.h.
14 ;       type    one of STD, OBSOL, UNIMPL, COMPAT
15 ;       name    psuedo-prototype of syscall routine
16 ;               If one of the following alts is different, then all appear:
17 ;       altname name of system call if different
18 ;       alttag  name of args struct tag if different from [o]`name'"_args"
19 ;       altrtyp return type if not int (bogus - syscalls always return int)
20 ;               for UNIMPL/OBSOL, name continues with comments
21
22 ; types:
23 ;       STD     always included
24 ;       COMPAT  included on COMPAT #ifdef
25 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
26 ;       OBSOL   obsolete, not included in system, only specifies name
27 ;       UNIMPL  not implemented, placeholder only
28
29 ; #ifdef's, etc. may be included, and are copied to the output files.
30
31 #include <sys/types.h>
32 #include <sys/sysent.h>
33 #include <sys/sysproto.h>
34 #include <netinet/in.h>
35
36 #include <compat/svr4/svr4.h>
37 #include <compat/svr4/svr4_types.h>
38 #include <compat/svr4/svr4_signal.h>
39 #include <compat/svr4/svr4_proto.h>
40
41 0       AUE_NULL        UNIMPL  unused
42 1       AUE_NULL        NOPROTO { void sys_exit(int rval); } exit \
43                                     sys_exit_args void
44 2       AUE_NULL        NOPROTO { int fork(void); }
45 3       AUE_NULL        NOPROTO { int read(int fd, char *buf, u_int nbyte); }
46 4       AUE_NULL        NOPROTO { int write(int fd, char *buf, u_int nbyte); }
47 5       AUE_NULL        STD     { int svr4_sys_open(char *path, int flags, \
48                                     int mode); }
49 6       AUE_NULL        NOPROTO { int close(int fd); }
50 7       AUE_NULL        STD     { int svr4_sys_wait(int *status); }
51 8       AUE_NULL        STD     { int svr4_sys_creat(char *path, int mode); }
52 9       AUE_NULL        NOPROTO { int link(char *path, char *link); }
53 10      AUE_NULL        NOPROTO { int unlink(char *path); }
54 11      AUE_NULL        STD     { int svr4_sys_execv(char *path, char **argp); }
55 12      AUE_NULL        NOPROTO { int chdir(char *path); }
56 13      AUE_NULL        STD     { int svr4_sys_time(time_t *t); }
57 14      AUE_NULL        STD     { int svr4_sys_mknod(char* path, int mode, int dev); }
58 15      AUE_NULL        NOPROTO { int chmod(char *path, int mode); }
59 16      AUE_NULL        NOPROTO { int chown(char *path, uid_t uid, gid_t gid); }
60 17      AUE_NULL        STD     { int svr4_sys_break(caddr_t nsize); }
61 18      AUE_NULL        STD     { int svr4_sys_stat(char* path, \
62                                     struct svr4_stat* ub); }
63 19      AUE_NULL        NOPROTO { int lseek(int filedes, off_t *offset, \
64                                     int whence); }
65 20      AUE_NULL        NOPROTO { pid_t getpid(void); }
66 21      AUE_NULL        UNIMPL  old_mount
67 22      AUE_NULL        UNIMPL  sysv_umount
68 23      AUE_NULL        NOPROTO { int setuid(uid_t uid); }
69 24      AUE_NULL        NOPROTO { uid_t getuid(void); }
70 25      AUE_NULL        UNIMPL  stime
71 26      AUE_NULL        UNIMPL  ptrace
72 27      AUE_NULL        STD     { int svr4_sys_alarm(unsigned sec); }
73 28      AUE_NULL        STD     { int svr4_sys_fstat(int fd, \
74                                     struct svr4_stat *sb); }
75 29      AUE_NULL        STD     { int svr4_sys_pause(void); }
76 30      AUE_NULL        STD     { int svr4_sys_utime(char *path, \
77                                     struct svr4_utimbuf *ubuf); }
78 31      AUE_NULL        UNIMPL  stty
79 32      AUE_NULL        UNIMPL  gtty
80 33      AUE_NULL        STD     { int svr4_sys_access(char *path, \
81                                     int flags); }
82 34      AUE_NULL        STD     { int svr4_sys_nice(int prio); }
83 35      AUE_NULL        UNIMPL  statfs
84 36      AUE_NULL        NOPROTO { int sync(void); }
85 37      AUE_NULL        STD     { int svr4_sys_kill(int pid, int signum); }
86 38      AUE_NULL        UNIMPL  fstatfs
87 39      AUE_NULL        STD     { int svr4_sys_pgrpsys(int cmd, int pid, \
88                                     int pgid); }
89 40      AUE_NULL        UNIMPL  xenix
90 41      AUE_NULL        NOPROTO { int dup(u_int fd); }
91 42      AUE_NULL        NOPROTO { int pipe(void); }
92 43      AUE_NULL        STD     { int svr4_sys_times(struct tms *tp); }
93 44      AUE_NULL        UNIMPL  profil
94 45      AUE_NULL        UNIMPL  plock
95 46      AUE_NULL        NOPROTO { int setgid(gid_t gid); }
96 47      AUE_NULL        NOPROTO { gid_t getgid(void); }
97 48      AUE_NULL        STD     { int svr4_sys_signal(int signum, \
98                                     svr4_sig_t handler); }
99 49      AUE_NULL        STD     { int svr4_sys_msgsys(int what, int a2, \
100                                     int a3, int a4, int a5); }
101 50      AUE_NULL        STD     { int svr4_sys_sysarch(int op, void *a1); }
102 51      AUE_NULL        UNIMPL  acct
103 52      AUE_NULL        STD     { int svr4_sys_shmsys(int what, int a2, \
104                                     int a3, int a4, int a5); }
105 53      AUE_NULL        STD     { int svr4_sys_semsys(int what, int a2, \
106                                     int a3, int a4, int a5); }
107 54      AUE_NULL        STD     { int svr4_sys_ioctl(int fd, u_long com, \
108                                     caddr_t data); }
109 55      AUE_NULL        UNIMPL  uadmin
110 56      AUE_NULL        UNIMPL  exch
111 57      AUE_NULL        STD     { int svr4_sys_utssys(void *a1, void *a2, \
112                                     int sel, void *a3); }
113 58      AUE_NULL        NOPROTO { int fsync(int fd); }
114 59      AUE_NULL        STD     { int svr4_sys_execve(char *path, \
115                                     char **argp, char **envp); }
116 60      AUE_NULL        NOPROTO { int umask(int newmask); }
117 61      AUE_NULL        NOPROTO { int chroot(char *path); }
118 62      AUE_NULL        STD     { int svr4_sys_fcntl(int fd, int cmd, \
119                                     char *arg); }
120 63      AUE_NULL        STD     { int svr4_sys_ulimit(int cmd, \
121                                     long newlimit); }
122 64      AUE_NULL        UNIMPL  reserved
123 65      AUE_NULL        UNIMPL  reserved
124 66      AUE_NULL        UNIMPL  reserved
125 67      AUE_NULL        UNIMPL  reserved
126 68      AUE_NULL        UNIMPL  reserved
127 69      AUE_NULL        UNIMPL  reserved
128 70      AUE_NULL        UNIMPL  advfs
129 71      AUE_NULL        UNIMPL  unadvfs
130 72      AUE_NULL        UNIMPL  rmount
131 73      AUE_NULL        UNIMPL  rumount
132 74      AUE_NULL        UNIMPL  rfstart
133 75      AUE_NULL        UNIMPL  sigret
134 76      AUE_NULL        UNIMPL  rdebug
135 77      AUE_NULL        UNIMPL  rfstop
136 78      AUE_NULL        UNIMPL  rfsys
137 79      AUE_NULL        NOPROTO { int rmdir(char *path); }
138 80      AUE_NULL        NOPROTO { int mkdir(char *path, int mode); }
139 81      AUE_NULL        STD     { int svr4_sys_getdents(int fd, char *buf, \
140                                     int nbytes); }
141 82      AUE_NULL        UNIMPL  libattach
142 83      AUE_NULL        UNIMPL  libdetach
143 84      AUE_NULL        UNIMPL  sysfs
144 85      AUE_NULL        STD     { int svr4_sys_getmsg(int fd, \
145                                     struct svr4_strbuf *ctl, \
146                                     struct svr4_strbuf *dat, int *flags); }
147 86      AUE_NULL        STD     { int svr4_sys_putmsg(int fd, \
148                                     struct svr4_strbuf *ctl, \
149                                     struct svr4_strbuf *dat, int flags); }
150 87      AUE_NULL        STD     { int svr4_sys_poll(struct pollfd *fds, \
151                                     unsigned int nfds, int timeout); }
152 88      AUE_NULL        STD     { int svr4_sys_lstat(char *path, \
153                                     struct svr4_stat *ub); }
154 89      AUE_NULL        NOPROTO { int symlink(char *path, char *link); }
155 90      AUE_NULL        NOPROTO { int readlink(char *path, char *buf, \
156                                     int count); }
157 91      AUE_NULL        NOPROTO { int getgroups(u_int gidsetsize, \
158                                     gid_t *gidset); }
159 92      AUE_NULL        NOPROTO { int setgroups(u_int gidsetsize, \
160                                     gid_t *gidset); }
161 93      AUE_NULL        NOPROTO { int fchmod(int fd, int mode); }
162 94      AUE_NULL        NOPROTO { int fchown(int fd, int uid, int gid); }
163 95      AUE_NULL        STD     { int svr4_sys_sigprocmask(int how, \
164                                     svr4_sigset_t *set, \
165                                     svr4_sigset_t *oset); }
166 96      AUE_NULL        STD     { int svr4_sys_sigsuspend( \
167                                     svr4_sigset_t *ss); }
168 97      AUE_NULL        STD     { int svr4_sys_sigaltstack( \
169                                     struct svr4_sigaltstack *nss, \
170                                     struct svr4_sigaltstack *oss); }
171 98      AUE_NULL        STD     { int svr4_sys_sigaction(int signum, \
172                                     struct svr4_sigaction *nsa, \
173                                     struct svr4_sigaction *osa); }
174 99      AUE_NULL        STD     { int svr4_sys_sigpending(int what, \
175                                     svr4_sigset_t *mask); }
176 100     AUE_NULL        STD     { int svr4_sys_context(int func, \
177                                     struct svr4_ucontext *uc); }
178 101     AUE_NULL        UNIMPL  evsys
179 102     AUE_NULL        UNIMPL  evtrapret
180 103     AUE_NULL        STD     { int svr4_sys_statvfs(char *path, \
181                                     struct svr4_statvfs *fs); }
182 104     AUE_NULL        STD     { int svr4_sys_fstatvfs(int fd, \
183                                     struct svr4_statvfs *fs); }
184 105     AUE_NULL        UNIMPL  whoknows
185 106     AUE_NULL        UNIMPL  nfssvc
186 107     AUE_NULL        STD     { int svr4_sys_waitsys(int grp, int id, \
187                                     union svr4_siginfo *info, int options); }
188 108     AUE_NULL        UNIMPL  sigsendsys
189 109     AUE_NULL        STD     { int svr4_sys_hrtsys(int cmd, int fun, \
190                                     int sub, void *rv1, void *rv2); }
191 110     AUE_NULL        UNIMPL  acancel
192 111     AUE_NULL        UNIMPL  async
193 112     AUE_NULL        UNIMPL  priocntlsys
194 113     AUE_NULL        STD     { int svr4_sys_pathconf(char *path, \
195                                     int name); }
196 114     AUE_NULL        UNIMPL  mincore
197 115     AUE_NULL        STD     { caddr_t svr4_sys_mmap(caddr_t addr, \
198                                     svr4_size_t len, int prot, int flags, \
199                                     int fd, svr4_off_t pos); }
200 116     AUE_NULL        NOPROTO { int mprotect(void *addr, int len, \
201                                     int prot); }
202 117     AUE_NULL        NOPROTO { int munmap(void *addr, int len); }
203 118     AUE_NULL        STD     { int svr4_sys_fpathconf(int fd, int name); }
204 119     AUE_NULL        NOPROTO { int vfork(void); }
205 120     AUE_NULL        NOPROTO { int fchdir(int fd); }
206 121     AUE_NULL        NOPROTO { int readv(int fd, struct iovec *iovp, \
207                                     u_int iovcnt); }
208 122     AUE_NULL        NOPROTO { int writev(int fd, struct iovec *iovp, \
209                                     u_int iovcnt); }
210 123     AUE_NULL        STD     { int svr4_sys_xstat(int two, char *path, \
211                                     struct svr4_xstat *ub); }
212 124     AUE_NULL        STD     { int svr4_sys_lxstat(int two, char *path, \
213                                     struct svr4_xstat *ub); }
214 125     AUE_NULL        STD     { int svr4_sys_fxstat(int two, int fd, \
215                                     struct svr4_xstat *sb); }
216 126     AUE_NULL        STD     { int svr4_sys_xmknod(int two, char *path, \
217                                     svr4_mode_t mode, svr4_dev_t dev); }
218 127     AUE_NULL        UNIMPL  clocal
219 128     AUE_NULL        STD     { int svr4_sys_setrlimit(int which, \
220                                     const struct svr4_rlimit *rlp); }
221 129     AUE_NULL        STD     { int svr4_sys_getrlimit(int which, \
222                                     struct svr4_rlimit *rlp); }
223 130     AUE_NULL        NOPROTO { int lchown(char *path, uid_t uid, \
224                                     gid_t gid); }
225 131     AUE_NULL        STD     { int svr4_sys_memcntl(void * addr, \
226                                     svr4_size_t len, int cmd, void * arg, \
227                                     int attr, int mask); }
228 132     AUE_NULL        UNIMPL  getpmsg
229 133     AUE_NULL        UNIMPL  putpmsg
230 134     AUE_NULL        NOPROTO { int rename(char *from, char *to); }
231 135     AUE_NULL        STD     { int svr4_sys_uname( \
232                                     struct svr4_utsname* name, int dummy); }
233 136     AUE_NULL        NOPROTO { int setegid(gid_t egid); }
234 137     AUE_NULL        STD     { int svr4_sys_sysconfig(int name); }
235 138     AUE_NULL        NOPROTO { int adjtime(struct timeval *delta, \
236                                     struct timeval *olddelta); }
237 139     AUE_NULL        STD     { long svr4_sys_systeminfo(int what, \
238                                     char *buf, long len); }
239 140     AUE_NULL        UNIMPL  notused
240 141     AUE_NULL        NOPROTO { int seteuid(uid_t euid); }
241 142     AUE_NULL        UNIMPL  vtrace
242 ; fork1
243 143     AUE_NULL        UNIMPL  { int fork(void); } 
244 144     AUE_NULL        UNIMPL  sigtimedwait
245 145     AUE_NULL        UNIMPL  lwp_info
246 146     AUE_NULL        UNIMPL  yield
247 147     AUE_NULL        UNIMPL  lwp_sema_wait
248 148     AUE_NULL        UNIMPL  lwp_sema_post
249 149     AUE_NULL        UNIMPL  lwp_sema_trywait
250 150     AUE_NULL        UNIMPL  notused
251 151     AUE_NULL        UNIMPL  notused
252 152     AUE_NULL        UNIMPL  modctl
253 153     AUE_NULL        STD     { int svr4_sys_fchroot(int fd); }
254 154     AUE_NULL        STD     { int svr4_sys_utimes(char *path, \
255                                     struct timeval *tptr); }
256 155     AUE_NULL        STD     { int svr4_sys_vhangup(void); }
257 156     AUE_NULL        STD     { int svr4_sys_gettimeofday( \
258                                     struct timeval *tp); }
259 157     AUE_NULL        NOPROTO { int getitimer(u_int which, \
260                                     struct itimerval *itv); }
261 158     AUE_NULL        NOPROTO { int setitimer(u_int which, \
262                                     struct itimerval *itv, \
263                                     struct itimerval *oitv); }
264 159     AUE_NULL        UNIMPL  lwp_create
265 160     AUE_NULL        UNIMPL  lwp_exit
266 161     AUE_NULL        UNIMPL  lwp_suspend
267 162     AUE_NULL        UNIMPL  lwp_continue
268 163     AUE_NULL        UNIMPL  lwp_kill
269 164     AUE_NULL        UNIMPL  lwp_self
270 165     AUE_NULL        UNIMPL  lwp_getprivate
271 166     AUE_NULL        UNIMPL  lwp_setprivate
272 167     AUE_NULL        UNIMPL  lwp_wait
273 168     AUE_NULL        UNIMPL  lwp_mutex_unlock
274 169     AUE_NULL        UNIMPL  lwp_mutex_lock
275 170     AUE_NULL        UNIMPL  lwp_cond_wait
276 171     AUE_NULL        UNIMPL  lwp_cond_signal
277 172     AUE_NULL        UNIMPL  lwp_cond_broadcast
278 173     AUE_NULL        UNIMPL  { ssize_t svr4_sys_pread(int fd, void *buf, \
279                                     size_t nbyte, svr4_off_t off); }
280 174     AUE_NULL        UNIMPL  { ssize_t svr4_sys_pwrite(int fd, \
281                                     const void *buf, size_t nbyte, \
282                                     svr4_off_t off); }
283 175     AUE_NULL        STD     { svr4_off64_t svr4_sys_llseek(int fd, \
284                                     long offset1, long offset2, int whence); }
285 176     AUE_NULL        UNIMPL  inst_sync
286 177     AUE_NULL        UNIMPL  whoknows
287 178     AUE_NULL        UNIMPL  kaio
288 179     AUE_NULL        UNIMPL  whoknows
289 180     AUE_NULL        UNIMPL  whoknows
290 181     AUE_NULL        UNIMPL  whoknows
291 182     AUE_NULL        UNIMPL  whoknows
292 183     AUE_NULL        UNIMPL  whoknows
293 184     AUE_NULL        UNIMPL  tsolsys
294 185     AUE_NULL        STD     { int svr4_sys_acl(char *path, int cmd, \
295                                     int num, struct svr4_aclent *buf); }
296 186     AUE_NULL        STD     { int svr4_sys_auditsys(int code, int a1, \
297                                     int a2, int a3, int a4, int a5); }
298 187     AUE_NULL        UNIMPL  processor_bind
299 188     AUE_NULL        UNIMPL  processor_info
300 189     AUE_NULL        UNIMPL  p_online
301 190     AUE_NULL        UNIMPL  sigqueue
302 191     AUE_NULL        UNIMPL  clock_gettime
303 192     AUE_NULL        UNIMPL  clock_settime
304 193     AUE_NULL        UNIMPL  clock_getres
305 194     AUE_NULL        UNIMPL  timer_create
306 195     AUE_NULL        UNIMPL  timer_delete
307 196     AUE_NULL        UNIMPL  timer_settime
308 197     AUE_NULL        UNIMPL  timer_gettime
309 198     AUE_NULL        UNIMPL  timer_overrun
310 199     AUE_NULL        NOPROTO { int nanosleep( \
311                                     const struct timespec *rqtp, \
312                                     struct timespec *rmtp); }
313 200     AUE_NULL        STD     { int svr4_sys_facl(int fd, int cmd, \
314                                     int num, struct svr4_aclent *buf); }
315 201     AUE_NULL        UNIMPL  door
316 202     AUE_NULL        NOPROTO { int setreuid(int ruid, int euid); }
317 203     AUE_NULL        NOPROTO { int setregid(int rgid, int egid); }
318 204     AUE_NULL        UNIMPL  install_utrap
319 205     AUE_NULL        UNIMPL  signotify
320 206     AUE_NULL        UNIMPL  schedctl
321 207     AUE_NULL        UNIMPL  pset
322 208     AUE_NULL        UNIMPL  whoknows
323 209     AUE_NULL        STD     { int svr4_sys_resolvepath(const char *path, \
324                                     char *buf, size_t bufsiz); }
325 210     AUE_NULL        UNIMPL  signotifywait
326 211     AUE_NULL        UNIMPL  lwp_sigredirect
327 212     AUE_NULL        UNIMPL  lwp_alarm
328 213     AUE_NULL        STD     { int svr4_sys_getdents64(int fd, \
329                                     struct svr4_dirent64 *dp, int nbytes); }
330 ;213    AUE_NULL        UNIMPL  getdents64
331 214     AUE_NULL        STD     { caddr_t svr4_sys_mmap64(void *addr, \
332                                     svr4_size_t len, int prot, int flags, \
333                                     int fd, svr4_off64_t pos); }
334 215     AUE_NULL        STD     { int svr4_sys_stat64(char *path, \
335                                     struct svr4_stat64 *sb); }
336 216     AUE_NULL        STD     { int svr4_sys_lstat64(char *path, \
337                                     struct svr4_stat64 *sb); }
338 217     AUE_NULL        STD     { int svr4_sys_fstat64(int fd, \
339                                     struct svr4_stat64 *sb); }
340 218     AUE_NULL        STD     { int svr4_sys_statvfs64(char *path, \
341                                     struct svr4_statvfs64 *fs); }
342 219     AUE_NULL        STD     { int svr4_sys_fstatvfs64(int fd, \
343                                     struct svr4_statvfs64 *fs); }
344 220     AUE_NULL        STD     { int svr4_sys_setrlimit64(int which, \
345                                     const struct svr4_rlimit64 *rlp); }
346 221     AUE_NULL        STD     { int svr4_sys_getrlimit64(int which, \
347                                     struct svr4_rlimit64 *rlp); }
348 222     AUE_NULL        UNIMPL  pread64
349 223     AUE_NULL        UNIMPL  pwrite64
350 224     AUE_NULL        STD     { int svr4_sys_creat64(char *path, \
351                                     int mode); }
352 225     AUE_NULL        STD     { int svr4_sys_open64(char *path, int flags, \
353                                     int mode); }
354 226     AUE_NULL        UNIMPL  rpcsys
355 227     AUE_NULL        UNIMPL  whoknows
356 228     AUE_NULL        UNIMPL  whoknows
357 229     AUE_NULL        UNIMPL  whoknows
358 230     AUE_NULL        STD     { int svr4_sys_socket(int domain, int type, \
359                                     int protocol); }
360 231     AUE_NULL        NOPROTO { int socketpair(int domain, int type, \
361                                     int protocol, int *rsv); }
362 232     AUE_NULL        NOPROTO { int bind(int s, \
363                                     const struct sockaddr *name, \
364                                     int namelen); }
365 233     AUE_NULL        NOPROTO { int listen(int s, int backlog); }
366 234     AUE_NULL        NOPROTO { int accept(int s, struct sockaddr *name, \
367                                     int *anamelen); }
368 235     AUE_NULL        NOPROTO { int connect(int s, \
369                                     const struct sockaddr *name, \
370                                     int namelen); }
371 236     AUE_NULL        NOPROTO { int shutdown(int s, int how); }
372 237     AUE_NULL        STD     { int svr4_sys_recv(int s, caddr_t buf, \
373                                     int len, int flags); }
374 238     AUE_NULL        NOPROTO { ssize_t recvfrom(int s, void *buf, \
375                                     size_t len, int flags, \
376                                     struct sockaddr *from, \
377                                     int *fromlenaddr); }
378 239     AUE_NULL        NOPROTO { ssize_t recvmsg(int s, struct msghdr *msg, \
379                                     int flags); }
380 240     AUE_NULL        STD     { int svr4_sys_send(int s, caddr_t buf, \
381                                     int len, int flags); }
382 241     AUE_NULL        NOPROTO { ssize_t sendmsg(int s, \
383                                     const struct msghdr *msg, int flags); }
384 242     AUE_NULL        STD     { ssize_t svr4_sys_sendto(int s, void *buf, \
385                                     size_t len, int flags, \
386                                     struct sockaddr *to, int tolen); }
387 243     AUE_NULL        NOPROTO { int getpeername(int fdes, \
388                                     struct sockaddr *asa, int *alen); }
389 244     AUE_NULL        NOPROTO { int getsockname(int fdes, \
390                                     struct sockaddr *asa, int *alen); }
391 245     AUE_NULL        NOPROTO { int getsockopt(int s, int level, int name, \
392                                     void *val, int *avalsize); }
393 246     AUE_NULL        NOPROTO { int setsockopt(int s, int level, int name, \
394                                     const void *val, int valsize); }
395 247     AUE_NULL        UNIMPL  sockconfig
396 248     AUE_NULL        UNIMPL  { int ntp_gettime(struct ntptimeval *ntvp); }
397 249     AUE_NULL        UNIMPL  { int ntp_adjtime(struct timex *tp); }