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 ;       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); }