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