From 1e63c94221231f7cd85596e20cfa7877aa1fc9df Mon Sep 17 00:00:00 2001 From: Diederik de Groot Date: Tue, 19 Dec 2017 15:04:05 +0100 Subject: [PATCH] Add DragonFlyBSD support (src/core/sys/posix) --- src/core/sys/posix/arpa/inet.d | 29 +++ src/core/sys/posix/dirent.d | 39 ++++ src/core/sys/posix/dlfcn.d | 21 ++ src/core/sys/posix/fcntl.d | 89 +++++++++ src/core/sys/posix/grp.d | 21 ++ src/core/sys/posix/net/if_.d | 15 ++ src/core/sys/posix/netdb.d | 101 ++++++++++ src/core/sys/posix/netinet/in_.d | 186 ++++++++++++++++++ src/core/sys/posix/netinet/tcp.d | 4 + src/core/sys/posix/poll.d | 34 ++++ src/core/sys/posix/pthread.d | 151 ++++++++++++++ src/core/sys/posix/pwd.d | 28 +++ src/core/sys/posix/sched.d | 21 ++ src/core/sys/posix/semaphore.d | 19 ++ src/core/sys/posix/setjmp.d | 34 ++++ src/core/sys/posix/signal.d | 254 ++++++++++++++++++++++++ src/core/sys/posix/stdio.d | 6 + src/core/sys/posix/stdlib.d | 56 ++++++ src/core/sys/posix/sys/ioctl.d | 18 ++ src/core/sys/posix/sys/ipc.d | 25 +++ src/core/sys/posix/sys/mman.d | 58 ++++++ src/core/sys/posix/sys/resource.d | 69 +++++++ src/core/sys/posix/sys/select.d | 49 +++++ src/core/sys/posix/sys/socket.d | 317 ++++++++++++++++++++++++++++++ src/core/sys/posix/sys/stat.d | 81 ++++++++ src/core/sys/posix/sys/time.d | 26 +++ src/core/sys/posix/sys/types.d | 49 +++++ 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 | 63 ++++++ src/core/sys/posix/termios.d | 141 +++++++++++++ src/core/sys/posix/time.d | 52 +++++ src/core/sys/posix/ucontext.d | 65 ++++++ src/core/sys/posix/unistd.d | 189 ++++++++++++++++++ src/core/sys/posix/utime.d | 10 + 37 files changed, 2384 insertions(+) diff --git a/src/core/sys/posix/arpa/inet.d b/src/core/sys/posix/arpa/inet.d index 41fa6cc87e..04c95a7232 100644 --- a/src/core/sys/posix/arpa/inet.d +++ b/src/core/sys/posix/arpa/inet.d @@ -158,6 +158,31 @@ else version(NetBSD) const(char)* inet_ntop(int, in void*, char*, socklen_t); int inet_pton(int, in char*, void*); } +else version( DragonFlyBSD ) +{ + 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; @@ -249,6 +274,10 @@ else version(NetBSD) { enum INET6_ADDRSTRLEN = 46; } +else version( DragonFlyBSD ) +{ + 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 5dfd6764b3..9893e3906e 100644 --- a/src/core/sys/posix/dirent.d +++ b/src/core/sys/posix/dirent.d @@ -221,6 +221,36 @@ else version( OpenBSD ) dirent* readdir(DIR*); } +else version( DragonFlyBSD ) +{ + 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, + DT_DBF = 15, /* database record file */ + } + + struct dirent + { + ino_t d_fileno; /* file number of entry */ + ushort d_reclen; /* strlen(d_name) */ + ubyte d_type; /* file type, see blow */ + ubyte d_unused1; /* padding, reserved */ + uint d_unused2; /* reserved */ + char[256] d_name; /* name, NUL-terminated */ + } + + alias void* DIR; + + dirent* readdir(DIR*); +} else version (Solaris) { struct dirent @@ -357,6 +387,10 @@ else version( FreeBSD ) { int readdir_r(DIR*, dirent*, dirent**); } +else version( DragonFlyBSD ) +{ + int readdir_r(DIR*, dirent*, dirent**); +} else version(NetBSD) { int __readdir_r30(DIR*, dirent*, dirent**); @@ -415,6 +449,11 @@ else version( OpenBSD ) void seekdir(DIR*, c_long); c_long telldir(DIR*); } +else version( DragonFlyBSD ) +{ + void seekdir(DIR*, c_long); + c_long telldir(DIR*); +} else version (Darwin) { version( OSX ) diff --git a/src/core/sys/posix/dlfcn.d b/src/core/sys/posix/dlfcn.d index c1bfdfa748..25a848d21b 100644 --- a/src/core/sys/posix/dlfcn.d +++ b/src/core/sys/posix/dlfcn.d @@ -225,6 +225,27 @@ else version( OpenBSD ) void* dli_saddr; } } +else version( DragonFlyBSD ) +{ + enum RTLD_LAZY = 1; + enum RTLD_NOW = 2; + enum RTLD_GLOBAL = 0x100; + enum RTLD_LOCAL = 0; + + 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( Solaris ) { enum RTLD_LAZY = 1; diff --git a/src/core/sys/posix/fcntl.d b/src/core/sys/posix/fcntl.d index 25af2387f3..c7c4d4e7ac 100644 --- a/src/core/sys/posix/fcntl.d +++ b/src/core/sys/posix/fcntl.d @@ -517,6 +517,95 @@ else version(NetBSD) int creat(in char*, mode_t); int open(in char*, int, ...); } +else version( DragonFlyBSD ) +{ + enum O_RDONLY = 0x0000; + enum O_WRONLY = 0x0001; + enum O_RDWR = 0x0002; + enum O_ACCMODE = 0x0003; + + enum FREAD = 0x0001; + enum FWRITE = 0x0002; + enum O_NONBLOCK = 0x0000004; + enum O_APPEND = 0x0000008; + enum O_SHLOCK = 0x0000010; + enum O_EXLOCK = 0x0000020; + enum O_ASYNC = 0x0000040; + enum O_FSYNC = 0x0000080; + enum O_SYNC = 0x0000080; + enum O_NOFOLLOW = 0x0000100; + enum O_CREAT = 0x0000200; + enum O_TRUNC = 0x0000400; + enum O_EXCL = 0x0000800; + enum O_NOCTTY = 0x0008000; + enum O_DIRECT = 0x0010000; + enum O_CLOEXEC = 0x0020000; + enum O_FBLOCKING = 0x0040000; + enum O_FNONBLOCKING = 0x0080000; + enum O_FAPPEND = 0x0100000; + enum O_FOFFSET = 0x0200000; + enum O_FSYNCWRITE = 0x0400000; + enum O_FASYNCWRITE = 0x0800000; + enum O_DIRECTORY = 0x8000000; + + enum FAPPEND = O_APPEND; + enum FASYNC = O_ASYNC; + enum FFSYNC = O_FSYNC; + enum FNONBLOCK = O_NONBLOCK; + enum FNDELAY = O_NONBLOCK; + enum O_NDELAY = O_NONBLOCK; + enum FPOSIXSHM = O_NOFOLLOW; + + enum FCNTLFLAGS = (FAPPEND|FASYNC|FFSYNC|FNONBLOCK|FPOSIXSHM|O_DIRECT); + + 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_SETLK = 8; + enum F_SETLKW = 9; + enum F_OGETLK = F_GETLK; + enum F_OSETLK = F_SETLK; + enum F_OSETLKW = F_SETLKW; + enum F_DUP2FD = 10; + //enum F_GETLK = 11; + //enum F_SETLK = 12; + //enum F_SETLKW = 13; + enum F_DUPFD_CLOEXEC = 17; + enum F_DUP2FD_CLOEXEC = 18; + + enum FD_CLOEXEC = 1; + + enum F_RDLCK = 1; + enum F_UNLCK = 2; + enum F_WRLCK = 3; + + enum LOCK_SH = 0x01; + enum LOCK_EX = 0x02; + enum LOCK_NB = 0x04; + enum LOCK_UN = 0x08; + + struct flock + { + off_t l_start; + off_t l_len; + pid_t l_pid; + short l_type; + short l_whence; + } + + alias oflock = flock; + + int creat(in char*, mode_t); + int open(in char*, int, ...); + //int fcntl(int, int, ...); /*defined below*/ + //int flock(int, 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 6a5f0708c9..f27eaabb59 100644 --- a/src/core/sys/posix/grp.d +++ b/src/core/sys/posix/grp.d @@ -97,6 +97,16 @@ else version( OpenBSD ) char** gr_mem; } } +else version( DragonFlyBSD ) +{ + struct group + { + char* gr_name; + char* gr_passwd; + gid_t gr_gid; + char** gr_mem; + } +} else version( Solaris ) { struct group @@ -158,6 +168,11 @@ else version( OpenBSD ) int getgrnam_r(in char*, group*, char*, size_t, group**); int getgrgid_r(gid_t, group*, char*, size_t, group**); } +else version( DragonFlyBSD ) +{ + int getgrnam_r(in char*, group*, char*, size_t, group**); + int getgrgid_r(gid_t, group*, char*, size_t, group**); +} else version( Solaris ) { int getgrnam_r(in char*, group*, char*, int, group**); @@ -210,6 +225,12 @@ else version( OpenBSD ) @trusted void endgrent(); @trusted void setgrent(); } +else version( DragonFlyBSD ) +{ + group* getgrent(); + @trusted void endgrent(); + @trusted void setgrent(); +} else version( Solaris ) { group* getgrent(); diff --git a/src/core/sys/posix/net/if_.d b/src/core/sys/posix/net/if_.d index 512cd9b3f7..618891a60b 100644 --- a/src/core/sys/posix/net/if_.d +++ b/src/core/sys/posix/net/if_.d @@ -106,6 +106,21 @@ else version(NetBSD) if_nameindex_t* if_nameindex(); void if_freenameindex(if_nameindex_t*); } +else version( DragonFlyBSD ) +{ + 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 e190ae0e68..e1d9366d2b 100644 --- a/src/core/sys/posix/netdb.d +++ b/src/core/sys/posix/netdb.d @@ -594,6 +594,107 @@ else version( OpenBSD ) enum EAI_PROTOCOL = -13; enum EAI_OVERFLOW = -14; } +else version( DragonFlyBSD ) +{ + /* + * Error return codes from gethostbyname() and gethostbyaddr() + * (left in h_errno). + */ + 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; + } + + 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; + } + + struct addrinfo + { + int ai_flags; + int ai_family; + int ai_socktype = SOCK_STREAM; /* socktype default value required to be able to perform getAddrInfo on DragonFlyBSD + * without socktype set, you get 'servname not supported for ai_socktype' + */ + int ai_protocol; + socklen_t ai_addrlen; + char* ai_canonname; + sockaddr* ai_addr; + addrinfo* ai_next; + } + + enum IPPORT_RESERVED = 1024; + + enum NETDB_INTERNAL = -1; + enum NETDB_SUCCESS = 0; + enum HOST_NOT_FOUND = 1; + enum TRY_AGAIN = 2; + enum NO_RECOVERY = 3; + enum NO_DATA = 4; + enum NO_ADDRESS = NO_DATA; + + //enum EAI_ADDRFAMILY = 1; // deprecated + enum EAI_AGAIN = 2; + enum EAI_BADFLAGS = 3; + enum EAI_FAIL = 4; + enum EAI_FAMILY = 5; + enum EAI_MEMORY = 6; + //enum EAI_NODATA = 7; // deprecated + enum EAI_NONAME = 8; + enum EAI_SERVICE = 9; + enum EAI_SOCKTYPE = 10; + enum EAI_SYSTEM = 11; + enum EAI_BADHINTS = 12; + enum EAI_PROTOCOL = 13; + enum EAI_OVERFLOW = 14; + + enum AI_PASSIVE = 0x001; + enum AI_CANONNAME = 0x002; + enum AI_NUMERICHOST = 0x004; + enum AI_NUMERICSERV = 0x008; + enum AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG); // valid flags for addrinfo (not a standard def, apps should not use it) + enum AI_ALL = 0x100; + enum AI_V4MAPPED_CFG = 0x200; + enum AI_ADDRCONFIG = 0x400; + enum AI_V4MAPPED = 0x800; + enum AI_DEFAULT = (AI_V4MAPPED_CFG | AI_ADDRCONFIG); + + enum NI_MAXHOST = 1025; // non-standard + enum NI_MAXSERV = 32; // non-standard + + enum NI_NOFQDN = 0x01; + enum NI_NUMERICHOST = 0x02; + enum NI_NAMEREQD = 0x04; + enum NI_NUMERICSERV = 0x08; + enum NI_DGRAM = 0x10; + //enum NI_WITHSCOPEID = 0x20; // deprecated + enum NI_NUMERICSCOPE = 0x40; + +} else version (Solaris) { struct hostent diff --git a/src/core/sys/posix/netinet/in_.d b/src/core/sys/posix/netinet/in_.d index 588a23fc14..db4b07ae1f 100644 --- a/src/core/sys/posix/netinet/in_.d +++ b/src/core/sys/posix/netinet/in_.d @@ -246,6 +246,49 @@ else version(NetBSD) //enum INET_ADDRSTRLEN = 16; } +else version( DragonFlyBSD ) +{ + //alias uint16_t in_port_t; + //alias uint32_t in_addr_t; + + //struct in_addr + //{ + // in_addr_t s_addr; + //} + + 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_LOOPBACK = 0x7f000001, + INADDR_BROADCAST = 0xffffffff, + INADDR_NONE = 0xffffffff, + } + + //enum INET_ADDRSTRLEN = 16; +} else version( Solaris ) { struct sockaddr_in @@ -896,6 +939,145 @@ else version(NetBSD) __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL; } } +else version( DragonFlyBSD ) +{ + 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 @@ -1176,6 +1358,10 @@ else version(NetBSD) { enum uint IPPROTO_RAW = 255; } +else version( DragonFlyBSD ) +{ + 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 50f0ae7fba..6ce826fb15 100644 --- a/src/core/sys/posix/netinet/tcp.d +++ b/src/core/sys/posix/netinet/tcp.d @@ -51,6 +51,10 @@ else version(NetBSD) { enum TCP_NODELAY = 1; } +else version( DragonFlyBSD ) +{ + 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 6ef8f2103f..672a280761 100644 --- a/src/core/sys/posix/poll.d +++ b/src/core/sys/posix/poll.d @@ -217,6 +217,40 @@ else version( OpenBSD ) int poll(pollfd*, nfds_t, int); } +else version( DragonFlyBSD ) +{ + 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( Solaris ) { alias c_ulong nfds_t; diff --git a/src/core/sys/posix/pthread.d b/src/core/sys/posix/pthread.d index 59baa0ddef..2786f481f4 100644 --- a/src/core/sys/posix/pthread.d +++ b/src/core/sys/posix/pthread.d @@ -294,6 +294,46 @@ else version( OpenBSD ) enum PTHREAD_COND_INITIALIZER = null; enum PTHREAD_RWLOCK_INITIALIZER = null; } +else version( DragonFlyBSD ) +{ + enum + { + PTHREAD_DETACHED = 0x1, + //PTHREAD_SCOPE_SYSTEM = 0x2, // defined below + PTHREAD_INHERIT_SCHED = 0x4, + PTHREAD_NOFLOAT = 0x8, + + PTHREAD_CREATE_DETACHED = PTHREAD_DETACHED, + PTHREAD_CREATE_JOINABLE = 0, + //PTHREAD_SCOPE_PROCESS = 0, // defined below + PTHREAD_EXPLICIT_SCHED = 0, + } + + 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 = 2, + } + + enum PTHREAD_CANCELED = cast(void*) -1; + + enum PTHREAD_NEEDS_INIT = 0; + enum PTHREAD_DONE_INIT = 1; + + enum PTHREAD_MUTEX_INITIALIZER = null; + //enum PTHREAD_ONCE_INIT = { PTHREAD_NEEDS_INIT, NULL }; + enum PTHREAD_ONCE_INIT = pthread_once_t.init;; + enum PTHREAD_COND_INITIALIZER = null; + enum PTHREAD_RWLOCK_INITIALIZER = null; +} else version (Solaris) { enum @@ -448,6 +488,31 @@ 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( DragonFlyBSD ) +{ + struct _pthread_cleanup_info + { + uintptr_t[8] pthread_cleanup_pad; + } + + struct pthread_cleanup + { + _pthread_cleanup_info __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 ); + } + } + + void _pthread_cleanup_push(_pthread_cleanup_routine, void*, _pthread_cleanup_info*); + void _pthread_cleanup_pop(int); +} else version(NetBSD) { struct _pthread_cleanup_store @@ -622,6 +687,21 @@ else version( FreeBSD ) int pthread_barrierattr_init(pthread_barrierattr_t*); int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); } +else version( DragonFlyBSD ) +{ + enum PTHREAD_BARRIER_SERIAL_THREAD = -1; + enum PTHREAD_KEYS_MAX = 256; + enum PTHREAD_STACK_MIN = 16384; + enum PTHREAD_THREADS_MAX = c_ulong.max; + + 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(NetBSD) { enum PTHREAD_BARRIER_SERIAL_THREAD = 1234567; @@ -704,6 +784,14 @@ else version( FreeBSD ) int pthread_spin_trylock(pthread_spinlock_t*); int pthread_spin_unlock(pthread_spinlock_t*); } +else version( DragonFlyBSD ) +{ + 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(NetBSD) { int pthread_spin_init(pthread_spinlock_t*, int); @@ -840,6 +928,24 @@ else version( OpenBSD ) int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; int pthread_setconcurrency(int); } +else version( DragonFlyBSD ) +{ + enum + { + PTHREAD_MUTEX_ERRORCHECK = 1, + PTHREAD_MUTEX_RECURSIVE = 2, + PTHREAD_MUTEX_NORMAL = 3, + 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 (Solaris) { enum @@ -890,6 +996,10 @@ else version( FreeBSD ) { int pthread_getcpuclockid(pthread_t, clockid_t*); } +else version( DragonFlyBSD ) +{ + int pthread_getcpuclockid(pthread_t, clockid_t*); +} else version(NetBSD) { } @@ -951,6 +1061,12 @@ else version( OpenBSD ) int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*); int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*); } +else version( DragonFlyBSD ) +{ + 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 (Solaris) { int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*); @@ -1123,6 +1239,23 @@ else version( OpenBSD ) int pthread_setschedparam(pthread_t, int, sched_param*); // int pthread_setschedprio(pthread_t, int); // not implemented } +else version( DragonFlyBSD ) +{ + enum + { + PTHREAD_SCOPE_PROCESS = 0, + PTHREAD_SCOPE_SYSTEM = 0x2 + } + + 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*); +} else version (Solaris) { enum @@ -1218,6 +1351,15 @@ else version( OpenBSD ) int pthread_attr_setstackaddr(pthread_attr_t*, void*); int pthread_attr_setstacksize(pthread_attr_t*, size_t); } +else version( DragonFlyBSD ) +{ + 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 (Solaris) { int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); @@ -1283,6 +1425,15 @@ else version(NetBSD) else version( OpenBSD ) { } +else version( DragonFlyBSD ) +{ + 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( Darwin ) { int pthread_condattr_getpshared(in pthread_condattr_t*, int*); diff --git a/src/core/sys/posix/pwd.d b/src/core/sys/posix/pwd.d index 1e992e8fb0..008161129f 100644 --- a/src/core/sys/posix/pwd.d +++ b/src/core/sys/posix/pwd.d @@ -126,6 +126,23 @@ else version( OpenBSD ) time_t pw_expire; /* account expiration */ } } +else version( DragonFlyBSD ) +{ + 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 */ + int pw_fields; /* internal: fields filled in */ + } +} else version (Solaris) { struct passwd @@ -196,6 +213,11 @@ else version( OpenBSD ) int getpwnam_r(in char*, passwd*, char*, size_t, passwd**); int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**); } +else version( DragonFlyBSD ) +{ + int getpwnam_r(in char*, passwd*, char*, size_t, passwd**); + int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**); +} else version (Solaris) { int getpwnam_r(in char*, passwd*, char*, size_t, passwd**); @@ -248,6 +270,12 @@ else version ( OpenBSD ) passwd* getpwent(); void setpwent(); } +else version ( DragonFlyBSD ) +{ + void endpwent(); + passwd* getpwent(); + void setpwent(); +} else version (Solaris) { void endpwent(); diff --git a/src/core/sys/posix/sched.d b/src/core/sys/posix/sched.d index 797aab56c4..8bad1fd5ef 100644 --- a/src/core/sys/posix/sched.d +++ b/src/core/sys/posix/sched.d @@ -117,6 +117,17 @@ else version( OpenBSD ) enum SCHED_OTHER = 2; enum SCHED_RR = 3; } +else version( DragonFlyBSD ) +{ + struct sched_param + { + int sched_priority; + } + + enum SCHED_FIFO = 1; + enum SCHED_OTHER = 2; + enum SCHED_RR = 3; +} else version (Solaris) { struct sched_param @@ -183,6 +194,10 @@ else version( OpenBSD ) { int sched_yield(); } +else version( DragonFlyBSD ) +{ + int sched_yield(); +} else version (Solaris) { int sched_yield(); @@ -235,6 +250,12 @@ else version( OpenBSD ) int sched_get_priority_max(int); int sched_rr_get_interval(pid_t, timespec*); } +else version( DragonFlyBSD ) +{ + int sched_get_priority_min(int); + int sched_get_priority_max(int); + int sched_rr_get_interval(pid_t, timespec*); +} else version (Solaris) { int sched_get_priority_max(int); diff --git a/src/core/sys/posix/semaphore.d b/src/core/sys/posix/semaphore.d index c26c89ac31..94ce3246f6 100644 --- a/src/core/sys/posix/semaphore.d +++ b/src/core/sys/posix/semaphore.d @@ -103,6 +103,21 @@ else version( OpenBSD ) enum SEM_FAILED = cast(sem_t*) null; } +else version( DragonFlyBSD ) +{ + struct sem_t + { + uint _magic; + struct _usem + { + shared uint _has_waiters; + shared uint _count; + uint _flags; + } _usem _kern; + } + + enum SEM_FAILED = cast(sem_t*) null; +} else version (Solaris) { struct sem_t @@ -167,6 +182,10 @@ else version( OpenBSD ) { int sem_timedwait(sem_t*, in timespec*); } +else version( DragonFlyBSD ) +{ + int sem_timedwait(sem_t*, in timespec*); +} else version (Solaris) { int sem_timedwait(sem_t*, in timespec*); diff --git a/src/core/sys/posix/setjmp.d b/src/core/sys/posix/setjmp.d index 7e57e5e5a9..48321e3fda 100644 --- a/src/core/sys/posix/setjmp.d +++ b/src/core/sys/posix/setjmp.d @@ -233,6 +233,21 @@ else version( OpenBSD ) int setjmp(ref jmp_buf); void longjmp(ref jmp_buf, int); } +else version( DragonFlyBSD ) +{ + // + version( X86_64) + { + enum _JBLEN = 12; + struct _jmp_buf { c_long[_JBLEN] _jb; } + } + else + static assert(0); + alias _jmp_buf[1] jmp_buf; + + int setjmp(ref jmp_buf); + void longjmp(ref jmp_buf, int); +} else version( CRuntime_Bionic ) { // @@ -326,6 +341,20 @@ else version( OpenBSD ) int sigsetjmp(ref sigjmp_buf); void siglongjmp(ref sigjmp_buf, int); } +else version( DragonFlyBSD ) +{ + // + version( X86_64) + { + struct _sigjmp_buf { c_long[_JBLEN] _sjb; } + } + else + static assert(0); + alias _sigjmp_buf[1] sigjmp_buf; + + int sigsetjmp(ref sigjmp_buf); + void siglongjmp(ref sigjmp_buf, int); +} else version( CRuntime_Bionic ) { alias c_long[_JBLEN + 1] sigjmp_buf; @@ -362,6 +391,11 @@ else version( OpenBSD ) int _setjmp(ref jmp_buf); void _longjmp(ref jmp_buf, int); } +else version( DragonFlyBSD ) +{ + int _setjmp(ref jmp_buf); + void _longjmp(ref jmp_buf, int); +} else version( CRuntime_Bionic ) { int _setjmp(ref jmp_buf); diff --git a/src/core/sys/posix/signal.d b/src/core/sys/posix/signal.d index f8067af0fd..163fc7db2d 100644 --- a/src/core/sys/posix/signal.d +++ b/src/core/sys/posix/signal.d @@ -164,6 +164,10 @@ else version (FreeBSD) { enum SIGRTMIN = 65; enum SIGRTMAX = 126; } +else version (DragonFlyBSD) { + enum SIGRTMIN = 35; + enum SIGRTMAX = 126; +} else version(NetBSD) { enum SIGRTMIN = 33; @@ -523,6 +527,30 @@ else version( OpenBSD ) enum SIGUSR2 = 31; enum SIGURG = 16; } +else version( DragonFlyBSD ) +{ + //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 (Solaris) { enum SIGALRM = 14; @@ -609,6 +637,19 @@ else version(OpenBSD) int sa_flags; } } +else version( DragonFlyBSD ) +{ + struct sigaction_t + { + union + { + sigfn_t sa_handler; + sigactfn_t sa_sigaction; + } + int sa_flags; + sigset_t sa_mask; + } +} else version (Solaris) { struct sigaction_t @@ -1181,6 +1222,55 @@ else version( OpenBSD ) int sigsuspend(in sigset_t *); int sigwait(in sigset_t*, int*); } +else version( DragonFlyBSD ) +{ + enum SIG_CATCH = cast(sigfn_t2) 2; + 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; + + struct siginfo_t + { + int si_signo; + int si_errno; + int si_code; + int si_pid; + uint si_uid; + int si_status; + void* si_addr; + sigval si_value; + c_long si_band; + int[7] __spare; + } + + enum SI_UNDEFINED = 0x00000; + 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 sigaction(int, in sigaction_t*, sigaction_t*); + int sigaddset(sigset_t*, int); + int sigdelset(sigset_t*, int); + int sigemptyset(sigset_t *); + int sigfillset(sigset_t *); + int sigismember(in sigset_t *, int); + int sigpending(sigset_t *); + int sigprocmask(int, in sigset_t*, sigset_t*); + int sigsuspend(in sigset_t *); + int sigwait(in sigset_t*, int*); +} else version (Solaris) { enum SIG_HOLD = cast(sigfn_t2)2; @@ -2202,6 +2292,130 @@ else version (OpenBSD) int siginterrupt(int, int); int sigpause(int); } +else version( DragonFlyBSD ) +{ + // 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 (Solaris) { enum SIGPOLL = 22; @@ -2521,6 +2735,14 @@ else version( OpenBSD ) c_long tv_nsec; } } +else version( DragonFlyBSD ) +{ + struct timespec + { + time_t tv_sec; + c_long tv_nsec; + } +} else version (Solaris) { struct timespec @@ -2634,6 +2856,33 @@ else version(NetBSD) else version (OpenBSD) { } +else version( DragonFlyBSD ) +{ + union _sigev_un_t + { + int sigev_signo; + int sigev_notify_kqueue; + void /*pthread_attr_t*/ * sigev_notify_attributes; + }; + union _sigval_t + { + int sival_int; + void * sival_ptr; + int sigval_int; + void * sigval_ptr; + }; + struct sigevent + { + int sigev_notify; + _sigev_un_t sigev_un; + _sigval_t sigev_value; + void function(_sigval_t) sigev_notify_function; + } + + 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 (Darwin) { } @@ -2717,6 +2966,11 @@ else version( OpenBSD ) int pthread_kill(pthread_t, int); int pthread_sigmask(int, in sigset_t*, sigset_t*); } +else version( DragonFlyBSD ) +{ + int pthread_kill(pthread_t, int); + int pthread_sigmask(int, in sigset_t*, sigset_t*); +} else version (Solaris) { int pthread_kill(pthread_t, int); diff --git a/src/core/sys/posix/stdio.d b/src/core/sys/posix/stdio.d index ff94cb0483..ff00e2a8af 100644 --- a/src/core/sys/posix/stdio.d +++ b/src/core/sys/posix/stdio.d @@ -213,6 +213,8 @@ version( CRuntime_Glibc ) // as of glibc 1.0x version = HaveMemstream; else version( FreeBSD ) // as of FreeBSD 9.2 version = HaveMemstream; +else version( DragonFlyBSD ) // for DragonFlyBSD + version = HaveMemstream; else version( OpenBSD ) // as of OpenBSD 5.4 version = HaveMemstream; @@ -299,6 +301,10 @@ version( OpenBSD ) { enum P_tmpdir = "/tmp/"; } +version( DragonFlyBSD ) +{ + enum P_tmpdir = "/var/tmp/"; +} version( Solaris ) { enum P_tmpdir = "/var/tmp/"; diff --git a/src/core/sys/posix/stdlib.d b/src/core/sys/posix/stdlib.d index d2d528fa18..70794da842 100644 --- a/src/core/sys/posix/stdlib.d +++ b/src/core/sys/posix/stdlib.d @@ -108,6 +108,10 @@ else version( OpenBSD ) { int posix_memalign(void**, size_t, size_t); } +else version( DragonFlyBSD ) +{ + int posix_memalign(void**, size_t, size_t); +} else version( Solaris ) { int posix_memalign(void**, size_t, size_t); @@ -165,6 +169,13 @@ else version( OpenBSD ) void* valloc(size_t); // LEGACY non-standard } +else version( DragonFlyBSD ) +{ + int setenv(in char*, in char*, int); + int unsetenv(in char*); + + void* valloc(size_t); // LEGACY non-standard +} else version( CRuntime_Bionic ) { int setenv(in char*, in char*, int); @@ -212,6 +223,10 @@ else version( OpenBSD ) { int rand_r(uint*); } +else version( DragonFlyBSD ) +{ + int rand_r(uint*); +} else version( Solaris ) { int rand_r(uint*); @@ -477,6 +492,47 @@ else version( OpenBSD ) void srandom(uint); int unlockpt(int); } +else version( DragonFlyBSD ) +{ + //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( CRuntime_Bionic ) { double drand48(); diff --git a/src/core/sys/posix/sys/ioctl.d b/src/core/sys/posix/sys/ioctl.d index 0d24fe7acc..31e495b1c8 100644 --- a/src/core/sys/posix/sys/ioctl.d +++ b/src/core/sys/posix/sys/ioctl.d @@ -379,6 +379,24 @@ else version (NetBSD) int ioctl(int, c_ulong, ...); } +else version (DragonFlyBSD) +{ + struct fiodgname_arg + { + int len; + void* buf; + } + + 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 76eee70b4d..39e830dea2 100644 --- a/src/core/sys/posix/sys/ipc.d +++ b/src/core/sys/posix/sys/ipc.d @@ -149,6 +149,31 @@ else version(NetBSD) key_t ftok(in char*, int); } +else version( DragonFlyBSD ) +{ + 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 = 0x0200; // 01000 + enum IPC_EXCL = 0x0400; // 02000 + enum IPC_NOWAIT = 0x0800; // 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 57851770f3..fcbe485e9d 100644 --- a/src/core/sys/posix/sys/mman.d +++ b/src/core/sys/posix/sys/mman.d @@ -94,6 +94,15 @@ else version(NetBSD) enum POSIX_MADV_DONTNEED = 4; int posix_madvise(void *addr, size_t len, int advice); } +else version( DragonFlyBSD ) +{ + 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) { } @@ -143,6 +152,13 @@ else version(NetBSD) enum PROT_WRITE = 0x02; enum PROT_EXEC = 0x04; } +else version( DragonFlyBSD ) +{ + enum PROT_NONE = 0x00; + enum PROT_READ = 0x01; + enum PROT_WRITE = 0x02; + enum PROT_EXEC = 0x04; +} else version (Solaris) { enum PROT_NONE = 0x00; @@ -194,6 +210,11 @@ else version(NetBSD) void* mmap(void*, size_t, int, int, int, off_t); int munmap(void*, size_t); } +else version( DragonFlyBSD ) +{ + 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); @@ -362,6 +383,21 @@ else version(NetBSD) int __msync13(void*, size_t, int); alias msync = __msync13; } +else version( DragonFlyBSD ) +{ + 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 = 0x0000; + enum MS_ASYNC = 0x0001; + enum MS_INVALIDATE = 0x0002; + + int msync(void*, size_t, int); +} else version (Solaris) { enum MAP_SHARED = 0x0001; @@ -481,6 +517,14 @@ else version(NetBSD) int mlockall(int); int munlockall(); } +else version( DragonFlyBSD ) +{ + enum MCL_CURRENT = 0x0001; + enum MCL_FUTURE = 0x0002; + + int mlockall(int); + int munlockall(); +} else version (Solaris) { enum MCL_CURRENT = 0x0001; @@ -530,6 +574,11 @@ else version(NetBSD) int mlock(in void*, size_t); int munlock(in void*, size_t); } +else version( DragonFlyBSD ) +{ + int mlock(in void*, size_t); + int munlock(in void*, size_t); +} else version (Solaris) { int mlock(in void*, size_t); @@ -568,6 +617,10 @@ else version(NetBSD) { int mprotect(void*, size_t, int); } +else version( DragonFlyBSD ) +{ + int mprotect(void*, size_t, int); +} else version (Solaris) { int mprotect(void*, size_t, int); @@ -609,6 +662,11 @@ else version(NetBSD) int shm_open(in char*, int, mode_t); int shm_unlink(in char*); } +else version( DragonFlyBSD ) +{ + 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 0079d5680c..2a0699b872 100644 --- a/src/core/sys/posix/sys/resource.d +++ b/src/core/sys/posix/sys/resource.d @@ -301,6 +301,64 @@ else version (NetBSD) RLIMIT_AS = 10, } } +else version (DragonFlyBSD) +{ + 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)), + // DragonFlyBSD 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 @@ -441,6 +499,11 @@ else version (FreeBSD) int getpriority(int, int); int setpriority(int, int, int); } +else version (DragonFlyBSD) +{ + int getpriority(int, int); + int setpriority(int, int, int); +} else version (CRuntime_Bionic) { int getpriority(int, int); @@ -497,6 +560,12 @@ else version (NetBSD) int getrusage(int, rusage*); int setrlimit(int, in rlimit*); } +else version (DragonFlyBSD) +{ + 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 e74222ddf4..0408a5ff0f 100644 --- a/src/core/sys/posix/sys/select.d +++ b/src/core/sys/posix/sys/select.d @@ -270,6 +270,55 @@ else version(NetBSD) 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( DragonFlyBSD ) +{ + private + { + alias c_ulong __fd_mask; + enum _NFDBITS = __fd_mask.sizeof * 8; + } + + enum uint FD_SETSIZE = 1024; + + struct fd_set + { + __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits; + } + + extern (D) __fd_mask __fdset_mask(uint n) pure + { + return cast(__fd_mask) 1 << (n % _NFDBITS); + } + + extern (D) void FD_CLR( int n, fd_set* p ) pure + { + p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n); + } + + extern (D) bool FD_ISSET( int n, const(fd_set)* p ) pure + { + return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0; + } + + extern (D) void FD_SET( int n, fd_set* p ) pure + { + p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n); + } + + extern (D) void FD_ZERO( fd_set* p ) pure + { + 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/socket.d b/src/core/sys/posix/sys/socket.d index 2ad2494c3e..1dc8bd3fea 100644 --- a/src/core/sys/posix/sys/socket.d +++ b/src/core/sys/posix/sys/socket.d @@ -1167,6 +1167,309 @@ else version(NetBSD) int sockatmark(int) @safe; int socketpair(int, int, int, ref int[2]) @safe; } +else version( DragonFlyBSD ) +{ + alias uint socklen_t; + alias ubyte sa_family_t; + + enum + { + SOCK_STREAM = 1, + SOCK_DGRAM = 2, + //SOCK_RAW = 3, // defined below + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + } + + enum SOCK_CLOEXEC = 0x10000000; + enum SOCK_NONBLOCK = 0x20000000; + + enum : uint + { + SO_DEBUG = 0x0001, + SO_ACCEPTCONN = 0x0002, + SO_REUSEADDR = 0x0004, + SO_KEEPALIVE = 0x0008, + SO_DONTROUTE = 0x0010, + SO_BROADCAST = 0x0020, + SO_USELOOPBACK = 0x0040, + SO_LINGER = 0x0080, + SO_OOBINLINE = 0x0100, + SO_REUSEPORT = 0x0200, + SO_TIMESTAMP = 0x0400, + SO_NOSIGPIPE = 0x0800, // non-standard + SO_ACCEPTFILTER = 0x1000, + + SO_SNDBUF = 0x1001, + SO_RCVBUF = 0x1002, + SO_SNDLOWAT = 0x1003, + SO_RCVLOWAT = 0x1004, + SO_SNDTIMEO = 0x1005, + SO_RCVTIMEO = 0x1006, + SO_ERROR = 0x1007, + SO_TYPE = 0x1008, + SO_SNDSPACE = 0x100a, // get appr. send buffer free space + SO_CPUHINT = 0x1030, // get socket's owner cpuid hint + } + + struct linger + { + int l_onoff; + int l_linger; + } + + struct accept_filter_arg { + byte[16] af_name; + byte[256-16] af_arg; + } + + enum : uint + { + SOL_SOCKET = 0xffff + } + + enum + { + AF_UNSPEC = 0, + AF_LOCAL = 1, + AF_UNIX = AF_LOCAL, + AF_INET = 2, + AF_IMPLINK = 3, + AF_PUP = 4, + AF_CHAOS = 5, + AF_NETBIOS = 6, + AF_ISO = 7, + AF_OSI = AF_ISO, + AF_ECMA = 8, + AF_DATAKIT = 9, + AF_CCITT = 10, + AF_SNA = 11, + AF_DECnet = 12, + AF_DLI = 13, + AF_LAT = 14, + AF_HYLINK = 15, + AF_APPLETALK = 16, + AF_ROUTE = 17, + AF_LINK = 18, + pseudo_AF_XTP = 19, + AF_COIP = 20, + AF_CNT = 21, + pseudo_AF_RTIP = 22, + AF_IPX = 23, + AF_SIP = 24, + pseudo_AF_PIP = 25, + AF_ISDN = 26, + AF_E164 = AF_ISDN, + pseudo_AF_KEY = 27, + //AF_INET6 = 28, // defined below + AF_NATM = 29, + AF_ATM = 30, + pseudo_AF_HDRCMPLT = 31, + AF_NETGRAPH = 32, + AF_BLUETOOTH = 33, + AF_MPLS = 34, + AF_IEEE80211 = 35, + } + + struct sockaddr + { + ubyte sa_len; + sa_family_t sa_family; + byte[14] sa_data; + } + + enum SOCK_MAXADDRLEN = 255; + + struct sockproto { + ushort sp_family; + ushort sp_protocol; + } + + private + { + enum _SS_ALIGNSIZE = long.sizeof; + enum _SS_MAXSIZE = 128; + enum _SS_PAD1SIZE = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof; + enum _SS_PAD2SIZE = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE; + } + + struct sockaddr_storage + { + ubyte ss_len; + sa_family_t ss_family; + byte[_SS_PAD1SIZE] __ss_pad1; + long __ss_align; + byte[_SS_PAD2SIZE] __ss_pad2; + } + + /* protocol families */ + enum PF_UNSPEC = AF_UNSPEC; + enum PF_LOCAL = AF_LOCAL; + enum PF_UNIX = PF_LOCAL; + enum PF_INET = AF_INET; + enum PF_IMPLINK = AF_IMPLINK; + enum PF_PUP = AF_PUP; + enum PF_CHAOS = AF_CHAOS; + enum PF_NETBIOS = AF_NETBIOS; + enum PF_ISO = AF_ISO; + enum PF_OSI = AF_ISO; + enum PF_ECMA = AF_ECMA; + enum PF_DATAKIT = AF_DATAKIT; + enum PF_CCITT = AF_CCITT; + enum PF_SNA = AF_SNA; + enum PF_DECnet = AF_DECnet; + enum PF_DLI = AF_DLI; + enum PF_LAT = AF_LAT; + enum PF_HYLINK = AF_HYLINK; + enum PF_APPLETALK = AF_APPLETALK; + enum PF_ROUTE = AF_ROUTE; + enum PF_LINK = AF_LINK; + enum PF_XTP = pseudo_AF_XTP; + enum PF_COIP = AF_COIP; + enum PF_CNT = AF_CNT; + enum PF_SIP = AF_SIP; + enum PF_IPX = AF_IPX; + enum PF_RTIP = pseudo_AF_RTIP; + enum PF_PIP = pseudo_AF_PIP; + enum PF_ISDN = AF_ISDN; + enum PF_KEY = pseudo_AF_KEY; + enum PF_INET6 = AF_INET6; + enum PF_NATM = AF_NATM; + enum PF_ATM = AF_ATM; + enum PF_NETGRAPH = AF_NETGRAPH; + enum PF_BLUETOOTH = AF_BLUETOOTH; + + struct msghdr + { + void* msg_name; + socklen_t msg_namelen; + iovec* msg_iov; + int msg_iovlen; + void* msg_control; + socklen_t msg_controllen; + int msg_flags; + } + + enum SOMAXCONN = 128; + enum SOMAXOPT_SIZE = 65536; + enum SOMAXOPT_SIZE0 = (32 * 1024 * 1024); + + enum : uint + { + MSG_OOB = 0x00000001, + MSG_PEEK = 0x00000002, + MSG_DONTROUTE = 0x00000004, + MSG_EOR = 0x00000008, + MSG_TRUNC = 0x00000010, + MSG_CTRUNC = 0x00000020, + MSG_WAITALL = 0x00000040, + MSG_DONTWAIT = 0x00000080, + MSG_EOF = 0x00000100, + MSG_UNUSED09 = 0x00000200, + MSG_NOSIGNAL = 0x00000400, + MSG_SYNC = 0x00000800, + MSG_CMSG_CLOEXEC = 0x00001000, + /* These override FIONBIO. MSG_FNONBLOCKING is functionally equivalent to MSG_DONTWAIT.*/ + MSG_FBLOCKING = 0x00010000, + MSG_FNONBLOCKING = 0x00020000, + MSG_FMASK = 0xFFFF0000, + } + + struct cmsghdr + { + socklen_t cmsg_len; + int cmsg_level; + int cmsg_type; + } + + enum CMGROUP_MAX = 16; + + struct cmsgcred { + pid_t cmcred_pid; + uid_t cmcred_uid; + uid_t cmcred_euid; + gid_t cmcred_gid; + short cmcred_ngroups; + gid_t[CMGROUP_MAX] cmcred_groups; + }; + + enum : uint + { + SCM_RIGHTS = 0x01 + } + + private // + { + 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; + } + + enum + { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2 + } + +/* + /+ sendfile(2) header/trailer struct +/ + struct sf_hdtr { + iovec * headers; + int hdr_cnt; + iovec * trailers; + int trl_cnt; + }; +*/ + + int accept(int, sockaddr*, socklen_t*); +// int accept4(int, sockaddr*, socklen_t*, int); + int bind(int, in sockaddr*, socklen_t); + int connect(int, in sockaddr*, socklen_t); +// int extconnect(int, int, 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 sendto(int, in void*, size_t, int, in sockaddr*, socklen_t); + ssize_t sendmsg(int, in msghdr*, int); +// int sendfile(int, int, off_t, size_t, sf_hdtr *, off_t *, int); + int setsockopt(int, int, int, in void*, socklen_t); + int shutdown(int, int); + int sockatmark(int); + int socket(int, int, int); + int socketpair(int, int, int, ref int[2]); +// void pfctlinput(int, struct sockaddr *); +} else version (Solaris) { alias uint socklen_t; @@ -1559,6 +1862,13 @@ else version(NetBSD) AF_INET6 = 24 } } +else version( DragonFlyBSD ) +{ + enum + { + AF_INET6 = 28 + } +} else version (Solaris) { enum @@ -1613,6 +1923,13 @@ else version(NetBSD) SOCK_RAW = 3 } } +else version( DragonFlyBSD ) +{ + 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 2fb1a2a9a9..086a2a8dae 100644 --- a/src/core/sys/posix/sys/stat.d +++ b/src/core/sys/posix/sys/stat.d @@ -942,6 +942,68 @@ else version(NetBSD) 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( DragonFlyBSD ) +{ + struct stat_t { + ino_t st_ino; /* inode's number */ + nlink_t st_nlink; /* number of hard links */ + dev_t st_dev; /* inode's device */ + mode_t st_mode; /* inode protection mode */ + uint16_t st_padding1; + 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; + c_long __st_atimensec; + time_t st_mtime; + c_long __st_mtimensec; + time_t st_ctime; + c_long __st_ctimensec; + off_t st_size; /* file size, in bytes */ + int64_t st_blocks; /* blocks allocated for file */ + uint32_t st_blksize; /* optimal blocksize for I/O */ + uint32_t st_flags; /* user defined flags for file */ + uint32_t st_gen; /* file generation number */ + int32_t st_lspare; + int64_t st_qspare1; /* was recursive change detect */ + int64_t st_qspare2; + }; + + 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; @@ -1294,6 +1356,12 @@ else version(NetBSD) alias __lstat50 lstat; alias __stat50 stat; } +else version( DragonFlyBSD ) +{ + int fstat(int, stat_t*); + int lstat(in char*, stat_t*); + int stat(in char*, stat_t*); +} else version( CRuntime_Bionic ) { int fstat(int, stat_t*) @trusted; @@ -1376,6 +1444,19 @@ else version(NetBSD) int mknod(in char*, mode_t, dev_t); } +else version( DragonFlyBSD ) +{ + 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 42104b049a..06e2cb109a 100644 --- a/src/core/sys/posix/sys/time.d +++ b/src/core/sys/posix/sys/time.d @@ -153,6 +153,32 @@ else version(NetBSD) int setitimer(int, in itimerval*, itimerval*); int utimes(in char*, ref const(timeval)[2]); } +else version( DragonFlyBSD ) +{ + struct timeval + { + time_t tv_sec; + suseconds_t tv_usec; + } + + struct itimerval + { + timeval it_interval; + timeval it_value; + } + + // non-standard + struct timezone_t + { + int tz_minuteswest; + int tz_dsttime; + } + + int getitimer(int, itimerval*); + int gettimeofday(timeval*, timezone_t*); // 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 10a5cbc28b..c78de17bdd 100644 --- a/src/core/sys/posix/sys/types.d +++ b/src/core/sys/posix/sys/types.d @@ -159,6 +159,21 @@ else version(NetBSD) alias c_long time_t; alias uint uid_t; } +else version( DragonFlyBSD ) +{ + alias long blkcnt_t; + alias long blksize_t; + alias uint dev_t; + alias uint gid_t; + alias long ino_t; + alias ushort mode_t; + alias uint nlink_t; + alias long off_t; //__off_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef) + alias int pid_t; // size_t (defined in /usr/include/sys/stdint.h -> core.stdc.stddef) + alias c_long ssize_t; + alias long time_t; + alias uint uid_t; +} else version (Solaris) { alias char* caddr_t; @@ -300,6 +315,16 @@ else version(NetBSD) alias c_long suseconds_t; alias uint useconds_t; } +else version( DragonFlyBSD ) +{ + 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) @@ -780,6 +805,21 @@ else version(NetBSD) alias uint pthread_key_t; alias void* pthread_t; } +else version( DragonFlyBSD ) +{ + alias int lwpid_t; + + alias void* pthread_attr_t; + alias void* pthread_cond_t; + alias void* pthread_condattr_t; + alias void* pthread_key_t; + alias void* pthread_mutex_t; + alias void* pthread_mutexattr_t; + alias void* pthread_once_t; + alias void* pthread_rwlock_t; + alias void* pthread_rwlockattr_t; + alias void* pthread_t; +} else version (Solaris) { alias uint pthread_t; @@ -949,6 +989,11 @@ else version(NetBSD) alias void* pthread_barrier_t; alias void* pthread_barrierattr_t; } +else version( DragonFlyBSD ) +{ + alias void* pthread_barrier_t; + alias void* pthread_barrierattr_t; +} else version( Darwin ) { } @@ -996,6 +1041,10 @@ else version(NetBSD) { //already defined } +else version( DragonFlyBSD ) +{ + alias void* pthread_spinlock_t; +} 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 667b6b7e17..0a893ba094 100644 --- a/src/core/sys/posix/sys/uio.d +++ b/src/core/sys/posix/sys/uio.d @@ -90,6 +90,17 @@ else version(NetBSD) ssize_t readv(int, in iovec*, int); ssize_t writev(int, in iovec*, int); } +else version( DragonFlyBSD ) +{ + 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 407ccb9f1c..9b737f8832 100644 --- a/src/core/sys/posix/sys/un.d +++ b/src/core/sys/posix/sys/un.d @@ -78,6 +78,15 @@ else version(NetBSD) byte[104] sun_path; } } +else version( DragonFlyBSD ) +{ + 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 3a99aaa98a..0aa591a37e 100644 --- a/src/core/sys/posix/sys/utsname.d +++ b/src/core/sys/posix/sys/utsname.d @@ -83,6 +83,22 @@ else version(NetBSD) int uname(utsname* __name); } +else version(DragonFlyBSD) +{ + private enum utsNameLength = 32; + + 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 064f67d54e..26b3a18d93 100644 --- a/src/core/sys/posix/sys/wait.d +++ b/src/core/sys/posix/sys/wait.d @@ -144,6 +144,28 @@ else version(NetBSD) extern (D) int WSTOPSIG( int status ) { return status >> 8; } extern (D) int WTERMSIG( int status ) { return _WSTATUS( status ); } } +else version( DragonFlyBSD ) +{ + 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; @@ -242,6 +264,12 @@ else version (NetBSD) //enum WCONTINUED = 4; enum WNOWAIT = 0x00010000; } +else version (DragonFlyBSD) +{ + enum WSTOPPED = WUNTRACED; + enum WCONTINUED = 4; + enum WNOWAIT = 8; +} else version (Solaris) { enum WEXITED = 1; diff --git a/src/core/sys/posix/syslog.d b/src/core/sys/posix/syslog.d index 20939aa503..c7353a822b 100644 --- a/src/core/sys/posix/syslog.d +++ b/src/core/sys/posix/syslog.d @@ -276,6 +276,69 @@ else version(NetBSD) void syslog (int __pri, const char *__fmt, ...); void closelog(); } +else version( DragonFlyBSD ) +{ + //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 351785b8a0..91c9728a92 100644 --- a/src/core/sys/posix/termios.d +++ b/src/core/sys/posix/termios.d @@ -466,7 +466,114 @@ else version ( FreeBSD ) int tcgetattr(int, termios*); int tcsendbreak(int, int); int tcsetattr(int, int, in termios*); +} +else version ( DragonFlyBSD ) +{ + 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 (NetBSD) { @@ -851,6 +958,40 @@ else version( FreeBSD ) pid_t tcgetsid(int); } +else version( DragonFlyBSD ) +{ + 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(NetBSD) { enum IXANY = 0x00000800; diff --git a/src/core/sys/posix/time.d b/src/core/sys/posix/time.d index cb801f65a3..328eac3363 100644 --- a/src/core/sys/posix/time.d +++ b/src/core/sys/posix/time.d @@ -65,6 +65,10 @@ else version(NetBSD) { time_t timegm(tm*); // non-standard } +else version( DragonFlyBSD ) +{ + time_t timegm(tm*); // non-standard +} else version (Solaris) { time_t timegm(tm*); // non-standard @@ -133,6 +137,16 @@ else version (NetBSD) // time.h enum CLOCK_MONOTONIC = 3; } +else version (DragonFlyBSD) +{ // time.h + enum CLOCK_MONOTONIC = 4; + // To be removed in December 2015. + static import core.sys.dragonflybsd.time; + deprecated("Please import it from core.sys.dragonflybsd.time instead.") + alias CLOCK_MONOTONIC_PRECISE = core.sys.dragonflybsd.time.CLOCK_MONOTONIC_PRECISE; + deprecated("Please import it from core.sys.dragonflybsd.time instead.") + alias CLOCK_MONOTONIC_FAST = core.sys.dragonflybsd.time.CLOCK_MONOTONIC_FAST; +} else version (Darwin) { // No CLOCK_MONOTONIC defined @@ -263,6 +277,32 @@ else version( FreeBSD ) int timer_getoverrun(timer_t); int timer_settime(timer_t, int, in itimerspec*, itimerspec*); } +else version( DragonFlyBSD ) +{ + enum CLOCK_THREAD_CPUTIME_ID = 15; + + 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(NetBSD) { struct itimerspec @@ -387,6 +427,13 @@ else version(NetBSD) tm* gmtime_r(in time_t*, tm*); tm* localtime_r(in time_t*, tm*); } +else version( DragonFlyBSD ) +{ + 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*); @@ -445,6 +492,11 @@ else version(NetBSD) tm* getdate(in char*); char* strptime(in char*, in char*, tm*); } +else version( DragonFlyBSD ) +{ + //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 55a5f24b47..8b75f7354c 100644 --- a/src/core/sys/posix/ucontext.d +++ b/src/core/sys/posix/ucontext.d @@ -836,6 +836,71 @@ else version(NetBSD) } } +else version( DragonFlyBSD ) +{ + // + version( X86_64 ) + { + alias long __register_t; + alias uint __uint32_t; + alias ushort __uint16_t; + + struct mcontext_t { + __register_t mc_onstack; + __register_t mc_rdi; + __register_t mc_rsi; + __register_t mc_rdx; + __register_t mc_rcx; + __register_t mc_r8; + __register_t mc_r9; + __register_t mc_rax; + __register_t mc_rbx; + __register_t mc_rbp; + __register_t mc_r10; + __register_t mc_r11; + __register_t mc_r12; + __register_t mc_r13; + __register_t mc_r14; + __register_t mc_r15; + __register_t mc_xflags; + __register_t mc_trapno; + __register_t mc_addr; + __register_t mc_flags; + __register_t mc_err; + __register_t mc_rip; + __register_t mc_cs; + __register_t mc_rflags; + __register_t mc_rsp; + __register_t mc_ss; + + uint mc_len; + uint mc_fpformat; + uint mc_ownedfp; + uint mc_reserved; + uint[8] mc_unused; + int[256] mc_fpregs; + }; // __attribute__((aligned(64))); + } + else + { + static assert(0, "Only X86_64 support on DragonFlyBSD"); + } + + // + enum UCF_SWAPPED = 0x00000001; + + struct ucontext_t + { + sigset_t uc_sigmask; + mcontext_t uc_mcontext; + + ucontext_t* uc_link; + stack_t uc_stack; + void function(ucontext_t *, void *) uc_cofunc; + void* uc_arg; + int[4] __spare__; + } +} 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 1d915c8fba..9540d9ca3e 100644 --- a/src/core/sys/posix/unistd.d +++ b/src/core/sys/posix/unistd.d @@ -130,6 +130,11 @@ else version(NetBSD) off_t lseek(int, off_t, int) @trusted; int ftruncate(int, off_t) @trusted; } +else version( DragonFlyBSD ) +{ + off_t lseek(int, off_t, int) @trusted; + int ftruncate(int, off_t) @trusted; +} else version( Solaris ) { version ( D_LP64 ) @@ -959,6 +964,161 @@ else version(NetBSD) _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 14, } } +else version( DragonFlyBSD ) +{ + 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, + _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_ASYNCHRONOUS_IO = 28, + _SC_MAPPED_FILES = 29, + _SC_MEMLOCK = 30, + _SC_MEMLOCK_RANGE = 31, + _SC_MEMORY_PROTECTION = 32, + _SC_MESSAGE_PASSING = 33, + _SC_PRIORITIZED_IO = 34, + _SC_PRIORITY_SCHEDULING = 35, + _SC_REALTIME_SIGNALS = 36, + _SC_SEMAPHORES = 37, + _SC_FSYNC = 38, + _SC_SHARED_MEMORY_OBJECTS = 39, + _SC_SYNCHRONIZED_IO = 40, + _SC_TIMERS = 41, + _SC_AIO_LISTIO_MAX = 42, + _SC_AIO_MAX = 43, + _SC_AIO_PRIO_DELTA_MAX = 44, + _SC_DELAYTIMER_MAX = 45, + _SC_MQ_OPEN_MAX = 46, + _SC_PAGESIZE = 47, + _SC_RTSIG_MAX = 48, + _SC_SEM_NSEMS_MAX = 49, + _SC_SEM_VALUE_MAX = 50, + _SC_SIGQUEUE_MAX = 51, + _SC_TIMER_MAX = 52, + _SC_IOV_MAX = 56, + _SC_NPROCESSORS_CONF = 57, + _SC_NPROCESSORS_ONLN = 58, + _SC_2_PBS = 59, + _SC_2_PBS_ACCOUNTING = 60, + _SC_2_PBS_CHECKPOINT = 61, + _SC_2_PBS_LOCATE = 62, + _SC_2_PBS_MESSAGE = 63, + _SC_2_PBS_TRACK = 64, + _SC_ADVISORY_INFO = 65, + _SC_BARRIERS = 66, + _SC_CLOCK_SELECTION = 67, + _SC_CPUTIME = 68, + _SC_FILE_LOCKING = 69, + _SC_GETGR_R_SIZE_MAX = 70, + _SC_GETPW_R_SIZE_MAX = 71, + _SC_HOST_NAME_MAX = 72, + _SC_LOGIN_NAME_MAX = 73, + _SC_MONOTONIC_CLOCK = 74, + _SC_MQ_PRIO_MAX = 75, + _SC_READER_WRITER_LOCKS = 76, + _SC_REGEXP = 77, + _SC_SHELL = 78, + _SC_SPAWN = 79, + _SC_SPIN_LOCKS = 80, + _SC_SPORADIC_SERVER = 81, + _SC_THREAD_ATTR_STACKADDR = 82, + _SC_THREAD_ATTR_STACKSIZE = 83, + _SC_THREAD_CPUTIME = 84, + _SC_THREAD_DESTRUCTOR_ITERATIONS = 85, + _SC_THREAD_KEYS_MAX = 86, + _SC_THREAD_PRIO_INHERIT = 87, + _SC_THREAD_PRIO_PROTECT = 88, + _SC_THREAD_PRIORITY_SCHEDULING = 89, + _SC_THREAD_PROCESS_SHARED = 90, + _SC_THREAD_SAFE_FUNCTIONS = 91, + _SC_THREAD_SPORADIC_SERVER = 92, + _SC_THREAD_STACK_MIN = 93, + _SC_THREAD_THREADS_MAX = 94, + _SC_TIMEOUTS = 95, + _SC_THREADS = 96, + _SC_TRACE = 97, + _SC_TRACE_EVENT_FILTER = 98, + _SC_TRACE_INHERIT = 99, + _SC_TRACE_LOG = 100, + _SC_TTY_NAME_MAX = 101, + _SC_TYPED_MEMORY_OBJECTS = 102, + _SC_V6_ILP32_OFF32 = 103, + _SC_V6_ILP32_OFFBIG = 104, + _SC_V6_LP64_OFF64 = 105, + _SC_V6_LPBIG_OFFBIG = 106, + _SC_IPV6 = 118, + _SC_RAW_SOCKETS = 119, + _SC_SYMLOOP_MAX = 120, + _SC_ATEXIT_MAX = 107, + _SC_XOPEN_CRYPT = 108, + _SC_XOPEN_ENH_I18N = 109, + _SC_XOPEN_LEGACY = 110, + _SC_XOPEN_REALTIME = 111, + _SC_XOPEN_REALTIME_THREADS = 112, + _SC_XOPEN_SHM = 113, + _SC_XOPEN_STREAMS = 114, + _SC_XOPEN_UNIX = 115, + _SC_XOPEN_VERSION = 116, + _SC_XOPEN_XCU_VERSION = 117, + _SC_CPUSET_SIZE = 122, + _SC_PHYS_PAGES = 121, + } + + 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; @@ -1261,6 +1421,10 @@ else version(NetBSD) { int fsync(int) @trusted; } +else version( DragonFlyBSD ) +{ + int fsync(int) @trusted; +} else version( CRuntime_Bionic ) { int fsync(int) @trusted; @@ -1440,6 +1604,31 @@ else version(NetBSD) int usleep(useconds_t) @trusted; pid_t vfork(); } +else version( DragonFlyBSD ) +{ + 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 e3400ce868..15af4441ee 100644 --- a/src/core/sys/posix/utime.d +++ b/src/core/sys/posix/utime.d @@ -94,6 +94,16 @@ else version(NetBSD) int utime(in char*, in utimbuf*); } +else version( DragonFlyBSD ) +{ + struct utimbuf + { + time_t actime; + time_t modtime; + } + + int utime(in char*, in utimbuf*); +} else version( Solaris ) { struct utimbuf