h*H      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                0.7.2.0 Safe-Inferredo Safe-Inferred  posix-apiAn unsliced byte sequence with NUL as the final byte. posix-apiCopies the slice, appending a NUL byte to the end.  posix-api1Copies the slice into pinned memory, appending a NUL byte to the end.  posix-api Convert a  consisting of only characters representable by ISO-8859-1. These are encoded with ISO-8859-1. Any character with a codepoint above U+00FF$ is replaced by an unspecified byte.  posix-apiGet a pointer to the payload of the managed C string. The behavior is undefined if the argument is not pinned.      Safe-Inferred posix-apiGet the current working directory without using the system locale to convert it to text. This is implemented with a safe FFI call since it may block. Safe-Inferred %'*1  posix-apiFile Creation Flags posix-apiFile Status Flags posix-apiFile Descriptor Flags posix-apiThe O_RDONLY access mode. posix-apiThe O_WRONLY access mode. posix-apiThe O_RDWR access mode. posix-apiThe  O_NONBLOCK flag  posix-apiThe O_APPEND flag! posix-apiThe O_CREAT flag" posix-apiThe O_TRUNC flag# posix-apiThe O_EXCL flag !"# Safe-Inferred $ posix-api?Get file descriptor flags. This uses the unsafe FFI to perform fcntl(fd,F_GETFD).% posix-api;Get file status flags. This uses the unsafe FFI to perform fcntl(fd,F_GETFL).' posix-api Variant of &; that does not help the caller with the types of the flags.( posix-api Variant of ); that does not help the caller with the types of the flags.* posix-api Wrapper for write(2) that takes a slice of bytes and an offset. The byte array backing the slice does not need to be pinned.+ posix-api Variant of ** that uses errno 0 to communicate success., posix-api Wrapper for write(2) that takes a slice of bytes and an offset. The byte array backing the slice must be pinned.- posix-api Wrapper for write(2) that takes a slice of bytes and an offset. The byte array backing the slice does not need to be pinned.. posix-api Wrapper for write(2) that takes a byte array and an offset. The byte array does not need to be pinned./ posix-api Wrapper for write(2)- that takes a byte array and an offset. Uses safe$ FFI. The byte array must be pinned.0 posix-api Variant of /+ that operates on mutable byte array. Uses safe$ FFI. The byte array must be pinned.4 posix-apiClose a file descriptor. The  http://pubs.opengroup.org/onlinepubs/009696899/functions/close.htmlPOSIX specification1 includes more details. This uses the safe FFI.5 posix-apiClose a file descriptor. This uses the unsafe FFI. According to the  http://pubs.opengroup.org/onlinepubs/009696899/functions/close.htmlPOSIX specification, "If fildes refers to a socket, close() shall cause the socket to be destroyed. If the socket is in connection-mode, and the  SO_LINGER option is set for the socket with non-zero linger time, and the socket has untransmitted data, then close() shall block for up to the current linger interval until all data is transmitted."6 posix-apiClose a file descriptor with the unsafe FFI. Do not check for errors. It is only appropriate to use this when a file descriptor is being closed to handle an exceptional case. Since the user will want to propogate the original exception, the exception provided by 5 would just be discarded. This function allows us to potentially avoid an additional FFI call to .& posix-apiNULL-terminated file name posix-api Access mode posix-apiCreation flags posix-api Status flags' posix-apiNULL-terminated file name posix-apiFlags( posix-apiNULL-terminated file name posix-apiFlags posix-apiMode) posix-apiNULL-terminated file name posix-apiAccess mode, should include O_CREAT posix-apiCreation flags posix-api Status flags posix-api*Permissions assigned to newly created file* posix-apiFile descriptor posix-api Source bytes+ posix-apiFile descriptor posix-api Source bytes, posix-apiFile descriptor posix-api Source bytes- posix-apiFile descriptor posix-api Source bytes posix-apiNumber of bytes written. posix-apiSocket posix-apiSource byte array posix-apiOffset into source array posix-apiLength in bytes posix-api%Number of bytes pushed to send buffer/ posix-apiFile descriptor posix-apiSource byte array posix-apiOffset into source array posix-apiLength in bytes posix-api%Number of bytes pushed to send buffer0 posix-apiFile descriptor posix-apiSource byte array posix-apiOffset into source array posix-apiLength in bytes posix-api%Number of bytes pushed to send buffer1 posix-apiFile descriptor posix-api Destination posix-apiDestination offset posix-apiLength in bytes posix-apiNumber of bytes received2 posix-apiPath to existing file posix-apiPath to new file3 posix-api File name4 posix-apiSocket5 posix-apiSocket6 posix-apiSocket&$%.-*+1,&)'(/045632 789!"#&$%.-*+1,&)'(/045632 789!"# Safe-Inferred : posix-api4NULL-terminated name of queue, must start with slash posix-api Access mode posix-apiCreation flags posix-api Status flags; posix-api Message queue posix-apiMaximum length of message< posix-api Message queue posix-apiMessage posix-apiPriority :;< :;< Safe-Inferred, posix-apiThe  O_NONBLOCK open flag. Safe-Inferred%1= posix-apiThe  O_CLOEXEC open flag.= Safe-Inferred== Safe-Inferred%'*01 C posix-apiThe fd field of  struct pollfdD posix-apiThe events field of  struct pollfdE posix-apiThe revents field of  struct pollfdF posix-apiThe POLLIN event.G posix-apiThe POLLOUT event.H posix-apiThe POLLERR event.I posix-apiThe POLLHUP event.J posix-apiThe POLLNVAL event.K posix-api6Is the first argument a subset of the second argument?ABCDE>?@FGHIJK Safe-Inferred Safe-Inferred %'*17=8L posix-api,An address for a UNIX domain socket. The  http://pubs.opengroup.org/onlinepubs/009604499/basedefs/sys/un.h.htmlPOSIX specification mandates two fields: sa_family_t sun_family Address family. char sun_path[] Socket pathname. 7However, the first field is omitted since it is always AF_UNIX1. It is adding during serialization. Although sun_path! is a null-terminated string, SocketAddressUnix should not have a trailing null byte. The conversion function encodeSocketAddressUnix adds the null terminator. The size of path should not equal or exceed the platform-dependent size of sun_path.O posix-api4An address for an Internet socket over IPv4. The  http://pubs.opengroup.org/onlinepubs/000095399/basedefs/netinet/in.h.htmlPOSIX specification mandates three fields: sa_family_t sin_family AF_INET in_port_t sin_port Port number struct in_addr sin_addr IP addressThis type omits the first field since is a constant that is only relevant for serialization purposes. The spec also mandates that sin_port and sin_addr be in network byte order, so keep in mind that these values are not immidiately useable.S posix-apiThe  option_value data.U posix-apiThe sockaddr data. This is an extensible tagged union, so this library has chosen to represent it as byte array. It is up to platform-specific libraries to inhabit this type with values. The byte array backing this may be unpinned or pinned.W posix-apiReceive flags are given by MessageFlags Receive and send flags are given by MessageFlags Send. This is done because there are several flags that are applicable in either a receiving context or a sending context.Y posix-apiThe direction of a message. The data constructor are only used at the type level as phantom arguments.\ posix-api$Which end of the socket to shutdown.^ posix-apiOptions used in the  option_name argument in  getsockopt or  setsockopt. e posix-api!A socket type. The spec mandates  SOCK_STREAM,  SOCK_DGRAM , and SOCK_SEQPACKET:. Other types may be available on a per-platform basis.TODO: Change this to SocketTypeg posix-apiA socket communications domain, sometimes referred to as a family. The spec mandates AF_UNIX,  AF_UNSPEC, and AF_INET.i posix-apiPhantom for pointers to addrinfo6 in address resolution functions. According to POSIX: struct addrinfo { int ai_flags; int ai_family; int ai_socktype; int ai_protocol; socklen_t ai_addrlen; struct sockaddr *ai_addr; char *ai_canonname; struct addrinfo *ai_next; };j posix-apiThe AF_INET6 communications domain. POSIX declares raw sockets optional. However, they are included here for convenience. Please open an issue if this prevents this library from compiling on a POSIX-compliant operating system that anyone uses for haskell development.k posix-apiThe AF_INET communications domain.l posix-apiThe  AF_UNSPEC communications domain.m posix-apiThe AF_UNIX communications domain.n posix-apiThe  SOCK_STREAM socket type.o posix-apiThe  SOCK_DGRAM socket type.p posix-apiThe SOCK_RAW socket type. POSIX declares raw sockets optional. However, they are included here for convenience. Please open an issue if this prevents this library from compiling on a POSIX-compliant operating system that anyone uses for haskell development. Keep in mind that even though raw sockets may exist on all POSIX-compliant operating systems, they may differ in their behavior.q posix-apiThe SOCK_SEQPACKET socket type.r posix-apiThe MSG_OOB receive flag or send flag.s posix-apiThe MSG_PEEK receive flag.t posix-apiThe  MSG_WAITALL receive flag.u posix-apiThe  MSG_NOSIGNAL send flag.v posix-api'The default protocol for a socket type.w posix-apiThe  IPPROTO_RAW protocol.x posix-apiThe  IPPROTO_ICMP protocol.y posix-apiThe  IPPROTO_TCP protocol.z posix-apiThe  IPPROTO_UDP protocol.{ posix-apiThe  IPPROTO_IP protocol.| posix-apiThe  IPPROTO_IPV6 protocol.} posix-api)Disable further receive operations (e.g. SHUT_RD)~ posix-api&Disable further send operations (e.g. SHUT_WR) posix-api&Disable further send operations (e.g.  SHUT_RDWR) posix-apiSocket error status (e.g.  SOL_SOCKET) posix-apiSocket error status (e.g. SO_ERROR) posix-apiBind to device (e.g. SO_BINDTODEVICE) posix-api#Allow reuse of local address (e.g.  SO_REUSEADDR) posix-api6Transmission of broadcast messages is supported (e.g.  SO_BROADCAST) posix-apiGet  cmsg_type. posix-apiGet iov_base. posix-apiGet iov_len. posix-apiThe size of a serialized msghdr. posix-apiGet ai_flags. posix-apiSet ai_flags. posix-apiGet  ai_family. posix-apiGet  ai_socktype. posix-apiGet  ai_protocol. posix-apiGet  ai_addrlen. posix-apiGet ai_addr. posix-apiGet ai_next. posix-apiSet  ai_family. posix-apiSet  ai_socktype. posix-apiSet  ai_protocol. posix-apiThe size of a serialized addrinfo. posix-apiThe size of a serialized iovec. posix-api$The index and read functions ignore  sin_family . The write functions will set  sin_family to AF_INET.ghefbcd`a^_STUVOPRQLMNWXY[Z\]imlkjnopqvwxyz{|srtu}~ Safe-Inferred %'< posix-api1The size of a serialized internet socket address. posix-api IO (Maybe ByteArray) {-# INLINE pinByteArray #-} pinByteArray byteArray = if isByteArrayPinned byteArray then pure Nothing else do pinnedByteArray <- PM.newPinnedByteArray len PM.copyByteArray pinnedByteArray 0 byteArray 0 len r <- PM.unsafeFreezeByteArray pinnedByteArray pure (Just r) where len = PM.sizeofByteArray byteArraySend two payloads (one from unmanaged memory and one from managed memory) over a network socket. posix-apiSend two payloads (one from managed memory and one from unmanaged memory) over a network socket. posix-apiSend data from a mutable byte array over a network socket. Users may specify an offset and a length to send fewer bytes than are actually present in the array. Since this uses the safe FFI, it allocates a pinned copy of the bytearry if it was not already pinned. posix-apiSend data from an address over a network socket. This is not guaranteed to send the entire length. This uses the safe FFI since it may block indefinitely. posix-apiSend data from an address over a network socket. This uses the unsafe FFI. Users of this function should be sure to set flags that prohibit this from blocking. On Linux this is accomplished with  O_NONBLOCK". It is often desirable to call threadWaitWrite* on a nonblocking socket before calling  unsafeSend on it. posix-apiSend data from a byte array over a network socket. This uses the unsafe FFI; considerations pertaining to  sendUnsafe apply to this function as well. Users may specify a length to send fewer bytes than are actually present in the array. posix-apiSend data from a mutable byte array over a network socket. This uses the unsafe FFI; considerations pertaining to  sendUnsafe apply to this function as well. Users specify an offset and a length to send fewer bytes than are actually present in the array. posix-apiSend data from a byte array over an unconnected network socket. This uses the unsafe FFI; considerations pertaining to  sendToUnsafe apply to this function as well. The offset and length arguments cause a slice of the byte array to be sent rather than the entire byte array. posix-api Variant of  that requires that  sockaddr_in be used as the socket address. This is used to avoid allocating a buffer for the socket address when the caller knows in advance that they are sending to an IPv4 address. posix-api Variant of  that requires that  sockaddr_in be used as the socket address. This is used to avoid allocating a buffer for the socket address when the caller knows in advance that they are sending to an IPv4 address. posix-apiSend data from a mutable byte array over an unconnected network socket. This uses the unsafe FFI; concerns pertaining to  apply to this function as well. The offset and length arguments cause a slice of the mutable byte array to be sent rather than the entire byte array. posix-api Variant of  that requires that  sockaddr_in be used as the socket address. This is used to avoid allocating a buffer for the socket address when the caller knows in advance that they are sending to an IPv4 address. posix-api?Receive data into an address from a network socket. This wraps recv using the safe FFI. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown. posix-apiReceive data into a byte array from a network socket. This wraps recv using the safe FFI. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown. posix-api?Receive data into an address from a network socket. This wraps recv using the unsafe FFI. Users of this function should be sure to set flags that prohibit this from blocking. On Linux this is accomplished by setting the  MSG_DONTWAIT! flag and handling the resulting EAGAIN or  EWOULDBLOCK. When the returned size is zero, there are no additional bytes to receive and the peer has performed an orderly shutdown. posix-apiReceive data into an address from a network socket. This uses the unsafe FFI; considerations pertaining to  receiveUnsafe apply to this function as well. Users may specify a length to receive fewer bytes than are actually present in the mutable byte array. posix-apiReceive data into an address from an unconnected network socket. This uses the unsafe FFI. Users may specify an offset into the destination byte array. This function does not resize the buffer. posix-apiReceive data into an address from a network socket. This uses the unsafe FFI. This does not return the socket address of the remote host that sent the packet received. posix-apiReceive data into an address from a network socket. This uses the unsafe FFI. This does not return the socket address of the remote host that sent the packet received. posix-api,Shutdown a socket. This uses the unsafe FFI. posix-api nonblocking) stream) defaultProtocol posix-api Variant of > that allows setting flags on the newly-accepted connection. posix-api Variant of  that requests that the kernel not include the socket address in its reponse. posix-apiListening socket posix-apiMaximum socket address size posix-api8Set non-blocking and close-on-exec without extra syscall posix-api%Peer information and connected socket posix-apiListening socket posix-api8Set non-blocking and close-on-exec without extra syscall posix-apiConnected socket  Safe-Inferred1 posix-apiGet ai_flags. posix-apiGet  ai_family. posix-apiGet  ai_socktype. posix-apiGet  ai_protocol. posix-apiGet  ai_addrlen. posix-apiGet ai_addr. posix-apiGet ai_next.  Safe-Inferred1/ posix-apiGet ai_flags. posix-apiGet  ai_family. posix-apiGet  ai_socktype. posix-apiGet  ai_protocol. posix-apiGet  ai_addrlen. posix-apiGet ai_addr. posix-apiGet ai_next.  Safe-Inferred1{ posix-apiGet  sin_family. posix-apiGet  in_port_t. posix-apiGet sin_addr.saddr. This works on Linux because struct in_addr has a single 32-bit field. I do not know how to perform this in a portable way with hsc2hs. Safe-Inferred%1 Safe-Inferred o posix-apiThe timeout argument is omitted since it is nonsense to choose anything other than 0 when using the unsafe FFI.ABCDE>?@FGHIJKABCDE>?@FGHIJK Safe-Inferred%'*01  posix-apiA data type corresponding to struct epoll_event. Linux defines this as: typedef union epoll_data { void *ptr; int fd; uint32_t u32; uint64_t u64; } epoll_data_t; struct epoll_event { uint32_t events; /* Epoll events */ epoll_data_t data; /* User data variable */ };It is a little difficult to capture what this type conveys, but we make an attempt. The second argument to the Event type constructor is either Addr, Fd, Word32, or Word645. This corresponds to the four possibilities in the  epoll_data union type. As long as the user monomorphizes this type when using it, there should not be any performance penalty for the flexibility afforded by this approach. posix-api Epoll events posix-apiUser data variable, named data in struct epoll_event. posix-apiThe  EPOLL_CTL_ADD control operation. posix-apiThe  EPOLL_CTL_MOD control operation. posix-apiThe  EPOLL_CTL_DEL control operation. posix-apiThe  EPOLL_CLOEXEC flag. posix-apiThe EPOLLIN. event. Can appear in a request or a response. posix-apiThe EPOLLOUT. event. Can appear in a request or a response. posix-apiThe EPOLLPRI. event. Can appear in a request or a response. posix-apiThe EPOLLERR event. The  5http://man7.org/linux/man-pages/man2/epoll_ctl.2.htmlepoll_ctl documentation says " epoll_wait will always wait for this event; it is not necessary to set it in events". Consequently, in this library, it has been marked as only appearing in Response positions. posix-apiThe EPOLLHUP event. The  5http://man7.org/linux/man-pages/man2/epoll_ctl.2.htmlepoll_ctl documentation says " epoll_wait will always wait for this event; it is not necessary to set it in events". Consequently, in this library, it has been marked as only appearing in Response positions. posix-apiThe  EPOLLRDHUP. event. Can appear in a request or a response. posix-apiThe EPOLLET! event. Only appears in requests. posix-apiDoes the first event set entirely contain the second one? That is, is the second argument a subset of the first? posix-apiDoes the first event set contain any of the events from the second one? posix-apiRead events from struct epoll_event. posix-apiRead data.fd from struct epoll_event. posix-apiRead data.ptr from struct epoll_event. posix-apiRead data.u32 from struct epoll_event. posix-apiRead data.u64 from struct epoll_event. posix-apiWrite data.u64 from struct epoll_event. posix-apiSince  epoll_event< includes an unaligned 64-bit word, it is difficult to use hsc2hs to generate the marshalling code. Consequently, the offsets of events and data are currently hardcoded. Open an issue in this causes a problem on your platform.(>?@  Safe-Inferred *1& posix-api9Wait for an I/O event on an epoll file descriptor. The  &https://linux.die.net/man/2/epoll_waitLinux man page includes more details. The timeout argument is omitted since it is nonsense to choose anything other than 0 when using the unsafe FFI. posix-api9Wait for an I/O event on an epoll file descriptor. The  &https://linux.die.net/man/2/epoll_waitLinux man page includes more details. The event buffer must be a pinned byte array. posix-apiAdd, modify, or remove entries in the interest list of the epoll instance referred to by the file descriptor epfd.  %https://linux.die.net/man/2/epoll_ctlLinux man page includes more details. posix-apiSize, ignored since Linux 2.6.8 posix-apiFlags posix-apiEPoll file descriptor posix-api Event buffer posix-apiMaximum events posix-apiNumber of events received posix-apiEPoll file descriptor posix-apiEvent buffer, must be pinned posix-apiMaximum events posix-apiTimeout in milliseconds, use -1 to block forever. posix-apiNumber of events received posix-apiEPoll file descriptor (epfd) posix-api Operation:  EPOLL_CTL_ADD,  EPOLL_CTL_MOD, or  EPOLL_CTL_DEL posix-api3File descriptor whose registration will be affected posix-api2A single event. This is read from, not written to.'>?@'>?@ !"#$%&'()*+,-..//001123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWWXYZ[\]^_`aabccdeffgghhijkllmmnnoopqqrrstuvwxyz{|}~48S5                    S[\]^     5(posix-api-0.7.2.0-8puDORraqsw8682COytEvH Posix.TypesForeign.C.String.ManagedPosix.Directory Posix.FilePosix.MessageQueueLinux.MessageQueue Posix.Poll Posix.Socket Linux.SocketPosix.Struct.AddressInfo.PeekPosix.Struct.AddressInfo.Poke'Posix.Struct.SocketAddressInternet.Peek Linux.Epoll posix-api AssertionPosix.File.TypesPosix.MessageQueue.TypesLinux.MessageQueue.TypesPosix.Poll.Types Posix.SelectPosix.Socket.TypesPosix.Socket.PlatformLinux.Socket.TypesuninterruptibleAcceptLinux.Epoll.TypesbaseSystem.Posix.TypesCNfdsManagedCString terminatedU terminated unterminated fromShortText fromBytespinnedFromBytespintouchfromLatinStringcontents$fShowManagedCString$fIsStringManagedCString$fMonoidManagedCString$fSemigroupManagedCString$fEqManagedCStringgetCurrentWorkingDirectory AccessMode CreationFlags StatusFlagsDescriptorFlagsreadOnly writeOnly readWrite nonblockingappendcreatetruncate exclusive!uninterruptibleGetDescriptorFlagsuninterruptibleGetStatusFlagsuninterruptibleOpenuninterruptibleOpenUntypedFlags#uninterruptibleOpenModeUntypedFlagsuninterruptibleOpenMode#uninterruptibleWriteBytesCompletely(uninterruptibleWriteBytesCompletelyErrnowriteBytesCompletelyErrnouninterruptibleWriteBytesuninterruptibleWriteByteArraywriteByteArraywriteMutableByteArray#uninterruptibleReadMutableByteArrayuninterruptibleLinkuninterruptibleUnlinkcloseuninterruptibleCloseuninterruptibleErrorlessClose isReadOnly isWriteOnly isReadWriteopenuninterruptibleReceiveByteArrayuninterruptibleSendBytes closeOnExecExchangeRequestResponsePollFd$sel:descriptor:PollFd$sel:request:PollFd$sel:response:PollFdinputoutputerrorhangupinvalid isSubeventOfSocketAddressUnix$sel:path:SocketAddressUnixSocketAddressInternet$sel:port:SocketAddressInternet"$sel:address:SocketAddressInternet OptionValue SocketAddress MessageFlagsMessageSendReceive ShutdownType OptionNameLevelProtocol$sel:getProtocol:ProtocolTypeFamily AddressInfo Internet6Internet UnspecifiedUnixstreamdatagramrawsequencedPacket outOfBandpeekwaitAllnoSignaldefaultProtocol rawProtocolicmptcpudpipipv6readwrite levelSocket optionError bindToDevice reuseAddress broadcastpeekControlMessageHeaderLengthpeekControlMessageHeaderLevelpeekControlMessageHeaderTypepeekIOVectorBasepeekIOVectorLengthsizeofMessageHeaderpeekAddressInfoFlagspokeAddressInfoFlagssizeofAddressInfosizeofIOVectorpeekMessageHeaderNamepokeMessageHeaderNamepokeMessageHeaderNameLengthpokeMessageHeaderIOVectorpokeMessageHeaderIOVectorLengthpokeMessageHeaderControlpokeMessageHeaderControlLengthpokeMessageHeaderFlagspeekMessageHeaderNameLengthpeekMessageHeaderIOVectorpeekMessageHeaderIOVectorLengthpeekMessageHeaderControlpokeIOVectorBasepokeIOVectorLengthpeekMessageHeaderControlLengthpeekMessageHeaderFlagssizeofSocketAddressInternetencodeSocketAddressInternetdecodeSocketAddressInternetindexSocketAddressInternetencodeSocketAddressUnixuninterruptibleFreeAddressInfouninterruptibleSocketsocket withSocketuninterruptibleSocketPairgetAddressInfouninterruptibleBinduninterruptibleListenconnectuninterruptibleConnectuninterruptibleConnectPtracceptaccept_uninterruptibleGetSocketNameuninterruptibleGetSocketOption!uninterruptibleSetSocketOptionIntuninterruptibleSetSocketOption'uninterruptibleSetSocketOptionByteArray sendByteArrayuninterruptibleSendMessageAuninterruptibleSendMessageBsendMutableByteArraysenduninterruptibleSenduninterruptibleSendByteArray#uninterruptibleSendMutableByteArrayuninterruptibleSendToByteArray&uninterruptibleSendToInternetByteArrayuninterruptibleSendToInternet%uninterruptibleSendToMutableByteArray-uninterruptibleSendToInternetMutableByteArrayreceivereceiveByteArrayuninterruptibleReceive&uninterruptibleReceiveMutableByteArray*uninterruptibleReceiveFromMutableByteArray"uninterruptibleReceiveFromInternet2uninterruptibleReceiveFromInternetMutableByteArray+uninterruptibleReceiveFromMutableByteArray_uninterruptibleReceiveFrom_uninterruptibleShutdownhostToNetworkShortnetworkToHostShorthostToNetworkLongnetworkToHostLong SocketFlagsdontWaitcontrolTruncate headerIncludesizeofUdpHeaderpokeUdpHeaderSourcePortpokeUdpHeaderDestinationPortpokeUdpHeaderLengthpokeUdpHeaderChecksumsizeofIpHeaderpokeIpHeaderVersionIhlpokeIpHeaderTypeOfServicepokeIpHeaderTotalLengthpokeIpHeaderIdentifierpokeIpHeaderFragmentOffsetpokeIpHeaderTimeToLivepokeIpHeaderProtocolpokeIpHeaderChecksumpokeIpHeaderSourceAddresspokeIpHeaderDestinationAddressapplySocketFlagsuninterruptibleAccept4uninterruptibleAccept4_flagsfamily socketTypeprotocol addressLengthaddressnextportuninterruptiblePoll#uninterruptiblePollMutablePrimArray PrimEpollDataEvent$sel:events:Event$sel:payload:EventEvents EpollFlagsControlOperationaddmodifydeletepriority readHangup edgeTriggeredcontainsAllEventscontainsAnyEvents sizeofEventpeekEventEventspeekEventDataFdpeekEventDataPtrpeekEventDataU32peekEventDataU64pokeEventDataU64uninterruptibleCreateuninterruptibleCreate1#uninterruptibleWaitMutablePrimArraywaitMutablePrimArray&uninterruptibleControlMutablePrimArrayassertByteArrayPinnedassertMutableByteArrayPinnedassertMutablePrimArrayPinnedGHC.BaseStringForeign.C.ErrorgetErrnoOpenMode OpenFlagspeekAddressInfoFamilypeekAddressInfoSocketTypepeekAddressInfoProtocolpeekAddressInfoAddressLengthpeekAddressInfoAddresspeekAddressInfoNextpokeAddressInfoFamilypokeAddressInfoSocketTypepokeAddressInfoProtocol$fPrimSocketAddressInternetSocketAddressInternet6 $sel:port:SocketAddressInternet6$$sel:flowInfo:SocketAddressInternet6$$sel:addressA:SocketAddressInternet6$$sel:addressB:SocketAddressInternet6#$sel:scopeId:SocketAddressInternet6AddressInfoFlags"internalWriteSocketAddressInternetFdForeign.C.TypesCIntsizeofMultipleMessageHeaderpokeMultipleMessageHeaderName#pokeMultipleMessageHeaderNameLength!pokeMultipleMessageHeaderIOVector'pokeMultipleMessageHeaderIOVectorLength pokeMultipleMessageHeaderControl&pokeMultipleMessageHeaderControlLengthpokeMultipleMessageHeaderFlagspokeMultipleMessageHeaderLengthpeekMultipleMessageHeaderLength#peekMultipleMessageHeaderNameLength$fPrimEpollDataWord64indexByteArrayEpollreadByteArrayEpollwriteByteArrayEpollindexOffAddrEpollreadOffAddrEpollwriteOffAddrEpoll