From dd13e98dca241718a53c514a3e0d6a90a96e1422 Mon Sep 17 00:00:00 2001 From: Nikolay Tolstokulakov Date: Thu, 4 Feb 2016 13:38:50 +0600 Subject: [PATCH] netbsd patch: core/sys/posix --- src/core/stdc/tgmath.d | 1 - src/core/sys/posix/arpa/inet.d | 29 +++ src/core/sys/posix/dirent.d | 46 +++++ src/core/sys/posix/dlfcn.d | 23 +++ src/core/sys/posix/fcntl.d | 53 ++++++ src/core/sys/posix/grp.d | 21 +++ src/core/sys/posix/net/if_.d | 15 ++ src/core/sys/posix/netdb.d | 107 +++++++++++ src/core/sys/posix/netinet/in_.d | 178 ++++++++++++++++++ src/core/sys/posix/netinet/tcp.d | 4 + src/core/sys/posix/poll.d | 34 ++++ src/core/sys/posix/pthread.d | 146 +++++++++++++++ src/core/sys/posix/pwd.d | 29 +++ src/core/sys/posix/sched.d | 21 +++ src/core/sys/posix/semaphore.d | 10 ++ src/core/sys/posix/setjmp.d | 43 +++++ src/core/sys/posix/signal.d | 290 +++++++++++++++++++++++++++++- src/core/sys/posix/stdio.d | 4 + src/core/sys/posix/stdlib.d | 56 ++++++ src/core/sys/posix/sys/ioctl.d | 12 ++ src/core/sys/posix/sys/ipc.d | 25 +++ src/core/sys/posix/sys/mman.d | 59 ++++++ src/core/sys/posix/sys/resource.d | 64 +++++++ src/core/sys/posix/sys/select.d | 49 +++++ src/core/sys/posix/sys/shm.d | 26 +++ src/core/sys/posix/sys/socket.d | 211 ++++++++++++++++++++++ src/core/sys/posix/sys/stat.d | 84 +++++++++ src/core/sys/posix/sys/time.d | 19 ++ src/core/sys/posix/sys/types.d | 103 +++++++++++ src/core/sys/posix/sys/uio.d | 11 ++ src/core/sys/posix/sys/un.d | 9 + src/core/sys/posix/sys/utsname.d | 16 ++ src/core/sys/posix/sys/wait.d | 28 +++ src/core/sys/posix/syslog.d | 65 +++++++ src/core/sys/posix/termios.d | 142 +++++++++++++++ src/core/sys/posix/time.d | 45 +++++ src/core/sys/posix/ucontext.d | 56 ++++++ src/core/sys/posix/unistd.d | 171 ++++++++++++++++++ src/core/sys/posix/utime.d | 10 ++ 39 files changed, 2313 insertions(+), 2 deletions(-) diff --git a/src/core/stdc/tgmath.d b/src/core/stdc/tgmath.d index 8747008c2e..901e656d5f 100644 --- a/src/core/stdc/tgmath.d +++ b/src/core/stdc/tgmath.d @@ -1119,7 +1119,6 @@ version( NetBSD ) // alias core.stdc.complex.crealf creal; // alias core.stdc.complex.creall creal; } - else version( OpenBSD ) { /// diff --git a/src/core/sys/posix/arpa/inet.d b/src/core/sys/posix/arpa/inet.d index 552e68acfb..675a197e6d 100644 --- a/src/core/sys/posix/arpa/inet.d +++ b/src/core/sys/posix/arpa/inet.d @@ -133,6 +133,31 @@ else version( FreeBSD ) const(char)* inet_ntop(int, in void*, char*, socklen_t); int inet_pton(int, in char*, void*); } +else version(NetBSD) +{ + alias uint16_t in_port_t; + alias uint32_t in_addr_t; + + struct in_addr + { + in_addr_t s_addr; + } + + enum INET_ADDRSTRLEN = 16; + + @trusted pure + { + uint32_t htonl(uint32_t); + uint16_t htons(uint16_t); + uint32_t ntohl(uint32_t); + uint16_t ntohs(uint16_t); + } + + in_addr_t inet_addr(in char*); + char* inet_ntoa(in_addr); + const(char)* inet_ntop(int, in void*, char*, socklen_t); + int inet_pton(int, in char*, void*); +} else version( Solaris ) { alias uint16_t in_port_t; @@ -220,6 +245,10 @@ else version( FreeBSD ) { enum INET6_ADDRSTRLEN = 46; } +else version(NetBSD) +{ + enum INET6_ADDRSTRLEN = 46; +} else version( Solaris ) { enum INET6_ADDRSTRLEN = 46; diff --git a/src/core/sys/posix/dirent.d b/src/core/sys/posix/dirent.d index 0b332157af..5a51cc7378 100644 --- a/src/core/sys/posix/dirent.d +++ b/src/core/sys/posix/dirent.d @@ -162,6 +162,35 @@ else version( FreeBSD ) dirent* readdir(DIR*); } +else version(NetBSD) +{ + enum + { + DT_UNKNOWN = 0, + DT_FIFO = 1, + DT_CHR = 2, + DT_DIR = 4, + DT_BLK = 6, + DT_REG = 8, + DT_LNK = 10, + DT_SOCK = 12, + DT_WHT = 14 + } + + struct dirent + { + ulong d_fileno; + ushort d_reclen; + ushort d_namlen; + ubyte d_type; + char[512] d_name; + } + + alias void* DIR; + + dirent* __readdir30(DIR*); + alias __readdir30 readdir; +} else version( OpenBSD ) { enum @@ -283,6 +312,13 @@ version( OSX ) pragma(mangle, "rewinddir$INODE64$UNIX2003") void rewinddir(DIR*); } } +else version(NetBSD) +{ + int closedir(DIR*); + DIR* __opendir30(in char*); + alias __opendir30 opendir; + void rewinddir(DIR*); +} else { int closedir(DIR*); @@ -321,6 +357,11 @@ else version( FreeBSD ) { int readdir_r(DIR*, dirent*, dirent**); } +else version(NetBSD) +{ + int __readdir_r30(DIR*, dirent*, dirent**); + alias __readdir_r30 readdir_r; +} else version( OpenBSD ) { int readdir_r(DIR*, dirent*, dirent**); @@ -364,6 +405,11 @@ else version( FreeBSD ) void seekdir(DIR*, c_long); c_long telldir(DIR*); } +else version(NetBSD) +{ + void seekdir(DIR*, c_long); + c_long telldir(DIR*); +} else version( OpenBSD ) { void seekdir(DIR*, c_long); diff --git a/src/core/sys/posix/dlfcn.d b/src/core/sys/posix/dlfcn.d index 0ce8dda1bf..b227d1025d 100644 --- a/src/core/sys/posix/dlfcn.d +++ b/src/core/sys/posix/dlfcn.d @@ -174,6 +174,29 @@ else version( FreeBSD ) void* dli_saddr; } } +else version(NetBSD) +{ + enum RTLD_LAZY = 1; + enum RTLD_NOW = 2; + enum RTLD_GLOBAL = 0x100; + enum RTLD_LOCAL = 0x200; + enum RTLD_NODELETE = 0x01000; /* Do not remove members. */ + enum RTLD_NOLOAD = 0x02000; + + int dlclose(void*); + char* dlerror(); + void* dlopen(in char*, int); + void* dlsym(void*, in char*); + int dladdr(const(void)* addr, Dl_info* info); + + struct Dl_info + { + const(char)* dli_fname; + void* dli_fbase; + const(char)* dli_sname; + void* dli_saddr; + } +} else version( OpenBSD ) { enum RTLD_LAZY = 1; diff --git a/src/core/sys/posix/fcntl.d b/src/core/sys/posix/fcntl.d index 3e12f81e6c..7502b616d2 100644 --- a/src/core/sys/posix/fcntl.d +++ b/src/core/sys/posix/fcntl.d @@ -451,6 +451,59 @@ else version( OpenBSD ) enum AT_SYMLINK_FOLLOW = 0x04; enum AT_REMOVEDIR = 0x08; } +else version(NetBSD) +{ + enum F_DUPFD = 0; + enum F_GETFD = 1; + enum F_SETFD = 2; + enum F_GETFL = 3; + enum F_SETFL = 4; + enum F_GETOWN = 5; + enum F_SETOWN = 6; + enum F_GETLK = 7; + enum F_SETLK = 8; + enum F_SETLKW = 9; + enum F_CLOSEM = 10; + enum F_MAXFD = 11; + enum F_DUPFD_CLOEXEC= 12; + enum F_GETNOSIGPIPE = 13; + enum F_SETNOSIGPIPE = 14; + + enum FD_CLOEXEC = 1; + + enum F_RDLCK = 1; + enum F_UNLCK = 2; + enum F_WRLCK = 3; + + enum O_CREAT = 0x0200; + enum O_EXCL = 0x0800; + enum O_NOCTTY = 0x8000; + enum O_TRUNC = 0x0400; + + enum O_RDONLY = 0x0000; + enum O_WRONLY = 0x0001; + enum O_RDWR = 0x0002; + enum O_ACCMODE = 0x0003; + + enum O_NONBLOCK = 0x0004; + enum O_APPEND = 0x0008; + enum O_SYNC = 0x0080; + //enum O_DSYNC + //enum O_RSYNC + + struct flock + { + off_t l_start; + off_t l_len; + pid_t l_pid; + short l_type; + short l_whence; + } + + + int creat(in char*, mode_t); + int open(in char*, int, ...); +} else version (Solaris) { enum F_DUPFD = 0; diff --git a/src/core/sys/posix/grp.d b/src/core/sys/posix/grp.d index 43c6c030ba..1f6ec9514f 100644 --- a/src/core/sys/posix/grp.d +++ b/src/core/sys/posix/grp.d @@ -77,6 +77,16 @@ else version( FreeBSD ) char** gr_mem; } } +else version(NetBSD) +{ + struct group + { + char* gr_name; + char* gr_passwd; + gid_t gr_gid; + char** gr_mem; + } +} else version( OpenBSD ) { struct group @@ -138,6 +148,11 @@ else version( FreeBSD ) int getgrnam_r(in char*, group*, char*, size_t, group**); int getgrgid_r(gid_t, group*, char*, size_t, group**); } +else version(NetBSD) +{ + int getgrnam_r(in char*, group*, char*, size_t, group**); + int getgrgid_r(gid_t, group*, char*, size_t, group**); +} else version( OpenBSD ) { int getgrnam_r(in char*, group*, char*, size_t, group**); @@ -183,6 +198,12 @@ else version( FreeBSD ) @trusted void endgrent(); @trusted void setgrent(); } +else version(NetBSD) +{ + group* getgrent(); + @trusted void endgrent(); + @trusted void setgrent(); +} else version( OpenBSD ) { group* getgrent(); diff --git a/src/core/sys/posix/net/if_.d b/src/core/sys/posix/net/if_.d index 7fd75f03d2..60e51a844b 100644 --- a/src/core/sys/posix/net/if_.d +++ b/src/core/sys/posix/net/if_.d @@ -91,6 +91,21 @@ else version( FreeBSD ) if_nameindex_t* if_nameindex(); void if_freenameindex(if_nameindex_t*); } +else version(NetBSD) +{ + struct if_nameindex_t + { + uint if_index; + char* if_name; + } + + enum IF_NAMESIZE = 16; + + uint if_nametoindex(in char*); + char* if_indextoname(uint, char*); + if_nameindex_t* if_nameindex(); + void if_freenameindex(if_nameindex_t*); +} else version( CRuntime_Bionic ) { enum IF_NAMESIZE = 16; diff --git a/src/core/sys/posix/netdb.d b/src/core/sys/posix/netdb.d index be88fa4535..60ae944d89 100644 --- a/src/core/sys/posix/netdb.d +++ b/src/core/sys/posix/netdb.d @@ -396,6 +396,113 @@ else version( FreeBSD ) enum EAI_SYSTEM = 11; enum EAI_OVERFLOW = 14; } +else version(NetBSD) +{ + struct hostent + { + char* h_name; + char** h_aliases; + int h_addrtype; + int h_length; + char** h_addr_list; + extern (D) char* h_addr() @property { return h_addr_list[0]; } // non-standard + } + + struct netent + { + char* n_name; + char** n_aliases; + int n_addrtype; + uint32_t n_net; +/+ todo +#if (defined(__sparc__) && defined(_LP64)) || \ + (defined(__sh__) && defined(_LP64) && (_BYTE_ORDER == _BIG_ENDIAN)) + int __n_pad0; /* ABI compatibility */ +#endif + uint32_t n_net; /*%< network # */ +#if defined(__alpha__) || (defined(__i386__) && defined(_LP64)) || \ + (defined(__sh__) && defined(_LP64) && (_BYTE_ORDER == _LITTLE_ENDIAN)) + int __n_pad0; /* ABI compatibility */ +#endif + ++/ + } + + struct protoent + { + char* p_name; + char** p_aliases; + int p_proto; + } + + struct servent + { + char* s_name; + char** s_aliases; + int s_port; + char* s_proto; + } + + enum IPPORT_RESERVED = 1024; + + //h_errno + + enum HOST_NOT_FOUND = 1; + enum NO_DATA = 4; + enum NO_RECOVERY = 3; + enum TRY_AGAIN = 2; + + struct addrinfo + { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; +/+todo +#if defined(__sparc__) && defined(_LP64) + int __ai_pad0; /* ABI compatibility */ +#endif ++/ + socklen_t ai_addrlen; +/+todo +#if defined(__alpha__) || (defined(__i386__) && defined(_LP64)) + int __ai_pad0; /* ABI compatibility */ +#endif ++/ + char* ai_canonname; + sockaddr* ai_addr; + addrinfo* ai_next; + } + + enum AI_PASSIVE = 0x1; + enum AI_CANONNAME = 0x2; + enum AI_NUMERICHOST = 0x4; + enum AI_NUMERICSERV = 0x8; + enum AI_V4MAPPED = 0x800; + enum AI_ALL = 0x100; + enum AI_ADDRCONFIG = 0x400; + + enum NI_NOFQDN = 0x1; + enum NI_NUMERICHOST = 0x2; + enum NI_NAMEREQD = 0x4; + enum NI_NUMERICSERV = 0x8; + enum NI_DGRAM = 0x10; + enum NI_WITHSCOPEID = 0x00000020; + enum NI_NUMERICSCOPE = 0x00000040; + enum NI_MAXHOST = 1025; // non-standard + enum NI_MAXSERV = 32; // non-standard + + enum EAI_AGAIN = 2; + enum EAI_BADFLAGS = 3; + enum EAI_FAIL = 4; + enum EAI_FAMILY = 5; + enum EAI_MEMORY = 6; + enum EAI_NONAME = 8; + enum EAI_SERVICE = 9; + enum EAI_SOCKTYPE = 10; + enum EAI_SYSTEM = 11; + enum EAI_OVERFLOW = 14; +} else version( OpenBSD ) { struct hostent diff --git a/src/core/sys/posix/netinet/in_.d b/src/core/sys/posix/netinet/in_.d index 5ac0bcd92c..061ed48933 100644 --- a/src/core/sys/posix/netinet/in_.d +++ b/src/core/sys/posix/netinet/in_.d @@ -211,6 +211,41 @@ else version( FreeBSD ) //enum INET_ADDRSTRLEN = 16; } +else version(NetBSD) +{ + struct sockaddr_in + { + ubyte sin_len; + sa_family_t sin_family; + in_port_t sin_port; + in_addr sin_addr; + ubyte[8] sin_zero; + } + + enum + { + IPPROTO_IP = 0, + IPPROTO_ICMP = 1, + IPPROTO_IGMP = 2, + IPPROTO_GGP = 3, + IPPROTO_TCP = 6, + IPPROTO_PUP = 12, + IPPROTO_UDP = 17, + IPPROTO_IDP = 22, + IPPROTO_ND = 77, + IPPROTO_MAX = 256 + } + + enum : uint + { + INADDR_ANY = 0x00000000, + INADDR_BROADCAST = 0xffffffff, + INADDR_LOOPBACK = 0x7f000001, + INADDR_NONE = 0xffffffff + } + + //enum INET_ADDRSTRLEN = 16; +} else version( Solaris ) { struct sockaddr_in @@ -722,6 +757,145 @@ else version( FreeBSD ) __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL; } } +else version(NetBSD) +{ + struct in6_addr + { + union + { + uint8_t[16] s6_addr; + uint16_t[8] s6_addr16; + uint32_t[4] s6_addr32; + } + } + + struct sockaddr_in6 + { + uint8_t sin6_len; + sa_family_t sin6_family; + in_port_t sin6_port; + uint32_t sin6_flowinfo; + in6_addr sin6_addr; + uint32_t sin6_scope_id; + } + + extern __gshared immutable in6_addr in6addr_any; + extern __gshared immutable in6_addr in6addr_loopback; + + struct ipv6_mreq + { + in6_addr ipv6mr_multiaddr; + uint ipv6mr_interface; + } + + enum : uint + { + IPPROTO_IPV6 = 41, + + //INET6_ADDRSTRLEN = 46, + + IPV6_JOIN_GROUP = 12, + IPV6_LEAVE_GROUP = 13, + IPV6_MULTICAST_HOPS = 10, + IPV6_MULTICAST_IF = 9, + IPV6_MULTICAST_LOOP = 11, + IPV6_UNICAST_HOPS = 4, + IPV6_V6ONLY = 27, + } + + private enum + { + __IPV6_ADDR_SCOPE_NODELOCAL = 0x01, + __IPV6_ADDR_SCOPE_INTFACELOCAL = 0x01, + __IPV6_ADDR_SCOPE_LINKLOCAL = 0x02, + __IPV6_ADDR_SCOPE_SITELOCAL = 0x05, + __IPV6_ADDR_SCOPE_ORGLOCAL = 0x08, + __IPV6_ADDR_SCOPE_GLOBAL = 0x0e, + } + + // macros + extern (D) int IN6_IS_ADDR_UNSPECIFIED( in in6_addr* a ) pure + { + return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) == 0); + } + + extern (D) int IN6_IS_ADDR_LOOPBACK( in in6_addr* a ) pure + { + return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) == ntohl(1)); + } + + extern (D) int IN6_IS_ADDR_V4COMPAT( in in6_addr* a ) pure + { + return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) != 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) != ntohl(1)); + } + + extern (D) int IN6_IS_ADDR_V4MAPPED( in in6_addr* a ) pure + { + return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) && + (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == ntohl(0x0000ffff)); + } + + extern (D) int IN6_IS_ADDR_LINKLOCAL( in in6_addr* a ) pure + { + return a.s6_addr[0] == 0xfe && (a.s6_addr[1] & 0xc0) == 0x80; + } + + extern (D) int IN6_IS_ADDR_SITELOCAL( in in6_addr* a ) pure + { + return a.s6_addr[0] == 0xfe && (a.s6_addr[1] & 0xc0) == 0xc0; + } + + extern (D) int IN6_IS_ADDR_MULTICAST( in in6_addr* a ) pure + { + return a.s6_addr[0] == 0xff; + } + + extern (D) uint8_t __IPV6_ADDR_MC_SCOPE( in in6_addr* a ) pure + { + return a.s6_addr[1] & 0x0f; + } + + extern (D) int IN6_IS_ADDR_MC_NODELOCAL( in in6_addr* a ) pure + { + return IN6_IS_ADDR_MULTICAST(a) && + __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_NODELOCAL; + } + + extern (D) int IN6_IS_ADDR_MC_LINKLOCAL( in in6_addr* a ) pure + { + return IN6_IS_ADDR_MULTICAST(a) && + __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_LINKLOCAL; + } + + extern (D) int IN6_IS_ADDR_MC_SITELOCAL( in in6_addr* a ) pure + { + return IN6_IS_ADDR_MULTICAST(a) && + __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_SITELOCAL; + } + + extern (D) int IN6_IS_ADDR_MC_ORGLOCAL( in in6_addr* a ) pure + { + return IN6_IS_ADDR_MULTICAST(a) && + __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_ORGLOCAL; + } + + extern (D) int IN6_IS_ADDR_MC_GLOBAL( in in6_addr* a ) pure + { + return IN6_IS_ADDR_MULTICAST(a) && + __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL; + } +} else version( Solaris ) { struct in6_addr @@ -998,6 +1172,10 @@ else version( FreeBSD ) { enum uint IPPROTO_RAW = 255; } +else version(NetBSD) +{ + enum uint IPPROTO_RAW = 255; +} else version( Solaris ) { enum uint IPPROTO_RAW = 255; diff --git a/src/core/sys/posix/netinet/tcp.d b/src/core/sys/posix/netinet/tcp.d index ad3e00cfc1..40ac9dd369 100644 --- a/src/core/sys/posix/netinet/tcp.d +++ b/src/core/sys/posix/netinet/tcp.d @@ -47,6 +47,10 @@ else version( FreeBSD ) { enum TCP_NODELAY = 1; } +else version(NetBSD) +{ + enum TCP_NODELAY = 1; +} else version( Solaris ) { enum TCP_NODELAY = 1; diff --git a/src/core/sys/posix/poll.d b/src/core/sys/posix/poll.d index dc3ead60ce..4e67b4a37e 100644 --- a/src/core/sys/posix/poll.d +++ b/src/core/sys/posix/poll.d @@ -152,6 +152,40 @@ else version( FreeBSD ) int poll(pollfd*, nfds_t, int); } +else version(NetBSD) +{ + alias uint nfds_t; + + struct pollfd + { + int fd; + short events; + short revents; + }; + + enum + { + POLLIN = 0x0001, + POLLPRI = 0x0002, + POLLOUT = 0x0004, + POLLRDNORM = 0x0040, + POLLWRNORM = POLLOUT, + POLLRDBAND = 0x0080, + POLLWRBAND = 0x0100, + //POLLEXTEND = 0x0200, + //POLLATTRIB = 0x0400, + //POLLNLINK = 0x0800, + //POLLWRITE = 0x1000, + POLLERR = 0x0008, + POLLHUP = 0x0010, + POLLNVAL = 0x0020, + + POLLSTANDARD = (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLRDBAND| + POLLWRBAND|POLLERR|POLLHUP|POLLNVAL) + } + + int poll(pollfd*, nfds_t, int); +} else version( OpenBSD ) { alias uint nfds_t; diff --git a/src/core/sys/posix/pthread.d b/src/core/sys/posix/pthread.d index 60cd76d589..d7b51b3d01 100644 --- a/src/core/sys/posix/pthread.d +++ b/src/core/sys/posix/pthread.d @@ -218,6 +218,42 @@ else version( FreeBSD ) enum PTHREAD_COND_INITIALIZER = null; enum PTHREAD_RWLOCK_INITIALIZER = null; } +else version(NetBSD) +{ + enum PRI_NONE = -1; + enum + { + PTHREAD_INHERIT_SCHED = 0x0, + + PTHREAD_CREATE_DETACHED = 1, + PTHREAD_CREATE_JOINABLE = 0, + PTHREAD_EXPLICIT_SCHED = 1, + } + + enum + { + PTHREAD_PROCESS_PRIVATE = 0, + PTHREAD_PROCESS_SHARED = 1, + } + + enum + { + PTHREAD_CANCEL_ENABLE = 0, + PTHREAD_CANCEL_DISABLE = 1, + PTHREAD_CANCEL_DEFERRED = 0, + PTHREAD_CANCEL_ASYNCHRONOUS = 1, + } + + enum PTHREAD_CANCELED = cast(void*) 1; + + enum PTHREAD_DONE_INIT = 1; + + enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0x33330003); + + enum PTHREAD_ONCE_INIT = pthread_once_t(PTHREAD_MUTEX_INITIALIZER); + enum PTHREAD_COND_INITIALIZER = pthread_cond_t(0x55550005); + enum PTHREAD_RWLOCK_INITIALIZER = pthread_rwlock_t(0x99990009); +} else version( OpenBSD ) { enum @@ -412,6 +448,33 @@ else version( FreeBSD ) void __pthread_cleanup_push_imp(_pthread_cleanup_routine_nogc, void*, _pthread_cleanup_info*) @nogc; void __pthread_cleanup_pop_imp(int); } +else version(NetBSD) +{ + alias void function(void*) _pthread_cleanup_routine; + + struct _pthread_cleanup_store + { + void*[4] pthread_cleanup_pad; + } + + struct pthread_cleanup + { + _pthread_cleanup_store __cleanup_info__ = void; + + extern (D) void push()( _pthread_cleanup_routine cleanup_routine, void* cleanup_arg ) + { + pthread__cleanup_push( cleanup_routine, cleanup_arg, &__cleanup_info__ ); + } + + extern (D) void pop()( int execute ) + { + pthread__cleanup_pop( execute, &__cleanup_info__ ); + } + } + + void pthread__cleanup_push(_pthread_cleanup_routine, void*, void*); + void pthread__cleanup_pop(int, void *); +} else version ( OpenBSD ) { void pthread_cleanup_push(void function(void*), void*); @@ -561,6 +624,18 @@ else version( FreeBSD ) int pthread_barrierattr_init(pthread_barrierattr_t*); int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); } +else version(NetBSD) +{ + enum PTHREAD_BARRIER_SERIAL_THREAD = 1234567; + + int pthread_barrier_destroy(pthread_barrier_t*); + int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint); + int pthread_barrier_wait(pthread_barrier_t*); + int pthread_barrierattr_destroy(pthread_barrierattr_t*); + int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*); + int pthread_barrierattr_init(pthread_barrierattr_t*); + int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); +} else version( OpenBSD ) { enum PTHREAD_BARRIER_SERIAL_THREAD = -1; @@ -631,6 +706,14 @@ else version( FreeBSD ) int pthread_spin_trylock(pthread_spinlock_t*); int pthread_spin_unlock(pthread_spinlock_t*); } +else version(NetBSD) +{ + int pthread_spin_init(pthread_spinlock_t*, int); + int pthread_spin_destroy(pthread_spinlock_t*); + int pthread_spin_lock(pthread_spinlock_t*); + int pthread_spin_trylock(pthread_spinlock_t*); + int pthread_spin_unlock(pthread_spinlock_t*); +} else version( OpenBSD ) { int pthread_spin_init(pthread_spinlock_t*, int); @@ -722,6 +805,24 @@ else version( FreeBSD ) int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; int pthread_setconcurrency(int); } +else version(NetBSD) +{ + enum + { + PTHREAD_MUTEX_NORMAL = 0, + PTHREAD_MUTEX_ERRORCHECK = 1, + PTHREAD_MUTEX_RECURSIVE = 2, + PTHREAD_MUTEX_TYPE_MAX + } + enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK; + + int pthread_attr_getguardsize(in pthread_attr_t*, size_t*); + int pthread_attr_setguardsize(pthread_attr_t*, size_t); + int pthread_getconcurrency(); + int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); + int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; + int pthread_setconcurrency(int); +} else version( OpenBSD ) { enum @@ -791,6 +892,9 @@ else version( FreeBSD ) { int pthread_getcpuclockid(pthread_t, clockid_t*); } +else version(NetBSD) +{ +} else version( OpenBSD ) { int pthread_getcpuclockid(pthread_t, clockid_t*); @@ -837,6 +941,12 @@ else version( FreeBSD ) int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*); int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*); } +else version(NetBSD) +{ + int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*); + int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*); + int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*); +} else version( OpenBSD ) { int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*); @@ -979,6 +1089,24 @@ else version( FreeBSD ) int pthread_setschedparam(pthread_t, int, sched_param*); // int pthread_setschedprio(pthread_t, int); // not implemented } +else version(NetBSD) +{ + enum + { + PTHREAD_SCOPE_PROCESS = 0, + PTHREAD_SCOPE_SYSTEM = 0x1 + } + + int pthread_attr_getinheritsched(in pthread_attr_t*, int*); + int pthread_attr_getschedpolicy(in pthread_attr_t*, int*); + int pthread_attr_getscope(in pthread_attr_t*, int*); + int pthread_attr_setinheritsched(pthread_attr_t*, int); + int pthread_attr_setschedpolicy(pthread_attr_t*, int); + int pthread_attr_setscope(in pthread_attr_t*, int); + int pthread_getschedparam(pthread_t, int*, sched_param*); + int pthread_setschedparam(pthread_t, int, sched_param*); + //int pthread_setschedprio(pthread_t, int); +} else version( OpenBSD ) { enum @@ -1074,6 +1202,15 @@ else version( FreeBSD ) int pthread_attr_setstackaddr(pthread_attr_t*, void*); int pthread_attr_setstacksize(pthread_attr_t*, size_t); } +else version(NetBSD) +{ + int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); + int pthread_attr_getstackaddr(in pthread_attr_t*, void**); + int pthread_attr_getstacksize(in pthread_attr_t*, size_t*); + int pthread_attr_setstack(pthread_attr_t*, void*, size_t); + int pthread_attr_setstackaddr(pthread_attr_t*, void*); + int pthread_attr_setstacksize(pthread_attr_t*, size_t); +} else version( OpenBSD ) { int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); @@ -1136,6 +1273,15 @@ else version( FreeBSD ) int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*); int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); } +else version(NetBSD) +{ + int pthread_condattr_getpshared(in pthread_condattr_t*, int*); + int pthread_condattr_setpshared(pthread_condattr_t*, int); + int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*); + int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); + int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*); + int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); +} else version( OpenBSD ) { } diff --git a/src/core/sys/posix/pwd.d b/src/core/sys/posix/pwd.d index ddd35f9952..34590c7fe5 100644 --- a/src/core/sys/posix/pwd.d +++ b/src/core/sys/posix/pwd.d @@ -94,6 +94,22 @@ else version( FreeBSD ) int pw_fields; /* internal: fields filled in */ } } +else version(NetBSD) +{ + struct passwd + { + char* pw_name; /* user name */ + char* pw_passwd; /* encrypted password */ + uid_t pw_uid; /* user uid */ + gid_t pw_gid; /* user gid */ + time_t pw_change; /* password change time */ + char* pw_class; /* user access class */ + char* pw_gecos; /* Honeywell login info */ + char* pw_dir; /* home directory */ + char* pw_shell; /* default shell */ + time_t pw_expire; /* account expiration */ + } +} else version( OpenBSD ) { struct passwd @@ -168,6 +184,13 @@ else version( FreeBSD ) int getpwnam_r(in char*, passwd*, char*, size_t, passwd**); int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**); } +else version(NetBSD) +{ + int __getpwnam_r50(in char*, passwd*, char*, size_t, passwd**); + alias __getpwnam_r50 getpwnam_r; + int __getpwuid_r50(uid_t, passwd*, char*, size_t, passwd**); + alias __getpwuid_r50 getpwuid_r; +} else version( OpenBSD ) { int getpwnam_r(in char*, passwd*, char*, size_t, passwd**); @@ -213,6 +236,12 @@ else version ( FreeBSD ) passwd* getpwent(); void setpwent(); } +else version (NetBSD) +{ + void endpwent(); + passwd* getpwent(); + void setpwent(); +} else version ( OpenBSD ) { void endpwent(); diff --git a/src/core/sys/posix/sched.d b/src/core/sys/posix/sched.d index 637545cf16..3f93b989bb 100644 --- a/src/core/sys/posix/sched.d +++ b/src/core/sys/posix/sched.d @@ -95,6 +95,17 @@ else version( FreeBSD ) enum SCHED_OTHER = 2; enum SCHED_RR = 3; } +else version(NetBSD) +{ + struct sched_param + { + int sched_priority; + } + + enum SCHED_FIFO = 1; + enum SCHED_OTHER = 0; + enum SCHED_RR = 2; +} else version( OpenBSD ) { struct sched_param @@ -164,6 +175,10 @@ else version( FreeBSD ) { int sched_yield(); } +else version(NetBSD) +{ + int sched_yield(); +} else version( OpenBSD ) { int sched_yield(); @@ -208,6 +223,12 @@ else version( FreeBSD ) int sched_get_priority_max(int); int sched_rr_get_interval(pid_t, timespec*); } +else version(NetBSD) +{ + int sched_get_priority_min(int); + int sched_get_priority_max(int); + int sched_rr_get_interval(pid_t, timespec*); +} else version( OpenBSD ) { int sched_get_priority_min(int); diff --git a/src/core/sys/posix/semaphore.d b/src/core/sys/posix/semaphore.d index ba29482285..32027eefb9 100644 --- a/src/core/sys/posix/semaphore.d +++ b/src/core/sys/posix/semaphore.d @@ -90,6 +90,12 @@ else version( FreeBSD ) enum SEM_FAILED = cast(sem_t*) null; } +else version(NetBSD) +{ + alias size_t sem_t; + + enum SEM_FAILED = cast(sem_t*) null; +} else version( OpenBSD ) { struct __sem { } @@ -153,6 +159,10 @@ else version( FreeBSD ) { int sem_timedwait(sem_t*, in timespec*); } +else version(NetBSD) +{ + int sem_timedwait(sem_t*, in timespec*); +} else version( OpenBSD ) { int sem_timedwait(sem_t*, in timespec*); diff --git a/src/core/sys/posix/setjmp.d b/src/core/sys/posix/setjmp.d index 8a1d4cc59f..3c8a78ee25 100644 --- a/src/core/sys/posix/setjmp.d +++ b/src/core/sys/posix/setjmp.d @@ -170,6 +170,26 @@ else version( FreeBSD ) int setjmp(ref jmp_buf); void longjmp(ref jmp_buf, int); } +else version(NetBSD) +{ + // + version( X86 ) + { + enum _JBLEN = 13; + struct _jmp_buf { int[_JBLEN + 1] _jb; } + } + else version( X86_64) + { + enum _JBLEN = 11; + struct _jmp_buf { c_long[_JBLEN] _jb; } + } + else + static assert(0); + alias _jmp_buf[_JBLEN] jmp_buf; + + int setjmp(ref jmp_buf); + void longjmp(ref jmp_buf, int); +} else version( OpenBSD ) { // @@ -277,6 +297,24 @@ else version( FreeBSD ) int sigsetjmp(ref sigjmp_buf); void siglongjmp(ref sigjmp_buf, int); } +else version(NetBSD) +{ + // + version( X86 ) + { + struct _sigjmp_buf { int[_JBLEN + 1] _ssjb; } + } + else version( X86_64) + { + struct _sigjmp_buf { c_long[_JBLEN] _sjb; } + } + else + static assert(0); + alias _sigjmp_buf[_JBLEN + 1] sigjmp_buf; + + int sigsetjmp(ref sigjmp_buf); + void siglongjmp(ref sigjmp_buf, int); +} else version( OpenBSD ) { alias sigjmp_buf = c_long[_JBLEN + 1]; @@ -310,6 +348,11 @@ else version( FreeBSD ) int _setjmp(ref jmp_buf); void _longjmp(ref jmp_buf, int); } +else version(NetBSD) +{ + int _setjmp(ref jmp_buf); + void _longjmp(ref jmp_buf, int); +} else version( OpenBSD ) { int _setjmp(ref jmp_buf); diff --git a/src/core/sys/posix/signal.d b/src/core/sys/posix/signal.d index dcdac9ab10..b14848a8ec 100644 --- a/src/core/sys/posix/signal.d +++ b/src/core/sys/posix/signal.d @@ -164,6 +164,11 @@ else version (FreeBSD) { enum SIGRTMAX = 126; } // Note: it appears that FreeBSD (prior to 7) and OSX do not support realtime signals +else version(NetBSD) +{ + enum SIGRTMIN = 33; + enum SIGRTMAX = 63; +} version( linux ) { @@ -434,6 +439,30 @@ else version( FreeBSD ) enum SIGUSR2 = 31; enum SIGURG = 16; } +else version(NetBSD) +{ + //SIGABRT (defined in core.stdc.signal) + enum SIGALRM = 14; + enum SIGBUS = 10; + enum SIGCHLD = 20; + enum SIGCONT = 19; + //SIGFPE (defined in core.stdc.signal) + enum SIGHUP = 1; + //SIGILL (defined in core.stdc.signal) + //SIGINT (defined in core.stdc.signal) + enum SIGKILL = 9; + enum SIGPIPE = 13; + enum SIGQUIT = 3; + //SIGSEGV (defined in core.stdc.signal) + enum SIGSTOP = 17; + //SIGTERM (defined in core.stdc.signal) + enum SIGTSTP = 18; + enum SIGTTIN = 21; + enum SIGTTOU = 22; + enum SIGUSR1 = 30; + enum SIGUSR2 = 31; + enum SIGURG = 16; +} else version( OpenBSD ) { //SIGABRT (defined in core.stdc.signal) @@ -516,7 +545,20 @@ else version( FreeBSD ) sigset_t sa_mask; } } -else version( OpenBSD ) +else version(NetBSD) +{ + struct sigaction_t + { + union + { + sigfn_t sa_handler; + sigactfn_t sa_sigaction; + } + sigset_t sa_mask; + int sa_flags; + } +} +else version(OpenBSD) { struct sigaction_t { @@ -933,6 +975,100 @@ else version( FreeBSD ) int sigsuspend(in sigset_t *); int sigwait(in sigset_t*, int*); } +else version(NetBSD) +{ + enum SIG_HOLD = cast(sigfn_t2) 3; + + struct sigset_t + { + uint[4] __bits; + } + + enum SA_NOCLDSTOP = 8; + + enum SIG_BLOCK = 1; + enum SIG_UNBLOCK = 2; + enum SIG_SETMASK = 3; + + union sigval_t { + int sival_int; + void *sival_ptr; + }; + struct _rt{ + pid_t _pid; + uid_t _uid; + sigval_t _value; + }; + struct _child{ + pid_t _pid; + uid_t _uid; + int _status; + clock_t _utime; + clock_t _stime; + }; + struct _fault{ + void *_addr; + int _trap; + int _trap2; + int _trap3; + }; + struct _poll{ + long _band; + int _fd; + }; + union _reason{ + _rt rt; + _child child; + _fault fault; + _poll poll; + }; + struct _ksiginfo { + int _signo; + int _code; + int _errno; +/+#ifdef _LP64 + /* In _LP64 the union starts on an 8-byte boundary. */ + int _pad; +#endif+/ + _reason reason; + }; + + + union siginfo_t + { + ubyte[128] si_pad;/* Total size; for future expansion */ + _ksiginfo _info; + @property ref c_long si_band() return { return _info.reason.poll._band; } + } + + enum SI_USER = 0; + enum SI_QUEUE = -1; + enum SI_TIMER = -2; + enum SI_ASYNCIO = -3; + enum SI_MESGQ = -4; + + int kill(pid_t, int); + int __sigaction14(int, in sigaction_t*, sigaction_t*); + int __sigaddset14(sigset_t*, int); + int __sigdelset14(sigset_t*, int); + int __sigemptyset14(sigset_t *); + int __sigfillset14(sigset_t *); + int __sigismember14(in sigset_t *, int); + int __sigpending14(sigset_t *); + int __sigprocmask14(int, in sigset_t*, sigset_t*); + int __sigsuspend14(in sigset_t *); + int sigwait(in sigset_t*, int*); + + alias __sigaction14 sigaction; + alias __sigaddset14 sigaddset; + alias __sigdelset14 sigdelset; + alias __sigemptyset14 sigemptyset; + alias __sigfillset14 sigfillset; + alias __sigismember14 sigismember; + alias __sigpending14 sigpending; + alias __sigprocmask14 sigprocmask; + alias __sigsuspend14 sigsuspend; +} else version( OpenBSD ) { enum SIG_CATCH = cast(sigfn_t2) 2; @@ -1780,6 +1916,130 @@ else version( FreeBSD ) int sigpause(int); int sigrelse(int); } +else version(NetBSD) +{ + // No SIGPOLL on *BSD + enum SIGPROF = 27; + enum SIGSYS = 12; + enum SIGTRAP = 5; + enum SIGVTALRM = 26; + enum SIGXCPU = 24; + enum SIGXFSZ = 25; + + enum + { + SA_ONSTACK = 0x0001, + SA_RESTART = 0x0002, + SA_RESETHAND = 0x0004, + SA_NODEFER = 0x0010, + SA_NOCLDWAIT = 0x0020, + SA_SIGINFO = 0x0040, + } + + enum + { + SS_ONSTACK = 0x0001, + SS_DISABLE = 0x0004, + } + + enum MINSIGSTKSZ = 8192; + enum SIGSTKSZ = (MINSIGSTKSZ + 32768); +; + //ucontext_t (defined in core.sys.posix.ucontext) + //mcontext_t (defined in core.sys.posix.ucontext) + + struct stack_t + { + void* ss_sp; + size_t ss_size; + int ss_flags; + } + + struct sigstack + { + void* ss_sp; + int ss_onstack; + } + + enum + { + ILL_ILLOPC = 1, + ILL_ILLOPN, + ILL_ILLADR, + ILL_ILLTRP, + ILL_PRVOPC, + ILL_PRVREG, + ILL_COPROC, + ILL_BADSTK, + } + + enum + { + BUS_ADRALN = 1, + BUS_ADRERR, + BUS_OBJERR, + } + + enum + { + SEGV_MAPERR = 1, + SEGV_ACCERR, + } + + enum + { + FPE_INTOVF = 1, + FPE_INTDIV, + FPE_FLTDIV, + FPE_FLTOVF, + FPE_FLTUND, + FPE_FLTRES, + FPE_FLTINV, + FPE_FLTSUB, + } + + enum + { + TRAP_BRKPT = 1, + TRAP_TRACE, + } + + enum + { + CLD_EXITED = 1, + CLD_KILLED, + CLD_DUMPED, + CLD_TRAPPED, + CLD_STOPPED, + CLD_CONTINUED, + } + + enum + { + POLL_IN = 1, + POLL_OUT, + POLL_MSG, + POLL_ERR, + POLL_PRI, + POLL_HUP, + } + + //sigfn_t bsd_signal(int sig, sigfn_t func); + sigfn_t sigset(int sig, sigfn_t func); + + nothrow: + @nogc: + //sigfn_t2 bsd_signal(int sig, sigfn_t2 func); + sigfn_t2 sigset(int sig, sigfn_t2 func); + + int killpg(pid_t, int); + int sigaltstack(in stack_t*, stack_t*); + int sighold(int); + int sigignore(int); + int siginterrupt(int, int); + int sigpause(int); + int sigrelse(int); +} else version (OpenBSD) { // No SIGPOLL on *BSD @@ -2199,6 +2459,14 @@ else version( FreeBSD ) c_long tv_nsec; } } +else version(NetBSD) +{ + struct timespec + { + time_t tv_sec; + c_long tv_nsec; + } +} else version( OpenBSD ) { struct timespec @@ -2302,6 +2570,21 @@ else version( FreeBSD ) int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*); int sigwaitinfo(in sigset_t*, siginfo_t*); } +else version(NetBSD) +{ + struct sigevent + { + int sigev_notify; + int sigev_signo; + sigval sigev_value; + void function(sigval) sigev_notify_function; + void /* pthread_attr_t */*sigev_notify_attributes; + } + + int sigqueue(pid_t, int, in sigval); + int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*); + int sigwaitinfo(in sigset_t*, siginfo_t*); +} else version (OpenBSD) { } @@ -2378,6 +2661,11 @@ else version( FreeBSD ) int pthread_kill(pthread_t, int); int pthread_sigmask(int, in sigset_t*, sigset_t*); } +else version(NetBSD) +{ + int pthread_kill(pthread_t, int); + int pthread_sigmask(int, in sigset_t*, sigset_t*); +} else version( OpenBSD ) { int pthread_kill(pthread_t, int); diff --git a/src/core/sys/posix/stdio.d b/src/core/sys/posix/stdio.d index c085c862ce..2650af5f9d 100644 --- a/src/core/sys/posix/stdio.d +++ b/src/core/sys/posix/stdio.d @@ -291,6 +291,10 @@ version( FreeBSD ) { enum P_tmpdir = "/var/tmp/"; } +version(NetBSD) +{ + enum P_tmpdir = "/var/tmp/"; +} version( OpenBSD ) { enum P_tmpdir = "/tmp/"; diff --git a/src/core/sys/posix/stdlib.d b/src/core/sys/posix/stdlib.d index 4afd346d46..e4777def65 100644 --- a/src/core/sys/posix/stdlib.d +++ b/src/core/sys/posix/stdlib.d @@ -100,6 +100,10 @@ else version( FreeBSD ) { int posix_memalign(void**, size_t, size_t); } +else version(NetBSD) +{ + int posix_memalign(void**, size_t, size_t); +} else version( OpenBSD ) { int posix_memalign(void**, size_t, size_t); @@ -138,6 +142,13 @@ else version( FreeBSD ) void* valloc(size_t); // LEGACY non-standard } +else version(NetBSD) +{ + int setenv(in char*, in char*, int); + int __unsetenv13(in char*); + alias __unsetenv13 unsetenv; + void* valloc(size_t); // LEGACY non-standard +} else version( OpenBSD ) { int setenv(in char*, in char*, int); @@ -179,6 +190,10 @@ else version( FreeBSD ) { int rand_r(uint*); } +else version(NetBSD) +{ + int rand_r(uint*); +} else version( OpenBSD ) { int rand_r(uint*); @@ -366,6 +381,47 @@ else version( FreeBSD ) void srandom(uint); int unlockpt(int); } +else version(NetBSD) +{ + //WNOHANG (defined in core.sys.posix.sys.wait) + //WUNTRACED (defined in core.sys.posix.sys.wait) + //WEXITSTATUS (defined in core.sys.posix.sys.wait) + //WIFEXITED (defined in core.sys.posix.sys.wait) + //WIFSIGNALED (defined in core.sys.posix.sys.wait) + //WIFSTOPPED (defined in core.sys.posix.sys.wait) + //WSTOPSIG (defined in core.sys.posix.sys.wait) + //WTERMSIG (defined in core.sys.posix.sys.wait) + + c_long a64l(in char*); + double drand48(); + //char* ecvt(double, int, int *, int *); // LEGACY + double erand48(ref ushort[3]); + //char* fcvt(double, int, int *, int *); // LEGACY + //char* gcvt(double, int, char*); // LEGACY + int getsubopt(char**, in char**, char**); + int grantpt(int); + char* initstate(uint, char*, size_t); + c_long jrand48(ref ushort[3]); + char* l64a(c_long); + void lcong48(ref ushort[7]); + c_long lrand48(); + char* mktemp(char*); // LEGACY + int mkstemp(char*); + char* mkdtemp(char*); // Defined in IEEE 1003.1, 2008 Edition + c_long mrand48(); + c_long nrand48(ref ushort[3]); + int posix_openpt(int); + char* ptsname(int); + int putenv(char*); + c_long random(); + char* realpath(in char*, char*); + ushort *seed48(ref ushort[3]); + void setkey(in char*); + char* setstate(in char*); + void srand48(c_long); + void srandom(uint); + int unlockpt(int); +} else version( OpenBSD ) { //WNOHANG (defined in core.sys.posix.sys.wait) diff --git a/src/core/sys/posix/sys/ioctl.d b/src/core/sys/posix/sys/ioctl.d index abeffe3f22..8c2e778d82 100644 --- a/src/core/sys/posix/sys/ioctl.d +++ b/src/core/sys/posix/sys/ioctl.d @@ -367,6 +367,18 @@ else version (FreeBSD) int ioctl(int, c_ulong, ...); } +else version (NetBSD) +{ + struct winsize + { + ushort ws_row; + ushort ws_col; + ushort ws_xpixel; + ushort ws_ypixel; + } + + int ioctl(int, c_ulong, ...); +} else version (Solaris) { int ioctl(int fildes, int request, ...); diff --git a/src/core/sys/posix/sys/ipc.d b/src/core/sys/posix/sys/ipc.d index 32ccffd46b..5c9c2526b6 100644 --- a/src/core/sys/posix/sys/ipc.d +++ b/src/core/sys/posix/sys/ipc.d @@ -124,6 +124,31 @@ else version( FreeBSD ) key_t ftok(in char*, int); } +else version(NetBSD) +{ + struct ipc_perm + { + uid_t cuid; + gid_t cgid; + uid_t uid; + gid_t gid; + mode_t mode; + ushort seq; + key_t key; + } + + enum IPC_CREAT = 0x0100; // 01000 + enum IPC_EXCL = 0x0200; // 02000 + enum IPC_NOWAIT = 0x0400; // 04000 + + enum key_t IPC_PRIVATE = 0; + + enum IPC_RMID = 0; + enum IPC_SET = 1; + enum IPC_STAT = 2; + + key_t ftok(in char*, int); +} else version( CRuntime_Bionic ) { // All except ftok are from the linux kernel headers. diff --git a/src/core/sys/posix/sys/mman.d b/src/core/sys/posix/sys/mman.d index 134e8c2699..104c29da2e 100644 --- a/src/core/sys/posix/sys/mman.d +++ b/src/core/sys/posix/sys/mman.d @@ -85,6 +85,15 @@ else version( FreeBSD ) enum POSIX_MADV_DONTNEED = 4; int posix_madvise(void *addr, size_t len, int advice); } +else version(NetBSD) +{ + enum POSIX_MADV_NORMAL = 0; + enum POSIX_MADV_RANDOM = 1; + enum POSIX_MADV_SEQUENTIAL = 2; + enum POSIX_MADV_WILLNEED = 3; + enum POSIX_MADV_DONTNEED = 4; + int posix_madvise(void *addr, size_t len, int advice); +} else version (Solaris) { } @@ -127,6 +136,13 @@ else version( FreeBSD ) enum PROT_WRITE = 0x02; enum PROT_EXEC = 0x04; } +else version(NetBSD) +{ + enum PROT_NONE = 0x00; + enum PROT_READ = 0x01; + enum PROT_WRITE = 0x02; + enum PROT_EXEC = 0x04; +} else version (Solaris) { enum PROT_NONE = 0x00; @@ -173,6 +189,11 @@ else version( FreeBSD ) void* mmap(void*, size_t, int, int, int, off_t); int munmap(void*, size_t); } +else version(NetBSD) +{ + void* mmap(void*, size_t, int, int, int, off_t); + int munmap(void*, size_t); +} else version (Solaris) { void* mmap(void*, size_t, int, int, int, off_t); @@ -327,6 +348,22 @@ else version( FreeBSD ) int msync(void*, size_t, int); } +else version(NetBSD) +{ + enum MAP_SHARED = 0x0001; + enum MAP_PRIVATE = 0x0002; + enum MAP_FIXED = 0x0010; + enum MAP_ANON = 0x1000; + + enum MAP_FAILED = cast(void*)-1; + + enum MS_SYNC = 0x0004; + enum MS_ASYNC = 0x0001; + enum MS_INVALIDATE = 0x0002; + + int __msync13(void*, size_t, int); + alias msync = __msync13; +} else version (Solaris) { enum MAP_SHARED = 0x0001; @@ -438,6 +475,14 @@ else version( FreeBSD ) int mlockall(int); int munlockall(); } +else version(NetBSD) +{ + enum MCL_CURRENT = 0x0001; + enum MCL_FUTURE = 0x0002; + + int mlockall(int); + int munlockall(); +} else version (Solaris) { enum MCL_CURRENT = 0x0001; @@ -482,6 +527,11 @@ else version( FreeBSD ) int mlock(in void*, size_t); int munlock(in void*, size_t); } +else version(NetBSD) +{ + int mlock(in void*, size_t); + int munlock(in void*, size_t); +} else version (Solaris) { int mlock(in void*, size_t); @@ -516,6 +566,10 @@ else version( FreeBSD ) { int mprotect(void*, size_t, int); } +else version(NetBSD) +{ + int mprotect(void*, size_t, int); +} else version (Solaris) { int mprotect(void*, size_t, int); @@ -552,6 +606,11 @@ else version( FreeBSD ) int shm_open(in char*, int, mode_t); int shm_unlink(in char*); } +else version(NetBSD) +{ + int shm_open(in char*, int, mode_t); + int shm_unlink(in char*); +} else version (Solaris) { int shm_open(in char*, int, mode_t); diff --git a/src/core/sys/posix/sys/resource.d b/src/core/sys/posix/sys/resource.d index f7d61d9fd0..2823aa5069 100644 --- a/src/core/sys/posix/sys/resource.d +++ b/src/core/sys/posix/sys/resource.d @@ -243,6 +243,64 @@ else version (FreeBSD) RLIMIT_AS = 10, } } +else version (NetBSD) +{ + enum + { + PRIO_PROCESS = 0, + PRIO_PGRP = 1, + PRIO_USER = 2, + } + + alias long rlim_t; + + enum + { + RLIM_INFINITY = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)), + // FreeBSD explicitly does not define the following: + //RLIM_SAVED_MAX, + //RLIM_SAVED_CUR, + } + + enum + { + RUSAGE_SELF = 0, + RUSAGE_CHILDREN = -1, + } + + struct rusage + { + timeval ru_utime; + timeval ru_stime; + c_long ru_maxrss; + alias ru_ixrss ru_first; + c_long ru_ixrss; + c_long ru_idrss; + c_long ru_isrss; + c_long ru_minflt; + c_long ru_majflt; + c_long ru_nswap; + c_long ru_inblock; + c_long ru_oublock; + c_long ru_msgsnd; + c_long ru_msgrcv; + c_long ru_nsignals; + c_long ru_nvcsw; + c_long ru_nivcsw; + alias ru_nivcsw ru_last; + } + + enum + { + RLIMIT_CORE = 4, + RLIMIT_CPU = 0, + RLIMIT_DATA = 2, + RLIMIT_FSIZE = 1, + RLIMIT_NOFILE = 8, + RLIMIT_STACK = 3, + RLIMIT_AS = 10, + } +} else version (Solaris) { enum @@ -415,6 +473,12 @@ else version (FreeBSD) int getrusage(int, rusage*); int setrlimit(int, in rlimit*); } +else version (NetBSD) +{ + int getrlimit(int, rlimit*); + int getrusage(int, rusage*); + int setrlimit(int, in rlimit*); +} else version (Solaris) { int getrlimit(int, rlimit*); diff --git a/src/core/sys/posix/sys/select.d b/src/core/sys/posix/sys/select.d index 3bdd21078f..c63ddf3a6d 100644 --- a/src/core/sys/posix/sys/select.d +++ b/src/core/sys/posix/sys/select.d @@ -221,6 +221,55 @@ else version( FreeBSD ) int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*); int select(int, fd_set*, fd_set*, fd_set*, timeval*); } +else version(NetBSD) +{ + private + { + alias c_ulong __fd_mask; + enum _NFDBITS = __fd_mask.sizeof * 8; + } + + enum uint FD_SETSIZE = 256; + + struct fd_set + { + __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; + } + + extern (D) __fd_mask __fdset_mask(uint n) + { + return cast(__fd_mask) 1 << (n % _NFDBITS); + } + + extern (D) void FD_CLR( int n, fd_set* p ) + { + p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); + } + + extern (D) bool FD_ISSET( int n, const(fd_set)* p ) + { + return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; + } + + extern (D) void FD_SET( int n, fd_set* p ) + { + p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); + } + + extern (D) void FD_ZERO( fd_set* p ) + { + fd_set *_p; + size_t _n; + + _p = p; + _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS; + while (_n > 0) + _p.__fds_bits[--_n] = 0; + } + + int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*); + int select(int, fd_set*, fd_set*, fd_set*, timeval*); +} else version (Solaris) { private diff --git a/src/core/sys/posix/sys/shm.d b/src/core/sys/posix/sys/shm.d index 7e0f1f4248..3f20acb68c 100644 --- a/src/core/sys/posix/sys/shm.d +++ b/src/core/sys/posix/sys/shm.d @@ -130,6 +130,32 @@ else version( FreeBSD ) int shmdt(in void*); int shmget(key_t, size_t, int); } +else version(NetBSD) +{ + enum SHM_RDONLY = 0x01000; // 010000 + enum SHM_RND = 0x02000; // 020000 + enum SHMLBA = 1 << 12; // PAGE_SIZE = (1< + { + enum _ALIGNBYTES = /+c_int+/ int.sizeof - 1; + extern (D) size_t _ALIGN( size_t p ) { return (p + _ALIGNBYTES) & ~_ALIGNBYTES; } + } + + extern (D) ubyte* CMSG_DATA( cmsghdr* cmsg ) + { + return cast(ubyte*) cmsg + _ALIGN( cmsghdr.sizeof ); + } + + extern (D) cmsghdr* CMSG_NXTHDR( msghdr* mhdr, cmsghdr* cmsg ) + { + if( cmsg == null ) + { + return CMSG_FIRSTHDR( mhdr ); + } + else + { + if( cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len ) + _ALIGN( cmsghdr.sizeof ) > + cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen ) + return null; + else + return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN( cmsg.cmsg_len )); + } + } + + extern (D) cmsghdr* CMSG_FIRSTHDR( msghdr* mhdr ) + { + return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null; + } + + struct linger + { + int l_onoff; + int l_linger; + } + + enum + { + SOCK_DGRAM = 2, + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + SOCK_STREAM = 1 + } + + enum : uint + { + SOL_SOCKET = 0xffff + } + + enum : uint + { + SO_DEBUG = 0x0001, /* turn on debugging info recording */ + SO_ACCEPTCONN = 0x0002, /* socket has had listen() */ + SO_REUSEADDR = 0x0004, /* allow local address reuse */ + SO_KEEPALIVE = 0x0008, /* keep connections alive */ + SO_DONTROUTE = 0x0010, /* just use interface addresses */ + SO_BROADCAST = 0x0020, /* permit sending of broadcast msgs */ + SO_USELOOPBACK = 0x0040, /* bypass hardware when possible */ + SO_LINGER = 0x0080, /* linger on close if data present */ + SO_OOBINLINE = 0x0100, /* leave received OOB data in line */ + SO_REUSEPORT = 0x0200, /* allow local address & port reuse */ + /* SO_OTIMESTAMP 0x0400 */ + SO_NOSIGPIPE = 0x0800, /* no SIGPIPE from EPIPE */ + SO_ACCEPTFILTER = 0x1000, /* there is an accept filter */ + SO_TIMESTAMP = 0x2000, /* timestamp received dgram traffic */ + + /* + * Additional options, not kept in so_options. + */ + SO_SNDBUF = 0x1001, /* send buffer size */ + SO_RCVBUF = 0x1002, /* receive buffer size */ + SO_SNDLOWAT = 0x1003, /* send low-water mark */ + SO_RCVLOWAT = 0x1004, /* receive low-water mark */ + /* SO_OSNDTIMEO 0x1005 */ + /* SO_ORCVTIMEO 0x1006 */ + SO_ERROR = 0x1007, /* get error status and clear */ + SO_TYPE = 0x1008, /* get socket type */ + SO_OVERFLOWED = 0x1009, /* datagrams: return packets dropped */ + + SO_NOHEADER = 0x100a, /* user supplies no header to kernel; + * kernel removes header and supplies + * payload + */ + SO_SNDTIMEO = 0x100b, /* send timeout */ + SO_RCVTIMEO = 0x100c /* receive timeout */ + + } + + enum + { + SOMAXCONN = 128 + } + + enum : uint + { + MSG_OOB = 0x0001, /* process out-of-band data */ + MSG_PEEK = 0x0002, /* peek at incoming message */ + MSG_DONTROUTE = 0x0004, /* send without using routing tables */ + MSG_EOR = 0x0008, /* data completes record */ + MSG_TRUNC = 0x0010, /* data discarded before delivery */ + MSG_CTRUNC = 0x0020, /* control data lost before delivery */ + MSG_WAITALL = 0x0040, /* wait for full request or error */ + MSG_DONTWAIT = 0x0080, /* this message should be nonblocking */ + MSG_BCAST = 0x0100, /* this message was rcvd using link-level brdcst */ + MSG_MCAST = 0x0200, /* this message was rcvd using link-level mcast */ + MSG_NOSIGNAL = 0x0400 /* do not generate SIGPIPE on EOF */ + } + + enum + { + AF_APPLETALK = 16, + AF_INET = 2, + AF_IPX = 23, + AF_UNIX = 1, + AF_UNSPEC = 0 + } + + enum + { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2 + } + + int accept(int, sockaddr*, socklen_t*); + int bind(int, in sockaddr*, socklen_t); + int connect(int, in sockaddr*, socklen_t); + int getpeername(int, sockaddr*, socklen_t*); + int getsockname(int, sockaddr*, socklen_t*); + int getsockopt(int, int, int, void*, socklen_t*); + int listen(int, int); + ssize_t recv(int, void*, size_t, int); + ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*); + ssize_t recvmsg(int, msghdr*, int); + ssize_t send(int, in void*, size_t, int); + ssize_t sendmsg(int, in msghdr*, int); + ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t); + int setsockopt(int, int, int, in void*, socklen_t); + int shutdown(int, int); + int socket(int, int, int); + int sockatmark(int); + int socketpair(int, int, int, ref int[2]); +} else version (Solaris) { alias uint socklen_t; @@ -1320,6 +1517,13 @@ else version( FreeBSD ) AF_INET6 = 28 } } +else version(NetBSD) +{ + enum + { + AF_INET6 = 24 + } +} else version (Solaris) { enum @@ -1367,6 +1571,13 @@ else version( FreeBSD ) SOCK_RAW = 3 } } +else version(NetBSD) +{ + enum + { + SOCK_RAW = 3 + } +} else version (Solaris) { enum diff --git a/src/core/sys/posix/sys/stat.d b/src/core/sys/posix/sys/stat.d index 2fa4f86fb3..669b7c7a5b 100644 --- a/src/core/sys/posix/sys/stat.d +++ b/src/core/sys/posix/sys/stat.d @@ -803,6 +803,68 @@ else version( FreeBSD ) int futimens(int fd, ref const(timespec)[2] times); } } +else version(NetBSD) +{ + struct stat_t + { + dev_t st_dev; /* inode's device */ + mode_t st_mode; /* inode protection mode */ + ino_t st_ino; /* inode's number */ + nlink_t st_nlink; /* number of hard links */ + uid_t st_uid; /* user ID of the file's owner */ + gid_t st_gid; /* group ID of the file's group */ + dev_t st_rdev; /* device type */ + time_t st_atime; /* time of last access */ + long st_atimensec; /* nsec of last access */ + time_t st_mtime; /* time of last data modification */ + long st_mtimensec; /* nsec of last data modification */ + time_t st_ctime; /* time of last file status change */ + long st_ctimensec; /* nsec of last file status change */ + time_t st_birthtime; /* time of creation */ + long st_birthtimensec; /* nsec of time of creation */ + off_t st_size; /* file size, in bytes */ + blkcnt_t st_blocks; /* blocks allocated for file */ + blksize_t st_blksize; /* optimal blocksize for I/O */ + uint32_t st_flags; /* user defined flags for file */ + uint32_t st_gen; /* file generation number */ + uint32_t[2] st_spare; + } + + enum S_IRUSR = 0x100; // octal 0000400 + enum S_IWUSR = 0x080; // octal 0000200 + enum S_IXUSR = 0x040; // octal 0000100 + enum S_IRWXU = 0x1C0; // octal 0000700 + + enum S_IRGRP = 0x020; // octal 0000040 + enum S_IWGRP = 0x010; // octal 0000020 + enum S_IXGRP = 0x008; // octal 0000010 + enum S_IRWXG = 0x038; // octal 0000070 + + enum S_IROTH = 0x4; // 0000004 + enum S_IWOTH = 0x2; // 0000002 + enum S_IXOTH = 0x1; // 0000001 + enum S_IRWXO = 0x7; // 0000007 + + enum S_ISUID = 0x800; // octal 0004000 + enum S_ISGID = 0x400; // octal 0002000 + enum S_ISVTX = 0x200; // octal 0001000 + + private + { + extern (D) bool S_ISTYPE( mode_t mode, uint mask ) + { + return ( mode & S_IFMT ) == mask; + } + } + + extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); } + extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); } + extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); } + extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); } + extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); } + extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); } + extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); } +} else version (Solaris) { private enum _ST_FSTYPSZ = 16; @@ -1142,6 +1204,15 @@ else version( FreeBSD ) int lstat(in char*, stat_t*); int stat(in char*, stat_t*); } +else version(NetBSD) +{ + int __fstat50(int, stat_t*); + int __lstat50(in char*, stat_t*); + int __stat50(in char*, stat_t*); + alias __fstat50 fstat; + alias __lstat50 lstat; + alias __stat50 stat; +} else version( CRuntime_Bionic ) { int fstat(int, stat_t*) @trusted; @@ -1211,6 +1282,19 @@ else version( FreeBSD ) int mknod(in char*, mode_t, dev_t); } +else version(NetBSD) +{ + enum S_IFMT = 0xF000; // octal 0170000 + enum S_IFBLK = 0x6000; // octal 0060000 + enum S_IFCHR = 0x2000; // octal 0020000 + enum S_IFIFO = 0x1000; // octal 0010000 + enum S_IFREG = 0x8000; // octal 0100000 + enum S_IFDIR = 0x4000; // octal 0040000 + enum S_IFLNK = 0xA000; // octal 0120000 + enum S_IFSOCK = 0xC000; // octal 0140000 + + int mknod(in char*, mode_t, dev_t); +} else version (Solaris) { enum S_IFMT = 0xF000; diff --git a/src/core/sys/posix/sys/time.d b/src/core/sys/posix/sys/time.d index b3bb1d98f7..a4bfd68f09 100644 --- a/src/core/sys/posix/sys/time.d +++ b/src/core/sys/posix/sys/time.d @@ -134,6 +134,25 @@ else version( FreeBSD ) int setitimer(int, in itimerval*, itimerval*); int utimes(in char*, ref const(timeval)[2]); } +else version(NetBSD) +{ + struct timeval + { + time_t tv_sec; + suseconds_t tv_usec; + } + + struct itimerval + { + timeval it_interval; + timeval it_value; + } + + int getitimer(int, itimerval*); + int gettimeofday(timeval*, void*); // timezone_t* is normally void* + int setitimer(int, in itimerval*, itimerval*); + int utimes(in char*, ref const(timeval)[2]); +} else version (Solaris) { struct timeval diff --git a/src/core/sys/posix/sys/types.d b/src/core/sys/posix/sys/types.d index cd2dc60d21..a609f2be22 100644 --- a/src/core/sys/posix/sys/types.d +++ b/src/core/sys/posix/sys/types.d @@ -143,6 +143,22 @@ else version( FreeBSD ) alias uint uid_t; alias uint fflags_t; } +else version(NetBSD) +{ + alias long blkcnt_t; + alias int blksize_t; + alias ulong dev_t; + alias uint gid_t; + alias ulong ino_t; + alias uint mode_t; + alias uint nlink_t; + alias ulong off_t; + alias int pid_t; + //size_t (defined in core.stdc.stddef) + alias c_long ssize_t; + alias c_long time_t; + alias uint uid_t; +} else version (Solaris) { alias char* caddr_t; @@ -274,6 +290,16 @@ else version( FreeBSD ) alias c_long suseconds_t; alias uint useconds_t; } +else version(NetBSD) +{ + alias ulong fsblkcnt_t; + alias ulong fsfilcnt_t; + alias c_long clock_t; + alias long id_t; + alias c_long key_t; + alias c_long suseconds_t; + alias uint useconds_t; +} else version (Solaris) { static if (__USE_FILE_OFFSET64) @@ -650,6 +676,74 @@ else version( FreeBSD ) alias void* pthread_rwlockattr_t; alias void* pthread_t; } +else version(NetBSD) +{ + struct pthread_queue_t { + void* ptqh_first; + void** ptqh_last; + } + + alias lwpid_t = int; + alias pthread_spin_t = ubyte; + struct pthread_attr_t { + uint pta_magic; + int pta_flags; + void* pta_private; + } + struct pthread_spinlock_t { + uint pts_magic; + pthread_spin_t pts_spin; + int pts_flags; + } + struct pthread_cond_t { + uint ptc_magic; + pthread_spin_t ptc_lock; + pthread_queue_t ptc_waiters; + pthread_mutex_t *ptc_mutex; + void* ptc_private; + } + struct pthread_condattr_t { + uint ptca_magic; + void *ptca_private; + } + struct pthread_mutex_t { + uint ptm_magic; + pthread_spin_t ptm_errorcheck; + ubyte[3] ptm_pad1; + pthread_spin_t ptm_interlock; + ubyte[3] ptm_pad2; + pthread_t ptm_owner; + void* ptm_waiters; + uint ptm_recursed; + void* ptm_spare2; + } + struct pthread_mutexattr_t{ + uint ptma_magic; + void* ptma_private; + } + struct pthread_once_t{ + pthread_mutex_t pto_mutex; + int pto_done; + } + struct pthread_rwlock_t{ + uint ptr_magic; + + pthread_spin_t ptr_interlock; + + pthread_queue_t ptr_rblocked; + pthread_queue_t ptr_wblocked; + uint ptr_nreaders; + pthread_t ptr_owner; + void *ptr_private; + } + struct pthread_rwlockattr_t{ + uint ptra_magic; + void* ptra_private; + } + + alias uint pthread_key_t; + alias void* pthread_t; +} else version (Solaris) { alias uint pthread_t; @@ -814,6 +908,11 @@ else version( FreeBSD ) alias void* pthread_barrier_t; alias void* pthread_barrierattr_t; } +else version(NetBSD) +{ + alias void* pthread_barrier_t; + alias void* pthread_barrierattr_t; +} else version( Darwin ) { } @@ -857,6 +956,10 @@ else version( FreeBSD ) { alias void* pthread_spinlock_t; } +else version(NetBSD) +{ + //already defined +} else version (Solaris) { alias pthread_mutex_t pthread_spinlock_t; diff --git a/src/core/sys/posix/sys/uio.d b/src/core/sys/posix/sys/uio.d index ffa0b3e298..9b5758742c 100644 --- a/src/core/sys/posix/sys/uio.d +++ b/src/core/sys/posix/sys/uio.d @@ -79,6 +79,17 @@ else version( FreeBSD ) ssize_t readv(int, in iovec*, int); ssize_t writev(int, in iovec*, int); } +else version(NetBSD) +{ + struct iovec + { + void* iov_base; + size_t iov_len; + } + + ssize_t readv(int, in iovec*, int); + ssize_t writev(int, in iovec*, int); +} else version (Solaris) { struct iovec diff --git a/src/core/sys/posix/sys/un.d b/src/core/sys/posix/sys/un.d index ad504d4c1c..1b6c7b08e9 100644 --- a/src/core/sys/posix/sys/un.d +++ b/src/core/sys/posix/sys/un.d @@ -69,6 +69,15 @@ else version( FreeBSD ) byte[104] sun_path; } } +else version(NetBSD) +{ + struct sockaddr_un + { + ubyte sun_len; + sa_family_t sun_family; + byte[104] sun_path; + } +} else version( Solaris ) { struct sockaddr_un diff --git a/src/core/sys/posix/sys/utsname.d b/src/core/sys/posix/sys/utsname.d index a87c5fb078..b41030a2e2 100644 --- a/src/core/sys/posix/sys/utsname.d +++ b/src/core/sys/posix/sys/utsname.d @@ -62,6 +62,22 @@ else version(FreeBSD) int uname(utsname* __name); } +else version(NetBSD) +{ + private enum utsNameLength = 256; + + struct utsname + { + char[utsNameLength] sysname; + char[utsNameLength] nodename; + char[utsNameLength] release; + // The field name is version but version is a keyword in D. + char[utsNameLength] update; + char[utsNameLength] machine; + } + + int uname(utsname* __name); +} else version(Solaris) { private enum SYS_NMLN = 257; diff --git a/src/core/sys/posix/sys/wait.d b/src/core/sys/posix/sys/wait.d index a69c885f00..6d39de7f8f 100644 --- a/src/core/sys/posix/sys/wait.d +++ b/src/core/sys/posix/sys/wait.d @@ -122,6 +122,28 @@ else version( FreeBSD ) extern (D) int WSTOPSIG( int status ) { return status >> 8; } extern (D) int WTERMSIG( int status ) { return _WSTATUS( status ); } } +else version(NetBSD) +{ + enum WNOHANG = 1; + enum WUNTRACED = 2; + + private + { + enum _WSTOPPED = 0x7F; // octal 0177 + } + + extern (D) int _WSTATUS(int status) { return (status & 0x7F); } + extern (D) int WEXITSTATUS( int status ) { return (status >> 8); } + extern (D) int WIFCONTINUED( int status ) { return status == 0x13; } + extern (D) bool WIFEXITED( int status ) { return _WSTATUS(status) == 0; } + extern (D) bool WIFSIGNALED( int status ) + { + return _WSTATUS( status ) != _WSTOPPED && _WSTATUS( status ) != 0; + } + extern (D) bool WIFSTOPPED( int status ) { return _WSTATUS( status ) == _WSTOPPED; } + extern (D) int WSTOPSIG( int status ) { return status >> 8; } + extern (D) int WTERMSIG( int status ) { return _WSTATUS( status ); } +} else version (Solaris) { enum WNOHANG = 64; @@ -214,6 +236,12 @@ else version (FreeBSD) // http://www.freebsd.org/projects/c99/ } +else version (NetBSD) +{ + enum WSTOPPED = WUNTRACED; + //enum WCONTINUED = 4; + enum WNOWAIT = 0x00010000; +} else version (Solaris) { enum WEXITED = 1; diff --git a/src/core/sys/posix/syslog.d b/src/core/sys/posix/syslog.d index 23e2fbce82..20939aa503 100644 --- a/src/core/sys/posix/syslog.d +++ b/src/core/sys/posix/syslog.d @@ -211,6 +211,71 @@ else version( FreeBSD ) void syslog (int __pri, const char *__fmt, ...); void closelog(); } +else version(NetBSD) +{ + //http://fxr.watson.org/fxr/source/sys/syslog.h + + //PRIORITY + enum { + LOG_EMERG = 0, /* system is unusable */ + LOG_ALERT = 1, /* action must be taken immediately */ + LOG_CRIT = 2, /* critical conditions */ + LOG_ERR = 3, /* error conditions */ + LOG_WARNING = 4, /* warning conditions */ + LOG_NOTICE = 5, /* normal but significant condition */ + LOG_INFO = 6, /* informational */ + LOG_DEBUG = 7, /* debug-level messages */ + }; + + //OPTIONS + enum { + LOG_PID = 0x01, /* log the pid with each message */ + LOG_CONS = 0x02, /* log on the console if errors in sending */ + LOG_ODELAY = 0x04, /* delay open until first syslog() (default) */ + LOG_NDELAY = 0x08, /* don't delay open */ + LOG_NOWAIT = 0x10, /* don't wait for console forks: DEPRECATED */ + LOG_PERROR = 0x20, /* log to stderr as well */ + }; + + //FACILITY + enum { + LOG_KERN = (0<<3), /* kernel messages */ + LOG_USER = (1<<3), /* random user-level messages */ + LOG_MAIL = (2<<3), /* mail system */ + LOG_DAEMON = (3<<3), /* system daemons */ + LOG_AUTH = (4<<3), /* security/authorization messages */ + LOG_SYSLOG = (5<<3), /* messages generated internally by syslogd */ + LOG_LPR = (6<<3), /* line printer subsystem */ + LOG_NEWS = (7<<3), /* network news subsystem */ + LOG_UUCP = (8<<3), /* UUCP subsystem */ + LOG_CRON = (9<<3), /* clock daemon */ + LOG_AUTHPRIV = (10<<3), /* security/authorization messages (private), */ + LOG_FTP = (11<<3), /* ftp daemon */ + LOG_NTP = (12<<3), /* NTP subsystem */ + LOG_SECURITY = (13<<3), /* security subsystems (firewalling, etc.) */ + LOG_CONSOLE = (14<<3), /* /dev/console output */ + + /* other codes through 15 reserved for system use */ + LOG_LOCAL0 = (16<<3), /* reserved for local use */ + LOG_LOCAL1 = (17<<3), /* reserved for local use */ + LOG_LOCAL2 = (18<<3), /* reserved for local use */ + LOG_LOCAL3 = (19<<3), /* reserved for local use */ + LOG_LOCAL4 = (20<<3), /* reserved for local use */ + LOG_LOCAL5 = (21<<3), /* reserved for local use */ + LOG_LOCAL6 = (22<<3), /* reserved for local use */ + LOG_LOCAL7 = (23<<3), /* reserved for local use */ + + LOG_NFACILITIES = 24, /* current number of facilities */ + }; + + int LOG_MASK(int pri) { return 1 << pri; } /* mask for one priority */ + int LOG_UPTO(int pri) { return (1 << (pri+1)) - 1; } /* all priorities through pri */ + + void openlog (const char *, int __option, int __facility); + int setlogmask (int __mask); + void syslog (int __pri, const char *__fmt, ...); + void closelog(); +} else version( Solaris ) { //http://pubs.opengroup.org/onlinepubs/007904875/basedefs/syslog.h.html diff --git a/src/core/sys/posix/termios.d b/src/core/sys/posix/termios.d index 5a56fd071c..8642f540ef 100644 --- a/src/core/sys/posix/termios.d +++ b/src/core/sys/posix/termios.d @@ -468,6 +468,114 @@ else version ( FreeBSD ) int tcsetattr(int, int, in termios*); } +else version (NetBSD) +{ + alias ubyte cc_t; + alias uint speed_t; + alias uint tcflag_t; + + enum NCCS = 20; + + struct termios + { + tcflag_t c_iflag; + tcflag_t c_oflag; + tcflag_t c_cflag; + tcflag_t c_lflag; + cc_t[NCCS] c_cc; + speed_t c_ispeed; + speed_t c_ospeed; + } + + enum VEOF = 0; + enum VEOL = 1; + enum VERASE = 3; + enum VINTR = 8; + enum VKILL = 5; + enum VMIN = 16; + enum VQUIT = 9; + enum VSTART = 12; + enum VSTOP = 13; + enum VSUSP = 10; + enum VTIME = 17; + + enum BRKINT = 0x0000002; + enum ICRNL = 0x0000100; + enum IGNBRK = 0x0000001; + enum IGNCR = 0x0000080; + enum IGNPAR = 0x0000004; + enum INLCR = 0x0000040; + enum INPCK = 0x0000010; + enum ISTRIP = 0x0000020; + enum IXOFF = 0x0000400; + enum IXON = 0x0000200; + enum PARMRK = 0x0000008; + + enum OPOST = 0x0000001; + + enum B0 = 0; + enum B50 = 50; + enum B75 = 75; + enum B110 = 110; + enum B134 = 134; + enum B150 = 150; + enum B200 = 200; + enum B300 = 300; + enum B600 = 600; + enum B1200 = 1200; + enum B1800 = 1800; + enum B2400 = 2400; + enum B4800 = 4800; + enum B9600 = 9600; + enum B19200 = 19200; + enum B38400 = 38400; + + enum CSIZE = 0x0000300; + enum CS5 = 0x0000000; + enum CS6 = 0x0000100; + enum CS7 = 0x0000200; + enum CS8 = 0x0000300; + enum CSTOPB = 0x0000400; + enum CREAD = 0x0000800; + enum PARENB = 0x0001000; + enum PARODD = 0x0002000; + enum HUPCL = 0x0004000; + enum CLOCAL = 0x0008000; + + enum ECHO = 0x00000008; + enum ECHOE = 0x00000002; + enum ECHOK = 0x00000004; + enum ECHONL = 0x00000010; + enum ICANON = 0x00000100; + enum IEXTEN = 0x00000400; + enum ISIG = 0x00000080; + enum NOFLSH = 0x80000000; + enum TOSTOP = 0x00400000; + + enum TCSANOW = 0; + enum TCSADRAIN = 1; + enum TCSAFLUSH = 2; + + enum TCIFLUSH = 1; + enum TCOFLUSH = 2; + enum TCIOFLUSH = 3; + + enum TCIOFF = 3; + enum TCION = 4; + enum TCOOFF = 1; + enum TCOON = 2; + + speed_t cfgetispeed(in termios*); + speed_t cfgetospeed(in termios*); + int cfsetispeed(termios*, speed_t); + int cfsetospeed(termios*, speed_t); + int tcdrain(int); + int tcflow(int, int); + int tcflush(int, int); + int tcgetattr(int, termios*); + int tcsendbreak(int, int); + int tcsetattr(int, int, in termios*); +} else version (Solaris) { alias tcflag_t = uint; @@ -743,6 +851,40 @@ else version( FreeBSD ) pid_t tcgetsid(int); } +else version(NetBSD) +{ + enum IXANY = 0x00000800; + + enum ONLCR = 0x00000002; + enum OCRNL = 0x00000010; + enum ONOCR = 0x00000020; + enum ONLRET = 0x00000040; + //enum OFILL + //enum NLDLY + //enum NL0 + //enum NL1 + //enum CRDLY + //enum CR0 + //enum CR1 + //enum CR2 + //enum CR3 + enum TABDLY = 0x00000004; + enum TAB0 = 0x00000000; + //enum TAB1 + //enum TAB2 + enum TAB3 = 0x00000004; + //enum BSDLY + //enum BS0 + //enum BS1 + //enum VTDLY + //enum VT0 + //enum VT1 + //enum FFDLY + //enum FF0 + //enum FF1 + + pid_t tcgetsid(int); +} else version (Solaris) { enum IXANY = 0x0000800; diff --git a/src/core/sys/posix/time.d b/src/core/sys/posix/time.d index ef0e3b0cbd..2bf9e96fdc 100644 --- a/src/core/sys/posix/time.d +++ b/src/core/sys/posix/time.d @@ -61,6 +61,10 @@ else version( FreeBSD ) { time_t timegm(tm*); // non-standard } +else version(NetBSD) +{ + time_t timegm(tm*); // non-standard +} else version (Solaris) { time_t timegm(tm*); // non-standard @@ -124,6 +128,11 @@ else version (FreeBSD) deprecated("Please import it from core.sys.freebsd.time instead.") alias CLOCK_MONOTONIC_FAST = core.sys.freebsd.time.CLOCK_MONOTONIC_FAST; } +else version (NetBSD) +{ + // time.h + enum CLOCK_MONOTONIC = 3; +} else version (Darwin) { // No CLOCK_MONOTONIC defined @@ -254,6 +263,30 @@ else version( FreeBSD ) int timer_getoverrun(timer_t); int timer_settime(timer_t, int, in itimerspec*, itimerspec*); } +else version(NetBSD) +{ + struct itimerspec + { + timespec it_interval; + timespec it_value; + } + + enum CLOCK_REALTIME = 0; + enum TIMER_ABSTIME = 0x01; + + alias int clockid_t; // + alias int timer_t; + + int clock_getres(clockid_t, timespec*); + int clock_gettime(clockid_t, timespec*); + int clock_settime(clockid_t, in timespec*); + int nanosleep(in timespec*, timespec*); + int timer_create(clockid_t, sigevent*, timer_t*); + int timer_delete(timer_t); + int timer_gettime(timer_t, itimerspec*); + int timer_getoverrun(timer_t); + int timer_settime(timer_t, int, in itimerspec*, itimerspec*); +} else version (Solaris) { enum CLOCK_PROCESS_CPUTIME_ID = 5; // @@ -347,6 +380,13 @@ else version( FreeBSD ) tm* gmtime_r(in time_t*, tm*); tm* localtime_r(in time_t*, tm*); } +else version(NetBSD) +{ + char* asctime_r(in tm*, char*); + char* ctime_r(in time_t*, char*); + tm* gmtime_r(in time_t*, tm*); + tm* localtime_r(in time_t*, tm*); +} else version (Solaris) { char* asctime_r(in tm*, char*); @@ -400,6 +440,11 @@ else version( FreeBSD ) //tm* getdate(in char*); char* strptime(in char*, in char*, tm*); } +else version(NetBSD) +{ + tm* getdate(in char*); + char* strptime(in char*, in char*, tm*); +} else version (Solaris) { extern __gshared c_long timezone, altzone; diff --git a/src/core/sys/posix/ucontext.d b/src/core/sys/posix/ucontext.d index 54e6cc095b..e0f393fe39 100644 --- a/src/core/sys/posix/ucontext.d +++ b/src/core/sys/posix/ucontext.d @@ -701,6 +701,62 @@ else version( FreeBSD ) int[4] __spare__; } } +else version(NetBSD) +{ + + version( X86_64 ) + { + enum { NGREG = 26 }; + alias __greg_t = ulong; + alias __gregset_t = __greg_t[NGREG]; + alias __fpregset_t = align(8)ubyte[512]; + + struct mcontext_t { + __gregset_t __gregs; + __greg_t _mc_tlsbase; + __fpregset_t __fpregs; + } + } + else version( X86 ) + { + enum { NGREG = 19 }; + alias __greg_t = ulong; + alias __gregset_t = __greg_t[_NGREG]; + struct __fpregset_t{ + union __fp_reg_set{ + struct __fpchip_state{ + int[27] __fp_state; /* Environment and registers */ + } ; /* x87 regs in fsave format */ + struct __fp_xmm_state{ + ubyte[512] __fp_xmm; + } ; /* x87 and xmm regs in fxsave format */ + int[128] __fp_fpregs; + }; + __fpregset_t __fp_reg_set; + int[33] __fp_pad; /* Historic padding */ + }; + + struct mcontext_t { + __gregset_t __gregs; + __fpregset_t __fpregs; + __greg_t _mc_tlsbase; + } + } + + struct ucontext_t + { + uint uc_flags; /* properties */ + ucontext_t * uc_link; /* context to resume */ + sigset_t uc_sigmask; /* signals blocked in this context */ + stack_t uc_stack; /* the stack used by this context */ + mcontext_t uc_mcontext; /* machine state */ + /+ todo #if defined(_UC_MACHINE_PAD) + long __uc_pad[_UC_MACHINE_PAD]; + #endif + +/ + + } +} else version ( Solaris ) { alias uint[4] upad128_t; diff --git a/src/core/sys/posix/unistd.d b/src/core/sys/posix/unistd.d index b99de41f49..8821e544dd 100644 --- a/src/core/sys/posix/unistd.d +++ b/src/core/sys/posix/unistd.d @@ -125,6 +125,11 @@ else version( FreeBSD ) off_t lseek(int, off_t, int) @trusted; int ftruncate(int, off_t) @trusted; } +else version(NetBSD) +{ + off_t lseek(int, off_t, int) @trusted; + int ftruncate(int, off_t) @trusted; +} else version( Solaris ) { version ( D_LP64 ) @@ -817,6 +822,143 @@ else version( FreeBSD ) _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 14, } } +else version(NetBSD) +{ + enum F_OK = 0; + enum R_OK = 0x04; + enum W_OK = 0x02; + enum X_OK = 0x01; + + enum F_ULOCK = 0; + enum F_LOCK = 1; + enum F_TLOCK = 2; + enum F_TEST = 3; + + enum + { + _SC_ARG_MAX = 1, + _SC_CHILD_MAX = 2, + _O_SC_CLK_TCK = 3, + _SC_NGROUPS_MAX = 4, + _SC_OPEN_MAX = 5, + _SC_JOB_CONTROL = 6, + _SC_SAVED_IDS = 7, + _SC_VERSION = 8, + _SC_BC_BASE_MAX = 9, + _SC_BC_DIM_MAX = 10, + _SC_BC_SCALE_MAX = 11, + _SC_BC_STRING_MAX = 12, + _SC_COLL_WEIGHTS_MAX = 13, + _SC_EXPR_NEST_MAX = 14, + _SC_LINE_MAX = 15, + _SC_RE_DUP_MAX = 16, + _SC_2_VERSION = 17, + _SC_2_C_BIND = 18, + _SC_2_C_DEV = 19, + _SC_2_CHAR_TERM = 20, + _SC_2_FORT_DEV = 21, + _SC_2_FORT_RUN = 22, + _SC_2_LOCALEDEF = 23, + _SC_2_SW_DEV = 24, + _SC_2_UPE = 25, + _SC_STREAM_MAX = 26, + _SC_TZNAME_MAX = 27, + _SC_PAGESIZE = 28, + _SC_FSYNC = 29, + _SC_XOPEN_SHM = 30, + _SC_SYNCHRONIZED_IO = 31, + _SC_IOV_MAX = 32, + _SC_MAPPED_FILES = 33, + _SC_MEMLOCK = 34, + _SC_MEMLOCK_RANGE = 35, + _SC_MEMORY_PROTECTION = 36, + _SC_LOGIN_NAME_MAX = 37, + _SC_MONOTONIC_CLOCK = 38, + _SC_CLK_TCK = 39, + _SC_ATEXIT_MAX = 40, + _SC_THREADS = 41, + _SC_SEMAPHORES = 42, + _SC_BARRIERS = 43, + _SC_TIMERS = 44, + _SC_SPIN_LOCKS = 45, + _SC_READER_WRITER_LOCKS = 46, + _SC_GETGR_R_SIZE_MAX = 47, + _SC_GETPW_R_SIZE_MAX = 48, + _SC_CLOCK_SELECTION = 49, + _SC_ASYNCHRONOUS_IO = 50, + _SC_AIO_LISTIO_MAX = 51, + _SC_AIO_MAX = 52, + _SC_MESSAGE_PASSING = 53, + _SC_MQ_OPEN_MAX = 54, + _SC_MQ_PRIO_MAX = 55, + _SC_PRIORITY_SCHEDULING = 56, + _SC_THREAD_DESTRUCTOR_ITERATIONS = 57, + _SC_THREAD_KEYS_MAX = 58, + _SC_THREAD_STACK_MIN = 59, + _SC_THREAD_THREADS_MAX = 60, + _SC_THREAD_ATTR_STACKADDR = 61, + _SC_THREAD_ATTR_STACKSIZE = 62, + _SC_THREAD_PRIORITY_SCHEDULING = 63, + _SC_THREAD_PRIO_INHERIT = 64, + _SC_THREAD_PRIO_PROTECT = 65, + _SC_THREAD_PROCESS_SHARED = 66, + _SC_THREAD_SAFE_FUNCTIONS = 67, + _SC_TTY_NAME_MAX = 68, + _SC_HOST_NAME_MAX = 69, + _SC_PASS_MAX = 70, + _SC_REGEXP = 71, + _SC_SHELL = 72, + _SC_SYMLOOP_MAX = 73, + + /* Actually, they are not supported or implemented yet */ + _SC_V6_ILP32_OFF32 = 74, + _SC_V6_ILP32_OFFBIG = 75, + _SC_V6_LP64_OFF64 = 76, + _SC_V6_LPBIG_OFFBIG = 77, + _SC_2_PBS = 80, + _SC_2_PBS_ACCOUNTING = 81, + _SC_2_PBS_CHECKPOINT = 82, + _SC_2_PBS_LOCATE = 83, + _SC_2_PBS_MESSAGE = 84, + _SC_2_PBS_TRACK = 85, + + /* These are implemented */ + _SC_SPAWN = 86, + _SC_SHARED_MEMORY_OBJECTS = 87, + + /* Extensions found in Solaris and Linux. */ + _SC_PHYS_PAGES = 121, + + /* Commonly provided sysconf() extensions */ + _SC_NPROCESSORS_CONF = 1001, + _SC_NPROCESSORS_ONLN = 1002, + /* Native variables */ + _SC_SCHED_RT_TS = 2001, + _SC_SCHED_PRI_MIN = 2002, + _SC_SCHED_PRI_MAX = 2003 + + } + + enum _SC_PAGE_SIZE = _SC_PAGESIZE; + + enum + { + _CS_PATH = 1, + _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 2, + _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 3, + _CS_POSIX_V6_ILP32_OFF32_LIBS = 4, + _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 5, + _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 6, + _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 7, + _CS_POSIX_V6_LP64_OFF64_CFLAGS = 8, + _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 9, + _CS_POSIX_V6_LP64_OFF64_LIBS = 10, + _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 11, + _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 12, + _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 13, + _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 14, + } +} else version( CRuntime_Bionic ) { enum F_OK = 0; @@ -1115,6 +1257,10 @@ else version( FreeBSD ) { int fsync(int) @trusted; } +else version(NetBSD) +{ + int fsync(int) @trusted; +} else version( CRuntime_Bionic ) { int fsync(int) @trusted; @@ -1269,6 +1415,31 @@ else version( FreeBSD ) int usleep(useconds_t) @trusted; pid_t vfork(); } +else version(NetBSD) +{ + char* crypt(in char*, in char*); + //char* ctermid(char*); + void encrypt(ref char[64], int) @trusted; + int fchdir(int) @trusted; + c_long gethostid() @trusted; + int getpgid(pid_t) @trusted; + int getsid(pid_t) @trusted; + char* getwd(char*); // LEGACY + int lchown(in char*, uid_t, gid_t); + int lockf(int, int, off_t) @trusted; + int nice(int) @trusted; + ssize_t pread(int, void*, size_t, off_t); + ssize_t pwrite(int, in void*, size_t, off_t); + int setpgrp(pid_t, pid_t) @trusted; + int setregid(gid_t, gid_t) @trusted; + int setreuid(uid_t, uid_t) @trusted; + void swab(in void*, void*, ssize_t); + void sync() @trusted; + int truncate(in char*, off_t); + useconds_t ualarm(useconds_t, useconds_t) @trusted; + int usleep(useconds_t) @trusted; + pid_t vfork(); +} else version( CRuntime_Bionic ) { int fchdir(int) @trusted; diff --git a/src/core/sys/posix/utime.d b/src/core/sys/posix/utime.d index 25166f6736..89d15f56e7 100644 --- a/src/core/sys/posix/utime.d +++ b/src/core/sys/posix/utime.d @@ -74,6 +74,16 @@ else version( FreeBSD ) int utime(in char*, in utimbuf*); } +else version(NetBSD) +{ + struct utimbuf + { + time_t actime; + time_t modtime; + } + + int utime(in char*, in utimbuf*); +} else version( Solaris ) { struct utimbuf