network-3.1.4.0/0000755000000000000000000000000007346545000011537 5ustar0000000000000000network-3.1.4.0/CHANGELOG.md0000644000000000000000000003246507346545000013362 0ustar0000000000000000## Version 3.1.4.0 * Install and use afunix_compat.h header. [#556](https://github.com/haskell/network/pull/556) * Supporting SO_SNDTIMEO and SO_RCVTIMEO. [#555](https://github.com/haskell/network/pull/555) * Emulating socketPair on Windows. [#554](https://github.com/haskell/network/pull/554) ## Version 3.1.3.0 * Supporting AF_UNIX on Windows [#553](https://github.com/haskell/network/issues/553) ## Version 3.1.2.9 * Resolving the runtime linker problem on Windows. [#552](https://github.com/haskell/network/issues/552) ## Version 3.1.2.8 * Ignoring error from shutdown in gracefulClose * Fix bitsize of some msghdr and cmsghdr fields on Linux [#535](https://github.com/haskell/network/issues/535) * Add SO_ACCEPTCONN SocketOption [#524](https://github.com/haskell/network/issues/524) ## Version 3.1.2.7 * No change from 3.1.2.6 but to take a right procedure to upload "network" to Hackage for Windows. ## Version 3.1.2.6 * Making IPv4PktInfo on Win the same as that on Posix [#522](https://github.com/haskell/network/issues/522) * Add support for nix/ghcjs [#517](https://github.com/haskell/network/issues/517) ## Version 3.1.2.5 * Regenerate `configure` script with autoconf-2.69 to temporarily fix broken cabal-3.4.0.0 on Windows. Note that the old one was generated with autoconf-2.71. [#513](https://github.com/haskell/network/issues/513) ## Version 3.1.2.3 * Supporting M1 Mac [#510](https://github.com/haskell/network/pull/510) * Workaround for autoconf on Windows [#508](https://github.com/haskell/network/pull/508) * Fixing building failure on SmartOS [#507](https://github.com/haskell/network/pull/507) * HsNet.h: remove unused fn hsnet_inet_ntoa definition [#504](https://github.com/haskell/network/pull/504) * Use a working define for OpenBSD detection [#503](https://github.com/haskell/network/pull/503) ## Version 3.1.2.2 * Allow bytestring 0.11 [#490](https://github.com/haskell/network/pull/490) * Export StructLinger [#491](https://github.com/haskell/network/pull/491) * Fix a couple of broken tests on OpenBSD [#498](https://github.com/haskell/network/pull/498) ## Version 3.1.2.1 * Increasing base lower bound to 4.9. [#473](https://github.com/haskell/network/pull/473) * Suppressing errors from removeFile in UNIX bind. [#478](https://github.com/haskell/network/pull/478) * Restoring UNIX stub functions on Windows. [#489](https://github.com/haskell/network/pull/489) ## Version 3.1.2.0 * Added `-f devel` for test cases that are known to fail. [#471](https://github.com/haskell/network/pull/471) * Improved precedence-compliant Read/Show instances. Verified via QuickCheck. [#465](https://github.com/haskell/network/pull/465) [#466](https://github.com/haskell/network/pull/466) * Removed the racing graceful close implementation to avoid issues with `CLOSE_WAIT`. [#460](https://github.com/haskell/network/pull/438) * Gracefully handle binding of UNIX domain sockets. [#460](https://github.com/haskell/network/pull/460) * Replace Socket type and family with extensible `CInt` pattern and synonyms. [#459](https://github.com/haskell/network/pull/459) * Fixed race conditions in tests. [#458](https://github.com/haskell/network/pull/458) * Removed many legacy uses of `undefined`. [#456](https://github.com/haskell/network/pull/456) * Defined extensible `CustomSockOpt` via `ViewPatterns`. [#455](https://github.com/haskell/network/pull/455) * Defined `openSocket` in terms of `AddrInfo`. [5b0987197fe2ed7beddd7b2096522d624e71151e](https://github.com/haskell/network/commit/5b0987197fe2ed7beddd7b2096522d624e71151e) * Improved FreeBSD portability for Control Messages and tests [#452](https://github.com/haskell/network/pull/452) * Support `sendMsg` and `recvMsg` [#433](https://github.com/haskell/network/pull/433) [#445](https://github.com/haskell/network/pull/445) [#451](https://github.com/haskell/network/pull/451) * Added `sendMsg` and `recvMsg` APIs * Redefined `SocketOption` as pattern synonym * Implement total Show functions for SockAddr [#441](https://github.com/haskell/network/pull/441) * Improve portability changing `u_int32_t` to `uint32_t`. [#442](https://github.com/haskell/network/pull/442) * Removed obsolete CPP statements. [d1f4ee60ce6a4a85abb79532f64d4a4e71e2b1ce](https://github.com/haskell/network/commit/d1f4ee60ce6a4a85abb79532f64d4a4e71e2b1ce) * Loads of improved test coverage. [cbd67cc50a37770432eb978ac8b8eb6da3664817](https://github.com/haskell/network/commit/cbd67cc50a37770432eb978ac8b8eb6da3664817) [fcc2d86d53a6bec793f6a979a9e8fdf7fe3f4c22](https://github.com/haskell/network/commit/fcc2d86d53a6bec793f6a979a9e8fdf7fe3f4c22) [6db96969b3e8974abbfd50a7f073baa57376fd5e](https://github.com/haskell/network/commit/6db96969b3e8974abbfd50a7f073baa57376fd5e) ## Version 3.1.1.1 * Fix for GHCJS. [#431](https://github.com/haskell/network/pull/431) ## Version 3.1.1.0 * A new API: `gracefulClose`. [#417](https://github.com/haskell/network/pull/417) * `touchSocket`, `unsafeFdSocket`: Allow direct access to a socket's file descriptor while providing tools to prevent it from being garbage collected. This also deprecated `fdSocket` in favor of `unsafeFdSocket` and `withFdSocket`. [#423](https://github.com/haskell/network/pull/423) * `socketToFd`: Duplicates a socket as a file desriptor and closes the source socket. [#424](https://github.com/haskell/network/pull/424) ## Version 3.1.0.1 * getAddrInfo: raise exception if no AddrInfo returned. [#410](https://github.com/haskell/network/pull/410) * Avoid catching SomeException. [#411](https://github.com/haskell/network/pull/411) ## Version 3.1.0.0 * Making GC of socket safer. [#399](https://github.com/haskell/network/pull/399) * Deprecating fdSocket. Use withFdSocket instead to ensure that sockets are GCed in proper time. [#399](https://github.com/haskell/network/pull/399) ## Version 3.0.1.1 * Fix blocking `if_nametoindex` errors on Windows [#391](https://github.com/haskell/network/pull/391) ## Version 3.0.1.0 * Added `getSocketType :: Socket -> IO SocketType`. [#372](https://github.com/haskell/network/pull/372) * Correcting manual and brushing up test cases [#375](https://github.com/haskell/network/pull/375) * Fixed longstanded bug in `getContents` on mac [#375](https://github.com/haskell/network/pull/375) * Fixing regression: set correct sockaddr length for abstract addresses for Linux. [#374](https://github.com/haskell/network/pull/374) ## Version 3.0.0.1 * Fixed a bug in `connect` where exceptions were not thrown [#368](https://github.com/haskell/network/pull/368) ## Version 3.0.0.0 * Breaking change: the Network and Network.BSD are removed. Network.BSD is provided a new package: network-bsd. * Breaking change: the signatures are changed: ``` old fdSocket :: Socket -> CInt new fdSocket :: Socket -> IO CInt old mkSocket :: CInt -> Family -> SocketType -> ProtocolNumber -> SocketStatus -> IO Socket new mkSocket :: CInt -> IO Socket ``` * Breaking change: the deprecated APIs are removed: send, sendTo, recv, recvFrom, recvLen, htonl, ntohl, inet_addr, int_ntoa, bindSocket, sClose, SocketStatus, isConnected, isBound, isListening, isReadable, isWritable, sIsConnected, sIsBound, sIsListening, sIsReadable, sIsWritable, aNY_PORT, iNADDR_ANY, iN6ADDR_ANY, sOMAXCONN, sOL_SOCKET, sCM_RIGHTS, packSocketType, getPeerCred. * Breaking change: SockAddrCan is removed from SockAddr. * Socket addresses are extendable with Network.Socket.Address. * "socket" is now asynchronous-exception-safe. [#336](https://github.com/haskell/network/pull/336) * "recvFrom" returns (0, addr) instead of throwing an error on EOF. [#360](https://github.com/haskell/network/pull/360) * All APIs are available on any platforms. * Build system is simplified. * Bug fixes. ## Version 2.8.0.1 * Eensuring that accept returns a correct sockaddr for unix domain. [#400](https://github.com/haskell/network/pull/400) * Avoid out of bounds writes in pokeSockAddr. [#400](https://github.com/haskell/network/pull/400) ## Version 2.8.0.0 * Breaking change: PortNumber originally contained Word16 in network byte order and used "deriving Ord". This results in strange behavior on the Ord instance. Now PortNumber holds Word16 in host byte order. [#347](https://github.com/haskell/network/pull/347) * Breaking change: stopping the export of the PortNum constructor in PortNumber. * Use bytestring == 0.10.* only. * Use base >= 4.7 && < 5. ## Version 2.7.0.2 * Removing withMVar to avoid the deadlock between "accept" and "close" [#330](https://github.com/haskell/network/pull/330) * "close" does not throw exceptions. A new API: "close'" throws exceptions when necessary. [#337](https://github.com/haskell/network/pull/337) * Fixing the hang of lazy sendAll. [#340](https://github.com/haskell/network/pull/340) * Installing NetDef.h (#334) [#334](https://github.com/haskell/network/pull/334) ## Version 2.7.0.1 * A new API: socketPortSafe. [#319](https://github.com/haskell/network/pull/319) * Fixing a drain bug of sendAll. [#320](https://github.com/haskell/network/pull/320) * Porting the new CALLCONV convention from master. [#313](https://github.com/haskell/network/pull/313) * Withdrawing the deprecations of packFamily and unpackFamily. [#324](https://github.com/haskell/network/pull/324) ## Version 2.7.0.0 * Obsoleting the Network module. * Obsoleting the Network.BSD module. * Obsoleting APIs: MkSocket, htonl, ntohl, getPeerCred, getPeerEid, send, sendTo, recv, recvFrom, recvLen, inet_addr, inet_ntoa, isConnected, isBound, isListening, isReadable, isWritable, aNY_PORT, iNADDR_ANY, iN6ADDR_ANY, sOMAXCONN, sOL_SOCKET, sCM_RIGHTS, packFamily, unpackFamily, packSocketType * Breaking change: do not closeFd within sendFd. [#271](https://github.com/haskell/network/pull/271) * Exporting ifNameToIndex and ifIndexToName from Network.Socket. * New APIs: setCloseOnExecIfNeeded, getCloseOnExec and getNonBlock * New APIs: isUnixDomainSocketAvailable and getPeerCredential * socketPair, sendFd and recvFd are exported even on Windows. ## Version 2.6.3.5 * Reverting "Do not closeFd within sendFd" [#271](https://github.com/haskell/network/pull/271) ## Version 2.6.3.4 * Don't touch IPv6Only when running on OpenBSD [#227](https://github.com/haskell/network/pull/227) * Do not closeFd within sendFd [#271](https://github.com/haskell/network/pull/271) * Updating examples and docs. ## Version 2.6.3.3 * Adds a function to show the defaultHints without reading their undefined fields [#291](https://github.com/haskell/network/pull/292) * Improve exception error messages for getAddrInfo and getNameInfo [#289](https://github.com/haskell/network/pull/289) ## Version 2.6.3.2 * Zero memory of `sockaddr_un` if abstract socket [#220](https://github.com/haskell/network/pull/220) * Improving error messages [#232](https://github.com/haskell/network/pull/232) * Allow non-blocking file descriptors via `setNonBlockIfNeeded` [#242](https://github.com/haskell/network/pull/242) * Update config.{guess,sub} to latest version [#244](https://github.com/haskell/network/pull/244) * Rename `my_inet_ntoa` to avoid symbol conflicts [#228](https://github.com/haskell/network/pull/228) * Test infrastructure improvements [#219](https://github.com/haskell/network/pull/219) [#217](https://github.com/haskell/network/pull/217) [#218](https://github.com/haskell/network/pull/218) * House keeping and cleanup [#238](https://github.com/haskell/network/pull/238) [#237](https://github.com/haskell/network/pull/237) ## Version 2.6.3.1 * Reverse breaking exception change in `Network.Socket.ByteString.recv` [#215](https://github.com/haskell/network/issues/215) ## Version 2.6.3.0 * New maintainers: Evan Borden (@eborden) and Kazu Yamamoto (@kazu-yamamoto). The maintainer for a long period, Johan Tibell (@tibbe) stepped down. Thank you, Johan, for your hard work for a long time. * New APIs: ntohl, htonl,hostAddressToTuple{,6} and tupleToHostAddress{,6}. [#210](https://github.com/haskell/network/pull/210) * Added a Read instance for PortNumber. [#145](https://github.com/haskell/network/pull/145) * We only set the IPV6_V6ONLY flag to 0 for stream and datagram socket types, as opposed to all of them. This makes it possible to use ICMPv6. [#180](https://github.com/haskell/network/pull/180) [#181](https://github.com/haskell/network/pull/181) * Work around GHC bug #12020. Socket errors no longer cause segfaults or hangs on Windows. [#192](https://github.com/haskell/network/pull/192) * Various documentation improvements and the deprecated pragmas. [#186](https://github.com/haskell/network/pull/186) [#201](https://github.com/haskell/network/issues/201) [#205](https://github.com/haskell/network/pull/205) [#206](https://github.com/haskell/network/pull/206) [#211](https://github.com/haskell/network/issues/211) * Various internal improvements. [#193](https://github.com/haskell/network/pull/193) [#200](https://github.com/haskell/network/pull/200) ## Version 2.6.2.1 * Regenerate configure and `HsNetworkConfig.h.in`. * Better detection of CAN sockets. ## Version 2.6.2.0 * Add support for `TCP_USER_TIMEOUT`. * Don't conditionally export the `SockAddr` constructors. * Add `isSupportSockAddr` to allow checking for supported address types at runtime. network-3.1.4.0/LICENSE0000644000000000000000000000307307346545000012547 0ustar0000000000000000Copyright (c) 2002-2010, The University Court of the University of Glasgow. Copyright (c) 2007-2010, Johan Tibell Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. network-3.1.4.0/Network/0000755000000000000000000000000007346545000013170 5ustar0000000000000000network-3.1.4.0/Network/Socket.hs0000644000000000000000000002144707346545000014764 0ustar0000000000000000{-# LANGUAGE CPP #-} #include "HsNetDef.h" ----------------------------------------------------------------------------- -- | -- Module : Network.Socket -- Copyright : (c) The University of Glasgow 2001 -- License : BSD-style (see the file libraries/network/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : provisional -- Portability : portable -- -- This is the main module of the network package supposed to be -- used with either "Network.Socket.ByteString" or -- "Network.Socket.ByteString.Lazy" for sending/receiving. -- -- Here are two minimal example programs using the TCP/IP protocol: -- -- * a server that echoes all data that it receives back -- * a client using it -- -- > -- Echo server program -- > module Main (main) where -- > -- > import Control.Concurrent (forkFinally) -- > import qualified Control.Exception as E -- > import Control.Monad (unless, forever, void) -- > import qualified Data.ByteString as S -- > import Network.Socket -- > import Network.Socket.ByteString (recv, sendAll) -- > -- > main :: IO () -- > main = runTCPServer Nothing "3000" talk -- > where -- > talk s = do -- > msg <- recv s 1024 -- > unless (S.null msg) $ do -- > sendAll s msg -- > talk s -- > -- > -- from the "network-run" package. -- > runTCPServer :: Maybe HostName -> ServiceName -> (Socket -> IO a) -> IO a -- > runTCPServer mhost port server = withSocketsDo $ do -- > addr <- resolve -- > E.bracket (open addr) close loop -- > where -- > resolve = do -- > let hints = defaultHints { -- > addrFlags = [AI_PASSIVE] -- > , addrSocketType = Stream -- > } -- > head <$> getAddrInfo (Just hints) mhost (Just port) -- > open addr = E.bracketOnError (openSocket addr) close $ \sock -> do -- > setSocketOption sock ReuseAddr 1 -- > withFdSocket sock setCloseOnExecIfNeeded -- > bind sock $ addrAddress addr -- > listen sock 1024 -- > return sock -- > loop sock = forever $ E.bracketOnError (accept sock) (close . fst) -- > $ \(conn, _peer) -> void $ -- > -- 'forkFinally' alone is unlikely to fail thus leaking @conn@, -- > -- but 'E.bracketOnError' above will be necessary if some -- > -- non-atomic setups (e.g. spawning a subprocess to handle -- > -- @conn@) before proper cleanup of @conn@ is your case -- > forkFinally (server conn) (const $ gracefulClose conn 5000) -- -- > {-# LANGUAGE OverloadedStrings #-} -- > -- Echo client program -- > module Main (main) where -- > -- > import qualified Control.Exception as E -- > import qualified Data.ByteString.Char8 as C -- > import Network.Socket -- > import Network.Socket.ByteString (recv, sendAll) -- > -- > main :: IO () -- > main = runTCPClient "127.0.0.1" "3000" $ \s -> do -- > sendAll s "Hello, world!" -- > msg <- recv s 1024 -- > putStr "Received: " -- > C.putStrLn msg -- > -- > -- from the "network-run" package. -- > runTCPClient :: HostName -> ServiceName -> (Socket -> IO a) -> IO a -- > runTCPClient host port client = withSocketsDo $ do -- > addr <- resolve -- > E.bracket (open addr) close client -- > where -- > resolve = do -- > let hints = defaultHints { addrSocketType = Stream } -- > head <$> getAddrInfo (Just hints) (Just host) (Just port) -- > open addr = E.bracketOnError (openSocket addr) close $ \sock -> do -- > connect sock $ addrAddress addr -- > return sock -- -- The proper programming model is that one 'Socket' is handled by -- a single thread. If multiple threads use one 'Socket' concurrently, -- unexpected things would happen. There is one exception for multiple -- threads vs a single 'Socket': one thread reads data from a 'Socket' -- only and the other thread writes data to the 'Socket' only. ----------------------------------------------------------------------------- -- In order to process this file, you need to have CALLCONV defined. module Network.Socket ( -- * Initialisation withSocketsDo -- * Address information , getAddrInfo -- ** Types , HostName , ServiceName , AddrInfo(..) , defaultHints -- ** Flags , AddrInfoFlag(..) , addrInfoFlagImplemented -- * Socket operations , connect , bind , listen , accept -- ** Closing , close , close' , gracefulClose , shutdown , ShutdownCmd(..) -- * Socket options , SocketOption(SockOpt ,UnsupportedSocketOption ,Debug,ReuseAddr,SoDomain,Type,SoProtocol,SoError,DontRoute ,Broadcast,SendBuffer,RecvBuffer,KeepAlive,OOBInline ,TimeToLive,MaxSegment,NoDelay,Cork,Linger,ReusePort ,RecvLowWater,SendLowWater,RecvTimeOut,SendTimeOut ,UseLoopBack,UserTimeout,IPv6Only ,RecvIPv4TTL,RecvIPv4TOS,RecvIPv4PktInfo ,RecvIPv6HopLimit,RecvIPv6TClass,RecvIPv6PktInfo) , StructLinger (..) , SocketTimeout (..) , isSupportedSocketOption , whenSupported , getSocketOption , setSocketOption , getSockOpt , setSockOpt -- * Socket , Socket , socket , openSocket , withFdSocket , unsafeFdSocket , touchSocket , socketToFd , fdSocket , mkSocket , socketToHandle -- ** Types of Socket , SocketType(GeneralSocketType, UnsupportedSocketType, NoSocketType , Stream, Datagram, Raw, RDM, SeqPacket) , isSupportedSocketType , getSocketType -- ** Family , Family(GeneralFamily, UnsupportedFamily ,AF_UNSPEC,AF_UNIX,AF_INET,AF_INET6,AF_IMPLINK,AF_PUP,AF_CHAOS ,AF_NS,AF_NBS,AF_ECMA,AF_DATAKIT,AF_CCITT,AF_SNA,AF_DECnet ,AF_DLI,AF_LAT,AF_HYLINK,AF_APPLETALK,AF_ROUTE,AF_NETBIOS ,AF_NIT,AF_802,AF_ISO,AF_OSI,AF_NETMAN,AF_X25,AF_AX25,AF_OSINET ,AF_GOSSIP,AF_IPX,Pseudo_AF_XTP,AF_CTF,AF_WAN,AF_SDL,AF_NETWARE ,AF_NDD,AF_INTF,AF_COIP,AF_CNT,Pseudo_AF_RTIP,Pseudo_AF_PIP ,AF_SIP,AF_ISDN,Pseudo_AF_KEY,AF_NATM,AF_ARP,Pseudo_AF_HDRCMPLT ,AF_ENCAP,AF_LINK,AF_RAW,AF_RIF,AF_NETROM,AF_BRIDGE,AF_ATMPVC ,AF_ROSE,AF_NETBEUI,AF_SECURITY,AF_PACKET,AF_ASH,AF_ECONET ,AF_ATMSVC,AF_IRDA,AF_PPPOX,AF_WANPIPE,AF_BLUETOOTH,AF_CAN) , isSupportedFamily , packFamily , unpackFamily -- ** Protocol number , ProtocolNumber , defaultProtocol -- * Basic socket address type , SockAddr(..) , isSupportedSockAddr , getPeerName , getSocketName -- ** Host address , HostAddress , hostAddressToTuple , tupleToHostAddress -- ** Host address6 , HostAddress6 , hostAddress6ToTuple , tupleToHostAddress6 -- ** Flow Info , FlowInfo -- ** Scope ID , ScopeID , ifNameToIndex , ifIndexToName -- ** Port number , PortNumber , defaultPort , socketPortSafe , socketPort -- * UNIX-domain socket , isUnixDomainSocketAvailable , socketPair , sendFd , recvFd , getPeerCredential -- * Name information , getNameInfo , NameInfoFlag(..) -- * Low level -- ** socket operations , setCloseOnExecIfNeeded , getCloseOnExec , setNonBlockIfNeeded , getNonBlock -- ** Sending and receiving data , sendBuf , recvBuf , sendBufTo , recvBufFrom -- ** Advanced IO , sendBufMsg , recvBufMsg , MsgFlag(MSG_OOB,MSG_DONTROUTE,MSG_PEEK,MSG_EOR,MSG_TRUNC,MSG_CTRUNC,MSG_WAITALL) -- ** Control message (ancillary data) , Cmsg(..) , CmsgId(CmsgId ,CmsgIdIPv4TTL ,CmsgIdIPv6HopLimit ,CmsgIdIPv4TOS ,CmsgIdIPv6TClass ,CmsgIdIPv4PktInfo ,CmsgIdIPv6PktInfo ,CmsgIdFd ,UnsupportedCmsgId) -- ** APIs for control message , lookupCmsg , filterCmsg , decodeCmsg , encodeCmsg -- ** Class and types for control message , ControlMessage(..) , IPv4TTL(..) , IPv6HopLimit(..) , IPv4TOS(..) , IPv6TClass(..) , IPv4PktInfo(..) , IPv6PktInfo(..) -- * Special constants , maxListenQueue ) where import Network.Socket.Buffer hiding (sendBufTo, recvBufFrom, sendBufMsg, recvBufMsg) import Network.Socket.Cbits import Network.Socket.Fcntl import Network.Socket.Flag import Network.Socket.Handle import Network.Socket.If import Network.Socket.Info import Network.Socket.Internal import Network.Socket.Name hiding (getPeerName, getSocketName) import Network.Socket.Options import Network.Socket.Shutdown import Network.Socket.SockAddr import Network.Socket.Syscall hiding (connect, bind, accept) import Network.Socket.Types import Network.Socket.Unix #if !defined(mingw32_HOST_OS) import Network.Socket.Posix.Cmsg #else import Network.Socket.Win32.Cmsg #endif network-3.1.4.0/Network/Socket/0000755000000000000000000000000007346545000014420 5ustar0000000000000000network-3.1.4.0/Network/Socket/Address.hs0000644000000000000000000000117607346545000016346 0ustar0000000000000000-- | This module provides extensible APIs for socket addresses. -- module Network.Socket.Address ( -- * Socket Address SocketAddress(..) , getPeerName , getSocketName -- * Socket operations , connect , bind , accept -- * Sending and receiving ByteString , sendTo , sendAllTo , recvFrom -- * Sending and receiving data from a buffer , sendBufTo , recvBufFrom -- * Advanced IO , sendBufMsg , recvBufMsg ) where import Network.Socket.ByteString.IO import Network.Socket.Buffer import Network.Socket.Name import Network.Socket.Syscall import Network.Socket.Types network-3.1.4.0/Network/Socket/Buffer.hsc0000644000000000000000000003112307346545000016330 0ustar0000000000000000{-# LANGUAGE CPP #-} ##include "HsNetDef.h" #if defined(mingw32_HOST_OS) # include "windows.h" #endif module Network.Socket.Buffer ( sendBufTo , sendBuf , recvBufFrom , recvBuf , recvBufNoWait , sendBufMsg , recvBufMsg ) where #if !defined(mingw32_HOST_OS) import Foreign.C.Error (getErrno, eAGAIN, eWOULDBLOCK) #else import Foreign.Ptr (nullPtr) #endif import Foreign.Marshal.Alloc (alloca, allocaBytes) import Foreign.Marshal.Utils (with) import GHC.IO.Exception (IOErrorType(InvalidArgument)) import System.IO.Error (mkIOError, ioeSetErrorString, catchIOError) #if defined(mingw32_HOST_OS) import GHC.IO.FD (FD(..), readRawBufferPtr, writeRawBufferPtr) import Network.Socket.Win32.CmsgHdr import Network.Socket.Win32.MsgHdr import Network.Socket.Win32.WSABuf #else import Network.Socket.Posix.CmsgHdr import Network.Socket.Posix.MsgHdr import Network.Socket.Posix.IOVec #endif import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Name import Network.Socket.Types import Network.Socket.Flag #if defined(mingw32_HOST_OS) type DWORD = Word32 type LPDWORD = Ptr DWORD #endif -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. -- Returns the number of bytes sent. Applications are responsible for -- ensuring that all data has been sent. sendBufTo :: SocketAddress sa => Socket -- (possibly) bound/connected Socket -> Ptr a -> Int -- Data to send -> sa -> IO Int -- Number of Bytes sent sendBufTo s ptr nbytes sa = withSocketAddress sa $ \p_sa siz -> fromIntegral <$> do withFdSocket s $ \fd -> do let sz = fromIntegral siz n = fromIntegral nbytes flags = 0 throwSocketErrorWaitWrite s "Network.Socket.sendBufTo" $ c_sendto fd ptr n flags p_sa sz #if defined(mingw32_HOST_OS) socket2FD :: Socket -> IO FD socket2FD s = do fd <- unsafeFdSocket s -- HACK, 1 means True return $ FD{ fdFD = fd, fdIsSocket_ = 1 } #endif -- | Send data to the socket. The socket must be connected to a remote -- socket. Returns the number of bytes sent. Applications are -- responsible for ensuring that all data has been sent. sendBuf :: Socket -- Bound/Connected Socket -> Ptr Word8 -- Pointer to the data to send -> Int -- Length of the buffer -> IO Int -- Number of Bytes sent sendBuf s str len = fromIntegral <$> do #if defined(mingw32_HOST_OS) -- writeRawBufferPtr is supposed to handle checking for errors, but it's broken -- on x86_64 because of GHC bug #12010 so we duplicate the check here. The call -- to throwSocketErrorIfMinus1Retry can be removed when no GHC version with the -- bug is supported. fd <- socket2FD s let clen = fromIntegral len throwSocketErrorIfMinus1Retry "Network.Socket.sendBuf" $ writeRawBufferPtr "Network.Socket.sendBuf" fd (castPtr str) 0 clen #else withFdSocket s $ \fd -> do let flags = 0 clen = fromIntegral len throwSocketErrorWaitWrite s "Network.Socket.sendBuf" $ c_send fd str clen flags #endif -- | Receive data from the socket, writing it into buffer instead of -- creating a new string. The socket need not be in a connected -- state. Returns @(nbytes, address)@ where @nbytes@ is the number of -- bytes received and @address@ is a 'SockAddr' representing the -- address of the sending socket. -- -- If the first return value is zero, it means EOF. -- -- For 'Stream' sockets, the second return value would be invalid. -- -- NOTE: blocking on Windows unless you compile with -threaded (see -- GHC ticket #1129) recvBufFrom :: SocketAddress sa => Socket -> Ptr a -> Int -> IO (Int, sa) recvBufFrom s ptr nbytes | nbytes <= 0 = ioError (mkInvalidRecvArgError "Network.Socket.recvBufFrom") | otherwise = withNewSocketAddress $ \ptr_sa sz -> alloca $ \ptr_len -> withFdSocket s $ \fd -> do poke ptr_len (fromIntegral sz) let cnbytes = fromIntegral nbytes flags = 0 len <- throwSocketErrorWaitRead s "Network.Socket.recvBufFrom" $ c_recvfrom fd ptr cnbytes flags ptr_sa ptr_len sockaddr <- peekSocketAddress ptr_sa `catchIOError` \_ -> getPeerName s return (fromIntegral len, sockaddr) -- | Receive data from the socket. The socket must be in a connected -- state. This function may return fewer bytes than specified. If the -- message is longer than the specified length, it may be discarded -- depending on the type of socket. This function may block until a -- message arrives. -- -- Considering hardware and network realities, the maximum number of -- bytes to receive should be a small power of 2, e.g., 4096. -- -- The return value is the length of received data. Zero means -- EOF. Historical note: Version 2.8.x.y or earlier, -- an EOF error was thrown. This was changed in version 3.0. recvBuf :: Socket -> Ptr Word8 -> Int -> IO Int recvBuf s ptr nbytes | nbytes <= 0 = ioError (mkInvalidRecvArgError "Network.Socket.recvBuf") | otherwise = do #if defined(mingw32_HOST_OS) -- see comment in sendBuf above. fd <- socket2FD s let cnbytes = fromIntegral nbytes len <- throwSocketErrorIfMinus1Retry "Network.Socket.recvBuf" $ readRawBufferPtr "Network.Socket.recvBuf" fd ptr 0 cnbytes #else len <- withFdSocket s $ \fd -> throwSocketErrorWaitRead s "Network.Socket.recvBuf" $ c_recv fd (castPtr ptr) (fromIntegral nbytes) 0{-flags-} #endif return $ fromIntegral len -- | Receive data from the socket. This function returns immediately -- even if data is not available. In other words, IO manager is NOT -- involved. The length of data is returned if received. -- -1 is returned in the case of EAGAIN or EWOULDBLOCK. -- -2 is returned in other error cases. recvBufNoWait :: Socket -> Ptr Word8 -> Int -> IO Int recvBufNoWait s ptr nbytes = withFdSocket s $ \fd -> do #if defined(mingw32_HOST_OS) alloca $ \ptr_bytes -> do res <- c_ioctlsocket fd #{const FIONREAD} ptr_bytes avail <- peek ptr_bytes r <- if res == #{const NO_ERROR} && avail > 0 then c_recv fd (castPtr ptr) (fromIntegral nbytes) 0{-flags-} else if avail == 0 then -- Socket would block, could also mean socket is closed but -- can't distinguish return (-1) else do err <- c_WSAGetLastError if err == #{const WSAEWOULDBLOCK} || err == #{const WSAEINPROGRESS} then return (-1) else return (-2) return $ fromIntegral r #else r <- c_recv fd (castPtr ptr) (fromIntegral nbytes) 0{-flags-} if r >= 0 then return $ fromIntegral r else do err <- getErrno if err == eAGAIN || err == eWOULDBLOCK then return (-1) else return (-2) #endif mkInvalidRecvArgError :: String -> IOError mkInvalidRecvArgError loc = ioeSetErrorString (mkIOError InvalidArgument loc Nothing Nothing) "non-positive length" -- | Send data to the socket using sendmsg(2). sendBufMsg :: SocketAddress sa => Socket -- ^ Socket -> sa -- ^ Destination address -> [(Ptr Word8,Int)] -- ^ Data to be sent -> [Cmsg] -- ^ Control messages -> MsgFlag -- ^ Message flags -> IO Int -- ^ The length actually sent sendBufMsg s sa bufsizs cmsgs flags = do sz <- withSocketAddress sa $ \addrPtr addrSize -> #if !defined(mingw32_HOST_OS) withIOVec bufsizs $ \(iovsPtr, iovsLen) -> do #else withWSABuf bufsizs $ \(wsaBPtr, wsaBLen) -> do #endif withCmsgs cmsgs $ \ctrlPtr ctrlLen -> do let msgHdr = MsgHdr { msgName = addrPtr , msgNameLen = fromIntegral addrSize #if !defined(mingw32_HOST_OS) , msgIov = iovsPtr , msgIovLen = fromIntegral iovsLen #else , msgBuffer = wsaBPtr , msgBufferLen = fromIntegral wsaBLen #endif , msgCtrl = castPtr ctrlPtr , msgCtrlLen = fromIntegral ctrlLen , msgFlags = 0 } cflags = fromMsgFlag flags withFdSocket s $ \fd -> with msgHdr $ \msgHdrPtr -> throwSocketErrorWaitWrite s "Network.Socket.Buffer.sendMsg" $ #if !defined(mingw32_HOST_OS) c_sendmsg fd msgHdrPtr cflags #else alloca $ \send_ptr -> c_sendmsg fd msgHdrPtr (fromIntegral cflags) send_ptr nullPtr nullPtr #endif return $ fromIntegral sz -- | Receive data from the socket using recvmsg(2). The supplied -- buffers are filled in order, with subsequent buffers used only -- after all the preceding buffers are full. If the message is short -- enough some of the supplied buffers may remain unused. recvBufMsg :: SocketAddress sa => Socket -- ^ Socket -> [(Ptr Word8,Int)] -- ^ A list of (buffer, buffer-length) pairs. -- If the total length is not large enough, -- 'MSG_TRUNC' is returned -> Int -- ^ The buffer size for control messages. -- If the length is not large enough, -- 'MSG_CTRUNC' is returned -> MsgFlag -- ^ Message flags -> IO (sa,Int,[Cmsg],MsgFlag) -- ^ Source address, total bytes received, control messages and message flags recvBufMsg s bufsizs clen flags = do withNewSocketAddress $ \addrPtr addrSize -> allocaBytes clen $ \ctrlPtr -> #if !defined(mingw32_HOST_OS) withIOVec bufsizs $ \(iovsPtr, iovsLen) -> do let msgHdr = MsgHdr { msgName = addrPtr , msgNameLen = fromIntegral addrSize , msgIov = iovsPtr , msgIovLen = fromIntegral iovsLen , msgCtrl = castPtr ctrlPtr , msgCtrlLen = fromIntegral clen , msgFlags = 0 #else withWSABuf bufsizs $ \(wsaBPtr, wsaBLen) -> do let msgHdr = MsgHdr { msgName = addrPtr , msgNameLen = fromIntegral addrSize , msgBuffer = wsaBPtr , msgBufferLen = fromIntegral wsaBLen , msgCtrl = if clen == 0 then nullPtr else castPtr ctrlPtr , msgCtrlLen = fromIntegral clen , msgFlags = fromIntegral $ fromMsgFlag flags #endif } _cflags = fromMsgFlag flags withFdSocket s $ \fd -> do with msgHdr $ \msgHdrPtr -> do len <- (fmap fromIntegral) <$> #if !defined(mingw32_HOST_OS) throwSocketErrorWaitRead s "Network.Socket.Buffer.recvmsg" $ c_recvmsg fd msgHdrPtr _cflags #else alloca $ \len_ptr -> do _ <- throwSocketErrorWaitReadBut (== #{const WSAEMSGSIZE}) s "Network.Socket.Buffer.recvmsg" $ c_recvmsg fd msgHdrPtr len_ptr nullPtr nullPtr peek len_ptr #endif sockaddr <- peekSocketAddress addrPtr `catchIOError` \_ -> getPeerName s hdr <- peek msgHdrPtr cmsgs <- parseCmsgs msgHdrPtr let flags' = MsgFlag $ fromIntegral $ msgFlags hdr return (sockaddr, len, cmsgs, flags') #if !defined(mingw32_HOST_OS) foreign import ccall unsafe "send" c_send :: CInt -> Ptr a -> CSize -> CInt -> IO CInt foreign import ccall unsafe "sendmsg" c_sendmsg :: CInt -> Ptr (MsgHdr sa) -> CInt -> IO CInt -- fixme CSsize foreign import ccall unsafe "recvmsg" c_recvmsg :: CInt -> Ptr (MsgHdr sa) -> CInt -> IO CInt #else foreign import CALLCONV SAFE_ON_WIN "ioctlsocket" c_ioctlsocket :: CInt -> CLong -> Ptr CULong -> IO CInt foreign import CALLCONV SAFE_ON_WIN "WSAGetLastError" c_WSAGetLastError :: IO CInt foreign import CALLCONV SAFE_ON_WIN "WSASendMsg" -- fixme Handle for SOCKET, see #426 c_sendmsg :: CInt -> Ptr (MsgHdr sa) -> DWORD -> LPDWORD -> Ptr () -> Ptr () -> IO CInt foreign import CALLCONV SAFE_ON_WIN "WSARecvMsg" c_recvmsg :: CInt -> Ptr (MsgHdr sa) -> LPDWORD -> Ptr () -> Ptr () -> IO CInt #endif foreign import ccall unsafe "recv" c_recv :: CInt -> Ptr CChar -> CSize -> CInt -> IO CInt foreign import CALLCONV SAFE_ON_WIN "sendto" c_sendto :: CInt -> Ptr a -> CSize -> CInt -> Ptr sa -> CInt -> IO CInt foreign import CALLCONV SAFE_ON_WIN "recvfrom" c_recvfrom :: CInt -> Ptr a -> CSize -> CInt -> Ptr sa -> Ptr CInt -> IO CInt network-3.1.4.0/Network/Socket/ByteString.hs0000644000000000000000000000547607346545000017062 0ustar0000000000000000-- | -- Module : Network.Socket.ByteString -- Copyright : (c) Johan Tibell 2007-2010 -- License : BSD-style -- -- Maintainer : johan.tibell@gmail.com -- Stability : stable -- Portability : portable -- -- This module provides access to the BSD /socket/ interface. For detailed -- documentation, consult your favorite POSIX socket reference. All functions -- communicate failures by converting the error number to an -- 'System.IO.Error.IOError'. -- -- This module is made to be imported with "Network.Socket" like so: -- -- > import Network.Socket -- > import Network.Socket.ByteString -- module Network.Socket.ByteString ( -- * Send data to a socket send , sendAll , sendTo , sendAllTo -- ** Vectored I/O -- $vectored , sendMany , sendManyTo -- * Receive data from a socket , recv , recvFrom -- * Advanced send and recv , sendMsg , recvMsg ) where import Data.ByteString (ByteString) import qualified Network.Socket.ByteString.IO as G import Network.Socket.ByteString.IO hiding (sendTo, sendAllTo, recvFrom) import Network.Socket.Types -- ---------------------------------------------------------------------------- -- ** Vectored I/O -- $vectored -- -- Vectored I\/O, also known as scatter\/gather I\/O, allows multiple -- data segments to be sent using a single system call, without first -- concatenating the segments. For example, given a list of -- @ByteString@s, @xs@, -- -- > sendMany sock xs -- -- is equivalent to -- -- > sendAll sock (concat xs) -- -- but potentially more efficient. -- -- Vectored I\/O are often useful when implementing network protocols -- that, for example, group data into segments consisting of one or -- more fixed-length headers followed by a variable-length body. -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. -- Returns the number of bytes sent. Applications are responsible for -- ensuring that all data has been sent. sendTo :: Socket -> ByteString -> SockAddr -> IO Int sendTo = G.sendTo -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. Unlike -- 'sendTo', this function continues to send data until either all -- data has been sent or an error occurs. On error, an exception is -- raised, and there is no way to determine how much data, if any, was -- successfully sent. sendAllTo :: Socket -> ByteString -> SockAddr -> IO () sendAllTo = G.sendAllTo -- | Receive data from the socket. The socket need not be in a -- connected state. Returns @(bytes, address)@ where @bytes@ is a -- 'ByteString' representing the data received and @address@ is a -- 'SockAddr' representing the address of the sending socket. recvFrom :: Socket -> Int -> IO (ByteString, SockAddr) recvFrom = G.recvFrom network-3.1.4.0/Network/Socket/ByteString/0000755000000000000000000000000007346545000016512 5ustar0000000000000000network-3.1.4.0/Network/Socket/ByteString/IO.hsc0000644000000000000000000003103507346545000017522 0ustar0000000000000000{-# LANGUAGE BangPatterns #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE OverloadedStrings #-} #include "HsNet.h" -- | -- Module : Network.Socket.ByteString.IO -- Copyright : (c) Johan Tibell 2007-2010 -- License : BSD-style -- -- Maintainer : johan.tibell@gmail.com -- Stability : stable -- Portability : portable -- module Network.Socket.ByteString.IO ( -- * Send data to a socket send , sendAll , sendTo , sendAllTo -- ** Vectored I/O -- $vectored , sendMany , sendManyTo -- * Receive data from a socket , recv , recvFrom , waitWhen0 -- * Advanced send and recv , sendMsg , recvMsg , MsgFlag(..) , Cmsg(..) ) where import Control.Concurrent (threadWaitWrite, rtsSupportsBoundThreads) import Data.ByteString (ByteString) import qualified Data.ByteString as B import Data.ByteString.Internal (createAndTrim) import Data.ByteString.Unsafe (unsafeUseAsCStringLen) import Foreign.Marshal.Alloc (allocaBytes) import Network.Socket.Buffer import Network.Socket.ByteString.Internal import Network.Socket.Imports import Network.Socket.Types import Data.ByteString.Internal (create, ByteString(..)) import Foreign.ForeignPtr (withForeignPtr) import Foreign.Marshal.Utils (with) import Network.Socket.Internal import Network.Socket.Flag #if !defined(mingw32_HOST_OS) import Network.Socket.Posix.Cmsg import Network.Socket.Posix.IOVec import Network.Socket.Posix.MsgHdr (MsgHdr(..)) #else import Foreign.Marshal.Alloc (alloca) import Network.Socket.Win32.Cmsg import Network.Socket.Win32.WSABuf import Network.Socket.Win32.MsgHdr (MsgHdr(..)) #endif -- ---------------------------------------------------------------------------- -- Sending -- | Send data to the socket. The socket must be connected to a -- remote socket. Returns the number of bytes sent. Applications are -- responsible for ensuring that all data has been sent. send :: Socket -- ^ Connected socket -> ByteString -- ^ Data to send -> IO Int -- ^ Number of bytes sent send s xs = unsafeUseAsCStringLen xs $ \(str, len) -> sendBuf s (castPtr str) len waitWhen0 :: Int -> Socket -> IO () waitWhen0 0 s = when rtsSupportsBoundThreads $ withFdSocket s $ \fd -> threadWaitWrite $ fromIntegral fd waitWhen0 _ _ = return () -- | Send data to the socket. The socket must be connected to a -- remote socket. Unlike 'send', this function continues to send data -- until either all data has been sent or an error occurs. On error, -- an exception is raised, and there is no way to determine how much -- data, if any, was successfully sent. sendAll :: Socket -- ^ Connected socket -> ByteString -- ^ Data to send -> IO () sendAll _ "" = return () sendAll s bs0 = loop bs0 where loop bs = do -- "send" throws an exception. sent <- send s bs waitWhen0 sent s when (sent /= B.length bs) $ loop $ B.drop sent bs -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. -- Returns the number of bytes sent. Applications are responsible for -- ensuring that all data has been sent. sendTo :: SocketAddress sa => Socket -- ^ Socket -> ByteString -- ^ Data to send -> sa -- ^ Recipient address -> IO Int -- ^ Number of bytes sent sendTo s xs sa = unsafeUseAsCStringLen xs $ \(str, len) -> sendBufTo s str len sa -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. Unlike -- 'sendTo', this function continues to send data until either all -- data has been sent or an error occurs. On error, an exception is -- raised, and there is no way to determine how much data, if any, was -- successfully sent. sendAllTo :: SocketAddress sa => Socket -- ^ Socket -> ByteString -- ^ Data to send -> sa -- ^ Recipient address -> IO () sendAllTo _ "" _ = return () sendAllTo s bs0 sa = loop bs0 where loop bs = do -- "send" throws an exception. sent <- sendTo s bs sa waitWhen0 sent s when (sent /= B.length bs) $ loop $ B.drop sent bs -- | Send data to the socket. The socket must be in a connected -- state. The data is sent as if the parts have been concatenated. -- This function continues to send data until either all data has been -- sent or an error occurs. On error, an exception is raised, and -- there is no way to determine how much data, if any, was -- successfully sent. sendMany :: Socket -- ^ Connected socket -> [ByteString] -- ^ Data to send -> IO () sendMany _ [] = return () sendMany s cs = do sent <- sendManyInner waitWhen0 sent s when (sent >= 0) $ sendMany s $ remainingChunks sent cs where sendManyInner = #if !defined(mingw32_HOST_OS) fmap fromIntegral . withIOVecfromBS cs $ \(iovsPtr, iovsLen) -> withFdSocket s $ \fd -> do let len = fromIntegral $ min iovsLen (#const IOV_MAX) throwSocketErrorWaitWrite s "Network.Socket.ByteString.sendMany" $ c_writev fd iovsPtr len #else fmap fromIntegral . withWSABuffromBS cs $ \(wsabsPtr, wsabsLen) -> withFdSocket s $ \fd -> do let len = fromIntegral wsabsLen alloca $ \send_ptr -> do _ <- throwSocketErrorWaitWrite s "Network.Socket.ByteString.sendMany" $ c_wsasend fd wsabsPtr len send_ptr 0 nullPtr nullPtr peek send_ptr #endif -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. The -- data is sent as if the parts have been concatenated. This function -- continues to send data until either all data has been sent or an -- error occurs. On error, an exception is raised, and there is no -- way to determine how much data, if any, was successfully sent. sendManyTo :: Socket -- ^ Socket -> [ByteString] -- ^ Data to send -> SockAddr -- ^ Recipient address -> IO () sendManyTo _ [] _ = return () sendManyTo s cs addr = do sent <- fromIntegral <$> sendManyToInner waitWhen0 sent s when (sent >= 0) $ sendManyTo s (remainingChunks sent cs) addr where sendManyToInner = withSockAddr addr $ \addrPtr addrSize -> #if !defined(mingw32_HOST_OS) withIOVecfromBS cs $ \(iovsPtr, iovsLen) -> do let msgHdr = MsgHdr { msgName = addrPtr , msgNameLen = fromIntegral addrSize , msgIov = iovsPtr , msgIovLen = fromIntegral iovsLen , msgCtrl = nullPtr , msgCtrlLen = 0 , msgFlags = 0 } withFdSocket s $ \fd -> with msgHdr $ \msgHdrPtr -> throwSocketErrorWaitWrite s "Network.Socket.ByteString.sendManyTo" $ c_sendmsg fd msgHdrPtr 0 #else withWSABuffromBS cs $ \(wsabsPtr, wsabsLen) -> do let msgHdr = MsgHdr { msgName = addrPtr , msgNameLen = fromIntegral addrSize , msgBuffer = wsabsPtr , msgBufferLen = fromIntegral wsabsLen , msgCtrl = nullPtr , msgCtrlLen = 0 , msgFlags = 0 } withFdSocket s $ \fd -> with msgHdr $ \msgHdrPtr -> alloca $ \send_ptr -> do _ <- throwSocketErrorWaitWrite s "Network.Socket.ByteString.sendManyTo" $ c_sendmsg fd msgHdrPtr 0 send_ptr nullPtr nullPtr peek send_ptr #endif -- ---------------------------------------------------------------------------- -- Receiving -- | Receive data from the socket. The socket must be in a connected -- state. This function may return fewer bytes than specified. If -- the message is longer than the specified length, it may be -- discarded depending on the type of socket. This function may block -- until a message arrives. -- -- Considering hardware and network realities, the maximum number of bytes to -- receive should be a small power of 2, e.g., 4096. -- -- For TCP sockets, a zero length return value means the peer has -- closed its half side of the connection. -- -- Currently, the 'recv' family is blocked on Windows because a proper -- IO manager is not implemented. To use with 'System.Timeout.timeout' -- on Windows, use 'Network.Socket.setSocketOption' with -- 'Network.Socket.RecvTimeOut' as well. recv :: Socket -- ^ Connected socket -> Int -- ^ Maximum number of bytes to receive -> IO ByteString -- ^ Data received recv s nbytes | nbytes < 0 = ioError (mkInvalidRecvArgError "Network.Socket.ByteString.recv") | otherwise = createAndTrim nbytes $ \ptr -> recvBuf s ptr nbytes -- | Receive data from the socket. The socket need not be in a -- connected state. Returns @(bytes, address)@ where @bytes@ is a -- 'ByteString' representing the data received and @address@ is a -- 'SockAddr' representing the address of the sending socket. -- -- If the first return value is zero, it means EOF. recvFrom :: SocketAddress sa => Socket -- ^ Socket -> Int -- ^ Maximum number of bytes to receive -> IO (ByteString, sa) -- ^ Data received and sender address recvFrom sock nbytes = allocaBytes nbytes $ \ptr -> do (len, sockaddr) <- recvBufFrom sock ptr nbytes str <- B.packCStringLen (ptr, len) return (str, sockaddr) -- ---------------------------------------------------------------------------- -- Not exported -- | Suppose we try to transmit a list of chunks @cs@ via a gathering write -- operation and find that @n@ bytes were sent. Then @remainingChunks n cs@ is -- list of chunks remaining to be sent. remainingChunks :: Int -> [ByteString] -> [ByteString] remainingChunks _ [] = [] remainingChunks i (x:xs) | i < len = B.drop i x : xs | otherwise = let i' = i - len in i' `seq` remainingChunks i' xs where len = B.length x #if !defined(mingw32_HOST_OS) -- | @withIOVecfromBS cs f@ executes the computation @f@, passing as argument a pair -- consisting of a pointer to a temporarily allocated array of pointers to -- IOVec made from @cs@ and the number of pointers (@length cs@). -- /Unix only/. withIOVecfromBS :: [ByteString] -> ((Ptr IOVec, Int) -> IO a) -> IO a withIOVecfromBS cs f = withBufSizs cs $ \bufsizs -> withIOVec bufsizs f #else -- | @withWSABuffromBS cs f@ executes the computation @f@, passing as argument a pair -- consisting of a pointer to a temporarily allocated array of pointers to -- WSABuf made from @cs@ and the number of pointers (@length cs@). -- /Windows only/. withWSABuffromBS :: [ByteString] -> ((Ptr WSABuf, Int) -> IO a) -> IO a withWSABuffromBS cs f = withBufSizs cs $ \bufsizs -> withWSABuf bufsizs f #endif withBufSizs :: [ByteString] -> ([(Ptr Word8, Int)] -> IO a) -> IO a withBufSizs bss0 f = loop bss0 id where loop [] !build = f $ build [] loop (PS fptr off len:bss) !build = withForeignPtr fptr $ \ptr -> do let !ptr' = ptr `plusPtr` off loop bss (build . ((ptr',len) :)) -- | Send data to the socket using sendmsg(2). sendMsg :: Socket -- ^ Socket -> SockAddr -- ^ Destination address -> [ByteString] -- ^ Data to be sent -> [Cmsg] -- ^ Control messages -> MsgFlag -- ^ Message flags -> IO Int -- ^ The length actually sent sendMsg _ _ [] _ _ = return 0 sendMsg s addr bss cmsgs flags = withBufSizs bss $ \bufsizs -> sendBufMsg s addr bufsizs cmsgs flags -- | Receive data from the socket using recvmsg(2). recvMsg :: Socket -- ^ Socket -> Int -- ^ The maximum length of data to be received -- If the total length is not large enough, -- 'MSG_TRUNC' is returned -> Int -- ^ The buffer size for control messages. -- If the length is not large enough, -- 'MSG_CTRUNC' is returned -> MsgFlag -- ^ Message flags -> IO (SockAddr, ByteString, [Cmsg], MsgFlag) -- ^ Source address, received data, control messages and message flags recvMsg s siz clen flags = do bs@(PS fptr _ _) <- create siz $ \ptr -> zeroMemory ptr (fromIntegral siz) withForeignPtr fptr $ \ptr -> do (addr,len,cmsgs,flags') <- recvBufMsg s [(ptr,siz)] clen flags let bs' | len < siz = PS fptr 0 len | otherwise = bs return (addr, bs', cmsgs, flags') network-3.1.4.0/Network/Socket/ByteString/Internal.hs0000644000000000000000000000400107346545000020615 0ustar0000000000000000{-# LANGUAGE CPP #-} -- | -- Module : Network.Socket.ByteString.Internal -- Copyright : (c) Johan Tibell 2007-2010 -- License : BSD-style -- -- Maintainer : johan.tibell@gmail.com -- Stability : stable -- Portability : portable -- module Network.Socket.ByteString.Internal ( mkInvalidRecvArgError #if !defined(mingw32_HOST_OS) , c_writev #else , c_wsasend #endif , c_sendmsg , c_recvmsg ) where #include "HsNetDef.h" import GHC.IO.Exception (IOErrorType(..)) import System.IO.Error (ioeSetErrorString, mkIOError) #if !defined(mingw32_HOST_OS) import System.Posix.Types (CSsize(..)) import Network.Socket.Imports import Network.Socket.Posix.IOVec (IOVec) import Network.Socket.Posix.MsgHdr (MsgHdr) import Network.Socket.Types #else import Data.Word import Foreign.C.Types import Foreign.Ptr import Network.Socket.Win32.WSABuf (WSABuf) import Network.Socket.Win32.MsgHdr (MsgHdr) import Network.Socket.Types type DWORD = Word32 type LPDWORD = Ptr DWORD #endif mkInvalidRecvArgError :: String -> IOError mkInvalidRecvArgError loc = ioeSetErrorString (mkIOError InvalidArgument loc Nothing Nothing) "non-positive length" #if !defined(mingw32_HOST_OS) foreign import ccall unsafe "writev" c_writev :: CInt -> Ptr IOVec -> CInt -> IO CSsize foreign import ccall unsafe "sendmsg" c_sendmsg :: CInt -> Ptr (MsgHdr SockAddr) -> CInt -> IO CSsize foreign import ccall unsafe "recvmsg" c_recvmsg :: CInt -> Ptr (MsgHdr SockAddr) -> CInt -> IO CSsize #else -- fixme Handle for SOCKET, see #426 foreign import CALLCONV SAFE_ON_WIN "WSASend" c_wsasend :: CInt -> Ptr WSABuf -> DWORD -> LPDWORD -> DWORD -> Ptr () -> Ptr () -> IO CInt foreign import CALLCONV SAFE_ON_WIN "WSASendMsg" c_sendmsg :: CInt -> Ptr (MsgHdr SockAddr) -> DWORD -> LPDWORD -> Ptr () -> Ptr () -> IO CInt foreign import CALLCONV SAFE_ON_WIN "WSARecvMsg" c_recvmsg :: CInt -> Ptr (MsgHdr SockAddr) -> LPDWORD -> Ptr () -> Ptr () -> IO CInt #endif network-3.1.4.0/Network/Socket/ByteString/Lazy.hs0000644000000000000000000000606307346545000017772 0ustar0000000000000000{-# LANGUAGE CPP #-} -- | -- Module : Network.Socket.ByteString.Lazy -- Copyright : (c) Bryan O'Sullivan 2009 -- License : BSD-style -- -- Maintainer : bos@serpentine.com -- Stability : experimental -- Portability : POSIX, GHC -- -- This module provides access to the BSD /socket/ interface. For detailed -- documentation, consult your favorite POSIX socket reference. All functions -- communicate failures by converting the error number to an -- 'System.IO.Error.IOError'. -- -- This module is made to be imported with "Network.Socket" like so: -- -- > import Network.Socket -- > import Network.Socket.ByteString.Lazy -- > import Prelude hiding (getContents) -- module Network.Socket.ByteString.Lazy ( -- * Send data to a socket send , sendAll -- * Receive data from a socket , getContents , recv ) where import Data.ByteString.Lazy.Internal (ByteString(..), defaultChunkSize) import Network.Socket (ShutdownCmd (..), shutdown) import Prelude hiding (getContents) import System.IO.Unsafe (unsafeInterleaveIO) import System.IO.Error (catchIOError) #if defined(mingw32_HOST_OS) import Network.Socket.ByteString.Lazy.Windows (send, sendAll) #else import Network.Socket.ByteString.Lazy.Posix (send, sendAll) #endif import qualified Data.ByteString as S import qualified Network.Socket.ByteString as N import Network.Socket.Imports import Network.Socket.Types -- ----------------------------------------------------------------------------- -- Receiving -- | Receive data from the socket. The socket must be in a connected -- state. Data is received on demand, in chunks; each chunk will be -- sized to reflect the amount of data received by individual 'recv' -- calls. -- -- All remaining data from the socket is consumed. When there is no -- more data to be received, the receiving side of the socket is shut -- down. If there is an error and an exception is thrown, the socket -- is not shut down. getContents :: Socket -- ^ Connected socket -> IO ByteString -- ^ Data received getContents s = loop where loop = unsafeInterleaveIO $ do sbs <- N.recv s defaultChunkSize if S.null sbs then do shutdown s ShutdownReceive `catchIOError` const (return ()) return Empty else Chunk sbs <$> loop -- | Receive data from the socket. The socket must be in a connected -- state. This function may return fewer bytes than specified. If -- the received data is longer than the specified length, it may be -- discarded depending on the type of socket. This function may block -- until a message arrives. -- -- If there is no more data to be received, returns an empty 'ByteString'. recv :: Socket -- ^ Connected socket -> Int64 -- ^ Maximum number of bytes to receive -> IO ByteString -- ^ Data received recv s nbytes = chunk <$> N.recv s (fromIntegral nbytes) where chunk k | S.null k = Empty | otherwise = Chunk k Empty network-3.1.4.0/Network/Socket/ByteString/Lazy/0000755000000000000000000000000007346545000017431 5ustar0000000000000000network-3.1.4.0/Network/Socket/ByteString/Lazy/Posix.hs0000644000000000000000000000417307346545000021074 0ustar0000000000000000{-# LANGUAGE BangPatterns #-} {-# LANGUAGE OverloadedStrings #-} module Network.Socket.ByteString.Lazy.Posix ( -- * Send data to a socket send , sendAll ) where import qualified Data.ByteString.Lazy as L import Data.ByteString.Unsafe (unsafeUseAsCStringLen) import Foreign.Marshal.Array (allocaArray) import Network.Socket.ByteString.IO (waitWhen0) import Network.Socket.ByteString.Internal (c_writev) import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Posix.IOVec (IOVec (IOVec)) import Network.Socket.Types -- ----------------------------------------------------------------------------- -- Sending send :: Socket -- ^ Connected socket -> L.ByteString -- ^ Data to send -> IO Int64 -- ^ Number of bytes sent send s lbs = do let cs = take maxNumChunks (L.toChunks lbs) len = length cs siz <- withFdSocket s $ \fd -> allocaArray len $ \ptr -> withPokes cs ptr $ \niovs -> throwSocketErrorWaitWrite s "writev" $ c_writev fd ptr niovs return $ fromIntegral siz where withPokes ss p f = loop ss p 0 0 where loop (c:cs) q k !niovs | k < maxNumBytes = unsafeUseAsCStringLen c $ \(ptr, len) -> do poke q $ IOVec (castPtr ptr) (fromIntegral len) loop cs (q `plusPtr` sizeOf (IOVec nullPtr 0)) (k + fromIntegral len) (niovs + 1) | otherwise = f niovs loop _ _ _ niovs = f niovs maxNumBytes = 4194304 :: Int -- maximum number of bytes to transmit in one system call maxNumChunks = 1024 :: Int -- maximum number of chunks to transmit in one system call sendAll :: Socket -- ^ Connected socket -> L.ByteString -- ^ Data to send -> IO () sendAll _ "" = return () sendAll s bs0 = loop bs0 where loop bs = do -- "send" throws an exception. sent <- send s bs waitWhen0 (fromIntegral sent) s when (sent /= L.length bs) $ loop $ L.drop sent bs network-3.1.4.0/Network/Socket/ByteString/Lazy/Windows.hs0000644000000000000000000000223507346545000021421 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} module Network.Socket.ByteString.Lazy.Windows ( -- * Send data to a socket send , sendAll ) where import qualified Data.ByteString as S import qualified Data.ByteString.Lazy as L import qualified Network.Socket.ByteString as Socket import Network.Socket.Imports import Network.Socket.ByteString.IO (waitWhen0) import Network.Socket.Types -- ----------------------------------------------------------------------------- -- Sending send :: Socket -- ^ Connected socket -> L.ByteString -- ^ Data to send -> IO Int64 -- ^ Number of bytes sent send s lbs = case L.toChunks lbs of -- TODO: Consider doing nothing if the string is empty. [] -> fromIntegral <$> Socket.send s S.empty (x:_) -> fromIntegral <$> Socket.send s x sendAll :: Socket -- ^ Connected socket -> L.ByteString -- ^ Data to send -> IO () sendAll _ "" = return () sendAll s bs0 = loop bs0 where loop bs = do -- "send" throws an exception. sent <- send s bs waitWhen0 (fromIntegral sent) s when (sent /= L.length bs) $ loop $ L.drop sent bs network-3.1.4.0/Network/Socket/Cbits.hsc0000644000000000000000000000134507346545000016166 0ustar0000000000000000module Network.Socket.Cbits where #include "HsNet.h" import Network.Socket.Imports -- | This is the value of SOMAXCONN, typically 128. -- 128 is good enough for normal network servers but -- is too small for high performance servers. maxListenQueue :: Int maxListenQueue = #const SOMAXCONN #if defined(mingw32_HOST_OS) wsaNotInitialized :: CInt wsaNotInitialized = #const WSANOTINITIALISED #else fGetFd :: CInt fGetFd = #const F_GETFD fGetFl :: CInt fGetFl = #const F_GETFL fdCloexec :: CInt fdCloexec = #const FD_CLOEXEC oNonBlock :: CInt oNonBlock = #const O_NONBLOCK # if defined(HAVE_ADVANCED_SOCKET_FLAGS) sockNonBlock :: CInt sockNonBlock = #const SOCK_NONBLOCK sockCloexec :: CInt sockCloexec = #const SOCK_CLOEXEC # endif #endif network-3.1.4.0/Network/Socket/Fcntl.hs0000644000000000000000000000274407346545000016031 0ustar0000000000000000{-# LANGUAGE CPP #-} module Network.Socket.Fcntl where import qualified System.Posix.Internals #if !defined(mingw32_HOST_OS) import Network.Socket.Cbits #endif import Network.Socket.Imports -- | Set the nonblocking flag on Unix. -- On Windows, nothing is done. setNonBlockIfNeeded :: CInt -> IO () setNonBlockIfNeeded fd = System.Posix.Internals.setNonBlockingFD fd True -- | Set the close_on_exec flag on Unix. -- On Windows, nothing is done. -- -- Since 2.7.0.0. setCloseOnExecIfNeeded :: CInt -> IO () #if defined(mingw32_HOST_OS) || defined(ghcjs_HOST_OS) setCloseOnExecIfNeeded _ = return () #else setCloseOnExecIfNeeded fd = System.Posix.Internals.setCloseOnExec fd #endif #if !defined(mingw32_HOST_OS) foreign import ccall unsafe "fcntl" c_fcntl_read :: CInt -> CInt -> CInt -> IO CInt #endif -- | Get the close_on_exec flag. -- On Windows, this function always returns 'False'. -- -- Since 2.7.0.0. getCloseOnExec :: CInt -> IO Bool #if defined(mingw32_HOST_OS) || defined(ghcjs_HOST_OS) getCloseOnExec _ = return False #else getCloseOnExec fd = do flags <- c_fcntl_read fd fGetFd 0 let ret = flags .&. fdCloexec return (ret /= 0) #endif -- | Get the nonblocking flag. -- On Windows, this function always returns 'False'. -- -- Since 2.7.0.0. getNonBlock :: CInt -> IO Bool #if defined(mingw32_HOST_OS) getNonBlock _ = return False #else getNonBlock fd = do flags <- c_fcntl_read fd fGetFl 0 let ret = flags .&. oNonBlock return (ret /= 0) #endif network-3.1.4.0/Network/Socket/Flag.hsc0000644000000000000000000000425707346545000016000 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE PatternSynonyms #-} #include "HsNet.h" module Network.Socket.Flag where import qualified Data.Semigroup as Sem import Network.Socket.Imports {- import Network.Socket.ReadShow import qualified Text.Read as P -} -- | Message flags. To combine flags, use '(<>)'. newtype MsgFlag = MsgFlag { fromMsgFlag :: CInt } deriving (Show, Eq, Ord, Num, Bits) instance Sem.Semigroup MsgFlag where (<>) = (.|.) instance Monoid MsgFlag where mempty = MsgFlag 0 #if !(MIN_VERSION_base(4,11,0)) mappend = (Sem.<>) #endif -- | Send or receive OOB(out-of-bound) data. pattern MSG_OOB :: MsgFlag #ifdef MSG_OOB pattern MSG_OOB = MsgFlag (#const MSG_OOB) #else pattern MSG_OOB = MsgFlag 0 #endif -- | Bypass routing table lookup. pattern MSG_DONTROUTE :: MsgFlag #ifdef MSG_DONTROUTE pattern MSG_DONTROUTE = MsgFlag (#const MSG_DONTROUTE) #else pattern MSG_DONTROUTE = MsgFlag 0 #endif -- | Peek at incoming message without removing it from the queue. pattern MSG_PEEK :: MsgFlag #ifdef MSG_PEEK pattern MSG_PEEK = MsgFlag (#const MSG_PEEK) #else pattern MSG_PEEK = MsgFlag 0 #endif -- | End of record. pattern MSG_EOR :: MsgFlag #ifdef MSG_EOR pattern MSG_EOR = MsgFlag (#const MSG_EOR) #else pattern MSG_EOR = MsgFlag 0 #endif -- | Received data is truncated. More data exist. pattern MSG_TRUNC :: MsgFlag #ifdef MSG_TRUNC pattern MSG_TRUNC = MsgFlag (#const MSG_TRUNC) #else pattern MSG_TRUNC = MsgFlag 0 #endif -- | Received control message is truncated. More control message exist. pattern MSG_CTRUNC :: MsgFlag #ifdef MSG_CTRUNC pattern MSG_CTRUNC = MsgFlag (#const MSG_CTRUNC) #else pattern MSG_CTRUNC = MsgFlag 0 #endif -- | Wait until the requested number of bytes have been read. pattern MSG_WAITALL :: MsgFlag #ifdef MSG_WAITALL pattern MSG_WAITALL = MsgFlag (#const MSG_WAITALL) #else pattern MSG_WAITALL = MsgFlag 0 #endif {- msgFlagPairs :: [Pair MsgFlag String] msgFlagPairs = [ (MSG_OOB, "MSG_OOB") , (MSG_DONTROUTE, "MSG_DONTROUTE") , (MSG_PEEK, "MSG_PEEK") , (MSG_EOR, "MSG_EOR") , (MSG_TRUNC, "MSG_TRUNC") , (MSG_CTRUNC, "MSG_CTRUNC") , (MSG_WAITALL, "MSG_WAITALL") ] -} network-3.1.4.0/Network/Socket/Handle.hs0000644000000000000000000000234607346545000016154 0ustar0000000000000000module Network.Socket.Handle where import qualified GHC.IO.Device (IODeviceType(Stream)) import GHC.IO.Handle.FD (fdToHandle') import System.IO (IOMode(..), Handle, BufferMode(..), hSetBuffering) import Network.Socket.Types -- | Turns a Socket into an 'Handle'. By default, the new handle is -- unbuffered. Use 'System.IO.hSetBuffering' to change the buffering. -- -- Note that since a 'Handle' is automatically closed by a finalizer -- when it is no longer referenced, you should avoid doing any more -- operations on the 'Socket' after calling 'socketToHandle'. To -- close the 'Socket' after 'socketToHandle', call 'System.IO.hClose' -- on the 'Handle'. -- -- Caveat 'Handle' is not recommended for network programming in -- Haskell, e.g. merely performing 'hClose' on a TCP socket won't -- cooperate with peer's 'gracefulClose', i.e. proper shutdown -- sequence with appropriate handshakes specified by the protocol. socketToHandle :: Socket -> IOMode -> IO Handle socketToHandle s mode = invalidateSocket s err $ \oldfd -> do h <- fdToHandle' oldfd (Just GHC.IO.Device.Stream) True (show s) mode True{-bin-} hSetBuffering h NoBuffering return h where err _ = ioError $ userError $ "socketToHandle: socket is no longer valid" network-3.1.4.0/Network/Socket/If.hs0000644000000000000000000000202107346545000015305 0ustar0000000000000000{-# LANGUAGE CPP #-} #include "HsNetDef.h" module Network.Socket.If ( ifNameToIndex , ifIndexToName ) where import Foreign.Marshal.Alloc (allocaBytes) import Network.Socket.Imports -- | Returns the index corresponding to the interface name. -- -- Since 2.7.0.0. ifNameToIndex :: String -> IO (Maybe Int) ifNameToIndex ifname = do index <- withCString ifname c_if_nametoindex -- On failure zero is returned. We'll return Nothing. return $ if index == 0 then Nothing else Just $ fromIntegral index -- | Returns the interface name corresponding to the index. -- -- Since 2.7.0.0. ifIndexToName :: Int -> IO (Maybe String) ifIndexToName ifn = allocaBytes 16 $ \ptr -> do -- 16 == IFNAMSIZ r <- c_if_indextoname (fromIntegral ifn) ptr if r == nullPtr then return Nothing else Just <$> peekCString ptr foreign import CALLCONV safe "if_nametoindex" c_if_nametoindex :: CString -> IO CUInt foreign import CALLCONV safe "if_indextoname" c_if_indextoname :: CUInt -> CString -> IO CString network-3.1.4.0/Network/Socket/Imports.hs0000644000000000000000000000120507346545000016407 0ustar0000000000000000module Network.Socket.Imports ( module Control.Applicative , module Control.Monad , module Data.Bits , module Data.Int , module Data.List , module Data.Maybe , module Data.Monoid , module Data.Ord , module Data.Word , module Foreign.C.String , module Foreign.C.Types , module Foreign.Ptr , module Foreign.Storable , module Numeric ) where import Control.Applicative import Control.Monad import Data.Bits import Data.Int import Data.List import Data.Maybe import Data.Monoid import Data.Ord import Data.Word import Foreign.C.String import Foreign.C.Types import Foreign.Ptr import Foreign.Storable import Numeric network-3.1.4.0/Network/Socket/Info.hsc0000644000000000000000000004312507346545000016017 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE RecordWildCards #-} {-# OPTIONS_GHC -fno-warn-orphans #-} #include "HsNet.h" ##include "HsNetDef.h" module Network.Socket.Info where import Foreign.Marshal.Alloc (alloca, allocaBytes) import Foreign.Marshal.Utils (maybeWith, with) import GHC.IO.Exception (IOErrorType(NoSuchThing)) import System.IO.Error (ioeSetErrorString, mkIOError) import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Syscall import Network.Socket.Types ----------------------------------------------------------------------------- -- | Either a host name e.g., @\"haskell.org\"@ or a numeric host -- address string consisting of a dotted decimal IPv4 address or an -- IPv6 address e.g., @\"192.168.0.1\"@. type HostName = String -- | Either a service name e.g., @\"http\"@ or a numeric port number. type ServiceName = String ----------------------------------------------------------------------------- -- Address and service lookups -- | Flags that control the querying behaviour of 'getAddrInfo'. -- For more information, see data AddrInfoFlag = -- | The list of returned 'AddrInfo' values will -- only contain IPv4 addresses if the local system has at least -- one IPv4 interface configured, and likewise for IPv6. -- (Only some platforms support this.) AI_ADDRCONFIG -- | If 'AI_ALL' is specified, return all matching IPv6 and -- IPv4 addresses. Otherwise, this flag has no effect. -- (Only some platforms support this.) | AI_ALL -- | The 'addrCanonName' field of the first returned -- 'AddrInfo' will contain the "canonical name" of the host. | AI_CANONNAME -- | The 'HostName' argument /must/ be a numeric -- address in string form, and network name lookups will not be -- attempted. | AI_NUMERICHOST -- | The 'ServiceName' argument /must/ be a port -- number in string form, and service name lookups will not be -- attempted. (Only some platforms support this.) | AI_NUMERICSERV -- | If no 'HostName' value is provided, the network -- address in each 'SockAddr' -- will be left as a "wild card". -- This is useful for server applications that -- will accept connections from any client. | AI_PASSIVE -- | If an IPv6 lookup is performed, and no IPv6 -- addresses are found, IPv6-mapped IPv4 addresses will be -- returned. (Only some platforms support this.) | AI_V4MAPPED deriving (Eq, Read, Show) aiFlagMapping :: [(AddrInfoFlag, CInt)] aiFlagMapping = [ #if HAVE_DECL_AI_ADDRCONFIG (AI_ADDRCONFIG, #const AI_ADDRCONFIG), #else (AI_ADDRCONFIG, 0), #endif #if HAVE_DECL_AI_ALL (AI_ALL, #const AI_ALL), #else (AI_ALL, 0), #endif (AI_CANONNAME, #const AI_CANONNAME), (AI_NUMERICHOST, #const AI_NUMERICHOST), #if HAVE_DECL_AI_NUMERICSERV (AI_NUMERICSERV, #const AI_NUMERICSERV), #else (AI_NUMERICSERV, 0), #endif (AI_PASSIVE, #const AI_PASSIVE), #if HAVE_DECL_AI_V4MAPPED (AI_V4MAPPED, #const AI_V4MAPPED) #else (AI_V4MAPPED, 0) #endif ] -- | Indicate whether the given 'AddrInfoFlag' will have any effect on -- this system. addrInfoFlagImplemented :: AddrInfoFlag -> Bool addrInfoFlagImplemented f = packBits aiFlagMapping [f] /= 0 data AddrInfo = AddrInfo { addrFlags :: [AddrInfoFlag] , addrFamily :: Family , addrSocketType :: SocketType , addrProtocol :: ProtocolNumber , addrAddress :: SockAddr , addrCanonName :: Maybe String } deriving (Eq, Show) instance Storable AddrInfo where sizeOf _ = #const sizeof(struct addrinfo) alignment _ = alignment (0 :: CInt) peek p = do ai_flags <- (#peek struct addrinfo, ai_flags) p ai_family <- (#peek struct addrinfo, ai_family) p ai_socktype <- (#peek struct addrinfo, ai_socktype) p ai_protocol <- (#peek struct addrinfo, ai_protocol) p ai_addr <- (#peek struct addrinfo, ai_addr) p >>= peekSockAddr ai_canonname_ptr <- (#peek struct addrinfo, ai_canonname) p ai_canonname <- if ai_canonname_ptr == nullPtr then return Nothing else Just <$> peekCString ai_canonname_ptr return $ AddrInfo { addrFlags = unpackBits aiFlagMapping ai_flags , addrFamily = unpackFamily ai_family , addrSocketType = unpackSocketType ai_socktype , addrProtocol = ai_protocol , addrAddress = ai_addr , addrCanonName = ai_canonname } poke p (AddrInfo flags family sockType protocol _ _) = do let c_stype = packSocketType sockType (#poke struct addrinfo, ai_flags) p (packBits aiFlagMapping flags) (#poke struct addrinfo, ai_family) p (packFamily family) (#poke struct addrinfo, ai_socktype) p c_stype (#poke struct addrinfo, ai_protocol) p protocol -- stuff below is probably not needed, but let's zero it for safety (#poke struct addrinfo, ai_addrlen) p (0::CSize) (#poke struct addrinfo, ai_addr) p nullPtr (#poke struct addrinfo, ai_canonname) p nullPtr (#poke struct addrinfo, ai_next) p nullPtr -- | Flags that control the querying behaviour of 'getNameInfo'. -- For more information, see data NameInfoFlag = -- | Resolve a datagram-based service name. This is -- required only for the few protocols that have different port -- numbers for their datagram-based versions than for their -- stream-based versions. NI_DGRAM -- | If the hostname cannot be looked up, an IO error is thrown. | NI_NAMEREQD -- | If a host is local, return only the hostname part of the FQDN. | NI_NOFQDN -- | The name of the host is not looked up. -- Instead, a numeric representation of the host's -- address is returned. For an IPv4 address, this will be a -- dotted-quad string. For IPv6, it will be colon-separated -- hexadecimal. | NI_NUMERICHOST -- | The name of the service is not -- looked up. Instead, a numeric representation of the -- service is returned. | NI_NUMERICSERV deriving (Eq, Read, Show) niFlagMapping :: [(NameInfoFlag, CInt)] niFlagMapping = [(NI_DGRAM, #const NI_DGRAM), (NI_NAMEREQD, #const NI_NAMEREQD), (NI_NOFQDN, #const NI_NOFQDN), (NI_NUMERICHOST, #const NI_NUMERICHOST), (NI_NUMERICSERV, #const NI_NUMERICSERV)] -- | Default hints for address lookup with 'getAddrInfo'. -- -- >>> addrFlags defaultHints -- [] -- >>> addrFamily defaultHints -- AF_UNSPEC -- >>> addrSocketType defaultHints -- NoSocketType -- >>> addrProtocol defaultHints -- 0 defaultHints :: AddrInfo defaultHints = AddrInfo { addrFlags = [] , addrFamily = AF_UNSPEC , addrSocketType = NoSocketType , addrProtocol = defaultProtocol , addrAddress = SockAddrInet 0 0 , addrCanonName = Nothing } ----------------------------------------------------------------------------- -- | Resolve a host or service name to one or more addresses. -- The 'AddrInfo' values that this function returns contain 'SockAddr' -- values that you can pass directly to 'connect' or -- 'bind'. -- -- This function is protocol independent. It can return both IPv4 and -- IPv6 address information. -- -- The 'AddrInfo' argument specifies the preferred query behaviour, -- socket options, or protocol. You can override these conveniently -- using Haskell's record update syntax on 'defaultHints', for example -- as follows: -- -- >>> let hints = defaultHints { addrFlags = [AI_NUMERICHOST], addrSocketType = Stream } -- -- You must provide a 'Just' value for at least one of the 'HostName' -- or 'ServiceName' arguments. 'HostName' can be either a numeric -- network address (dotted quad for IPv4, colon-separated hex for -- IPv6) or a hostname. In the latter case, its addresses will be -- looked up unless 'AI_NUMERICHOST' is specified as a hint. If you -- do not provide a 'HostName' value /and/ do not set 'AI_PASSIVE' as -- a hint, network addresses in the result will contain the address of -- the loopback interface. -- -- If the query fails, this function throws an IO exception instead of -- returning an empty list. Otherwise, it returns a non-empty list -- of 'AddrInfo' values. -- -- There are several reasons why a query might result in several -- values. For example, the queried-for host could be multihomed, or -- the service might be available via several protocols. -- -- Note: the order of arguments is slightly different to that defined -- for @getaddrinfo@ in RFC 2553. The 'AddrInfo' parameter comes first -- to make partial application easier. -- -- >>> addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.1") (Just "http") -- >>> addrAddress addr -- 127.0.0.1:80 getAddrInfo :: Maybe AddrInfo -- ^ preferred socket type or protocol -> Maybe HostName -- ^ host name to look up -> Maybe ServiceName -- ^ service name to look up -> IO [AddrInfo] -- ^ resolved addresses, with "best" first getAddrInfo hints node service = alloc getaddrinfo where alloc body = withSocketsDo $ maybeWith withCString node $ \c_node -> maybeWith withCString service $ \c_service -> maybeWith with filteredHints $ \c_hints -> alloca $ \ptr_ptr_addrs -> body c_node c_service c_hints ptr_ptr_addrs getaddrinfo c_node c_service c_hints ptr_ptr_addrs = do ret <- c_getaddrinfo c_node c_service c_hints ptr_ptr_addrs if ret == 0 then do ptr_addrs <- peek ptr_ptr_addrs ais <- followAddrInfo ptr_addrs c_freeaddrinfo ptr_addrs -- POSIX requires that getaddrinfo(3) returns at least one addrinfo. -- See: http://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html case ais of [] -> ioError $ mkIOError NoSuchThing message Nothing Nothing _ -> return ais else do err <- gai_strerror ret ioError $ ioeSetErrorString (mkIOError NoSuchThing message Nothing Nothing) err message = concat [ "Network.Socket.getAddrInfo (called with preferred socket type/protocol: " , maybe "Nothing" show hints , ", host name: " , show node , ", service name: " , show service , ")" ] #if defined(darwin_HOST_OS) -- Leaving out the service and using AI_NUMERICSERV causes a -- segfault on OS X 10.8.2. This code removes AI_NUMERICSERV -- (which has no effect) in that case. toHints h = h { addrFlags = delete AI_NUMERICSERV (addrFlags h) } filteredHints = case service of Nothing -> toHints <$> hints _ -> hints #else filteredHints = hints #endif followAddrInfo :: Ptr AddrInfo -> IO [AddrInfo] followAddrInfo ptr_ai | ptr_ai == nullPtr = return [] | otherwise = do a <- peek ptr_ai as <- (# peek struct addrinfo, ai_next) ptr_ai >>= followAddrInfo return (a : as) foreign import ccall safe "hsnet_getaddrinfo" c_getaddrinfo :: CString -> CString -> Ptr AddrInfo -> Ptr (Ptr AddrInfo) -> IO CInt foreign import ccall safe "hsnet_freeaddrinfo" c_freeaddrinfo :: Ptr AddrInfo -> IO () gai_strerror :: CInt -> IO String #ifdef HAVE_GAI_STRERROR gai_strerror n = c_gai_strerror n >>= peekCString foreign import ccall safe "gai_strerror" c_gai_strerror :: CInt -> IO CString #else gai_strerror n = ioError $ userError $ "Network.Socket.gai_strerror not supported: " ++ show n #endif ----------------------------------------------------------------------------- withCStringIf :: Bool -> Int -> (CSize -> CString -> IO a) -> IO a withCStringIf False _ f = f 0 nullPtr withCStringIf True n f = allocaBytes n (f (fromIntegral n)) -- | Resolve an address to a host or service name. -- This function is protocol independent. -- The list of 'NameInfoFlag' values controls query behaviour. -- -- If a host or service's name cannot be looked up, then the numeric -- form of the address or service will be returned. -- -- If the query fails, this function throws an IO exception. -- -- >>> addr:_ <- getAddrInfo (Just defaultHints) (Just "127.0.0.1") (Just "http") -- >>> getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True $ addrAddress addr -- (Just "127.0.0.1",Just "80") {- -- >>> getNameInfo [] True True $ addrAddress addr -- (Just "localhost",Just "http") -} getNameInfo :: [NameInfoFlag] -- ^ flags to control lookup behaviour -> Bool -- ^ whether to look up a hostname -> Bool -- ^ whether to look up a service name -> SockAddr -- ^ the address to look up -> IO (Maybe HostName, Maybe ServiceName) getNameInfo flags doHost doService addr = alloc getnameinfo where alloc body = withSocketsDo $ withCStringIf doHost (# const NI_MAXHOST) $ \c_hostlen c_host -> withCStringIf doService (# const NI_MAXSERV) $ \c_servlen c_serv -> withSockAddr addr $ \ptr_addr sz -> body c_hostlen c_host c_servlen c_serv ptr_addr sz getnameinfo c_hostlen c_host c_servlen c_serv ptr_addr sz = do ret <- c_getnameinfo ptr_addr (fromIntegral sz) c_host c_hostlen c_serv c_servlen (packBits niFlagMapping flags) if ret == 0 then do let peekIf doIf c_val = if doIf then Just <$> peekCString c_val else return Nothing host <- peekIf doHost c_host serv <- peekIf doService c_serv return (host, serv) else do err <- gai_strerror ret ioError $ ioeSetErrorString (mkIOError NoSuchThing message Nothing Nothing) err message = concat [ "Network.Socket.getNameInfo (called with flags: " , show flags , ", hostname lookup: " , show doHost , ", service name lookup: " , show doService , ", socket address: " , show addr , ")" ] foreign import ccall safe "hsnet_getnameinfo" c_getnameinfo :: Ptr SockAddr -> CInt{-CSockLen???-} -> CString -> CSize -> CString -> CSize -> CInt -> IO CInt -- | Pack a list of values into a bitmask. The possible mappings from -- value to bit-to-set are given as the first argument. We assume -- that each value can cause exactly one bit to be set; unpackBits will -- break if this property is not true. ----------------------------------------------------------------------------- packBits :: (Eq a, Num b, Bits b) => [(a, b)] -> [a] -> b packBits mapping xs = foldl' pack 0 mapping where pack acc (k, v) | k `elem` xs = acc .|. v | otherwise = acc -- | Unpack a bitmask into a list of values. unpackBits :: (Num b, Bits b) => [(a, b)] -> b -> [a] -- Be permissive and ignore unknown bit values. At least on OS X, -- getaddrinfo returns an ai_flags field with bits set that have no -- entry in . unpackBits [] _ = [] unpackBits ((k,v):xs) r | r .&. v /= 0 = k : unpackBits xs (r .&. complement v) | otherwise = unpackBits xs r ----------------------------------------------------------------------------- -- SockAddr instance Show SockAddr where showsPrec _ (SockAddrUnix str) = showString str showsPrec _ (SockAddrInet port ha) = showHostAddress ha . showString ":" . shows port showsPrec _ (SockAddrInet6 port _ ha6 _) = showChar '[' . showHostAddress6 ha6 . showString "]:" . shows port -- Taken from on the implementation of showIPv4 in Data.IP.Addr showHostAddress :: HostAddress -> ShowS showHostAddress ip = let (u3, u2, u1, u0) = hostAddressToTuple ip in foldr1 (.) . intersperse (showChar '.') $ map showInt [u3, u2, u1, u0] -- Taken from showIPv6 in Data.IP.Addr. -- | Show an IPv6 address in the most appropriate notation, based on recommended -- representation proposed by . -- -- /The implementation is completely compatible with the current implementation -- of the `inet_ntop` function in glibc./ showHostAddress6 :: HostAddress6 -> ShowS showHostAddress6 ha6@(a1, a2, a3, a4) -- IPv4-Mapped IPv6 Address | a1 == 0 && a2 == 0 && a3 == 0xffff = showString "::ffff:" . showHostAddress a4 -- IPv4-Compatible IPv6 Address (exclude IPRange ::/112) | a1 == 0 && a2 == 0 && a3 == 0 && a4 >= 0x10000 = showString "::" . showHostAddress a4 -- length of longest run > 1, replace it with "::" | end - begin > 1 = showFields prefix . showString "::" . showFields suffix | otherwise = showFields fields where fields = let (u7, u6, u5, u4, u3, u2, u1, u0) = hostAddress6ToTuple ha6 in [u7, u6, u5, u4, u3, u2, u1, u0] showFields = foldr (.) id . intersperse (showChar ':') . map showHex prefix = take begin fields -- fields before "::" suffix = drop end fields -- fields after "::" begin = end + diff -- the longest run of zeros (diff, end) = minimum $ scanl (\c i -> if i == 0 then c - 1 else 0) 0 fields `zip` [0..] ----------------------------------------------------------------------------- -- | A utility function to open a socket with `AddrInfo`. -- This is a just wrapper for the following code: -- -- > \addr -> socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) openSocket :: AddrInfo -> IO Socket openSocket addr = socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) network-3.1.4.0/Network/Socket/Internal.hs0000644000000000000000000002354207346545000016536 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} #include "HsNetDef.h" ----------------------------------------------------------------------------- -- | -- Module : Network.Socket.Internal -- Copyright : (c) The University of Glasgow 2001 -- License : BSD-style (see the file libraries/network/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : provisional -- Portability : portable -- -- A module containing semi-public "Network.Socket" internals. -- Modules which extend the "Network.Socket" module will need to use -- this module while ideally most users will be able to make do with -- the public interface. -- ----------------------------------------------------------------------------- module Network.Socket.Internal ( -- * Socket error functions throwSocketError , throwSocketErrorCode #if defined(mingw32_HOST_OS) , c_getLastError #endif -- * Guards for socket operations that may fail , throwSocketErrorIfMinus1_ , throwSocketErrorIfMinus1Retry , throwSocketErrorIfMinus1Retry_ , throwSocketErrorIfMinus1RetryMayBlock #if defined(mingw32_HOST_OS) , throwSocketErrorIfMinus1ButRetry #endif -- ** Guards that wait and retry if the operation would block -- | These guards are based on 'throwSocketErrorIfMinus1RetryMayBlock'. -- They wait for socket readiness if the action fails with @EWOULDBLOCK@ -- or similar. , throwSocketErrorWaitRead , throwSocketErrorWaitReadBut , throwSocketErrorWaitWrite -- * Initialization , withSocketsDo -- * Low-level helpers , zeroMemory ) where import GHC.Conc (threadWaitRead, threadWaitWrite) #if defined(mingw32_HOST_OS) import Control.Exception (evaluate) import System.IO.Unsafe (unsafePerformIO) # if __GLASGOW_HASKELL__ >= 707 import GHC.IO.Exception (IOErrorType(..)) # else import GHC.IOBase (IOErrorType(..)) # endif import System.IO.Error (ioeSetErrorString, mkIOError) #else import Foreign.C.Error (throwErrno, throwErrnoIfMinus1Retry, throwErrnoIfMinus1RetryMayBlock, throwErrnoIfMinus1_, Errno(..), errnoToIOError) #endif #if defined(mingw32_HOST_OS) import Network.Socket.Cbits #endif import Network.Socket.Imports import Network.Socket.Types -- --------------------------------------------------------------------- -- Guards for socket operations that may fail -- | Throw an 'IOError' corresponding to the current socket error. throwSocketError :: String -- ^ textual description of the error location -> IO a -- | Like 'throwSocketError', but the error code is supplied as an argument. -- -- On Windows, do not use errno. Use a system error code instead. throwSocketErrorCode :: String -> CInt -> IO a -- | Throw an 'IOError' corresponding to the current socket error if -- the IO action returns a result of @-1@. Discards the result of the -- IO action after error handling. throwSocketErrorIfMinus1_ :: (Eq a, Num a) => String -- ^ textual description of the location -> IO a -- ^ the 'IO' operation to be executed -> IO () {-# SPECIALIZE throwSocketErrorIfMinus1_ :: String -> IO CInt -> IO () #-} -- | Throw an 'IOError' corresponding to the current socket error if -- the IO action returns a result of @-1@, but retries in case of an -- interrupted operation. throwSocketErrorIfMinus1Retry :: (Eq a, Num a) => String -- ^ textual description of the location -> IO a -- ^ the 'IO' operation to be executed -> IO a {-# SPECIALIZE throwSocketErrorIfMinus1Retry :: String -> IO CInt -> IO CInt #-} -- | Throw an 'IOError' corresponding to the current socket error if -- the IO action returns a result of @-1@, but retries in case of an -- interrupted operation. Discards the result of the IO action after -- error handling. throwSocketErrorIfMinus1Retry_ :: (Eq a, Num a) => String -- ^ textual description of the location -> IO a -- ^ the 'IO' operation to be executed -> IO () throwSocketErrorIfMinus1Retry_ loc m = void $ throwSocketErrorIfMinus1Retry loc m {-# SPECIALIZE throwSocketErrorIfMinus1Retry_ :: String -> IO CInt -> IO () #-} -- | Throw an 'IOError' corresponding to the current socket error if -- the IO action returns a result of @-1@, but retries in case of an -- interrupted operation. Checks for operations that would block and -- executes an alternative action before retrying in that case. throwSocketErrorIfMinus1RetryMayBlock :: (Eq a, Num a) => String -- ^ textual description of the location -> IO b -- ^ action to execute before retrying if an -- immediate retry would block -> IO a -- ^ the 'IO' operation to be executed -> IO a {-# SPECIALIZE throwSocketErrorIfMinus1RetryMayBlock :: String -> IO b -> IO CInt -> IO CInt #-} -- | Throw an 'IOError' corresponding to the current socket error if -- the IO action returns a result of @-1@, but retries in case of an -- interrupted operation. Checks for operations that would block and -- executes an alternative action before retrying in that case. If the error -- is one handled by the exempt filter then ignore it and return the error code. throwSocketErrorIfMinus1RetryMayBlockBut :: (Eq a, Num a) => (CInt -> Bool) -- ^ exception exempt filter -> String -- ^ textual description of the location -> IO b -- ^ action to execute before retrying if an -- immediate retry would block -> IO a -- ^ the 'IO' operation to be executed -> IO a {-# SPECIALIZE throwSocketErrorIfMinus1RetryMayBlock :: String -> IO b -> IO CInt -> IO CInt #-} #if defined(mingw32_HOST_OS) throwSocketErrorIfMinus1RetryMayBlock name _ act = throwSocketErrorIfMinus1Retry name act throwSocketErrorIfMinus1RetryMayBlockBut exempt name _ act = throwSocketErrorIfMinus1ButRetry exempt name act throwSocketErrorIfMinus1_ name act = do _ <- throwSocketErrorIfMinus1Retry name act return () throwSocketErrorIfMinus1ButRetry :: (Eq a, Num a) => (CInt -> Bool) -> String -> IO a -> IO a throwSocketErrorIfMinus1ButRetry exempt name act = do r <- act if (r == -1) then do rc <- c_getLastError if rc == wsaNotInitialized then do withSocketsDo (return ()) r' <- act if (r' == -1) then throwSocketError name else return r' else if (exempt rc) then return r else throwSocketError name else return r throwSocketErrorIfMinus1Retry = throwSocketErrorIfMinus1ButRetry (const False) throwSocketErrorCode name rc = do pstr <- c_getWSError rc str <- peekCString pstr ioError (ioeSetErrorString (mkIOError OtherError name Nothing Nothing) str) throwSocketError name = c_getLastError >>= throwSocketErrorCode name foreign import CALLCONV unsafe "WSAGetLastError" c_getLastError :: IO CInt foreign import ccall unsafe "getWSErrorDescr" c_getWSError :: CInt -> IO (Ptr CChar) #else throwSocketErrorIfMinus1RetryMayBlock name on_block act = throwErrnoIfMinus1RetryMayBlock name act on_block throwSocketErrorIfMinus1RetryMayBlockBut _exempt name on_block act = throwErrnoIfMinus1RetryMayBlock name act on_block throwSocketErrorIfMinus1Retry = throwErrnoIfMinus1Retry throwSocketErrorIfMinus1_ = throwErrnoIfMinus1_ throwSocketError = throwErrno throwSocketErrorCode loc errno = ioError (errnoToIOError loc (Errno errno) Nothing Nothing) #endif -- | Like 'throwSocketErrorIfMinus1Retry', but if the action fails with -- @EWOULDBLOCK@ or similar, wait for the socket to be read-ready, -- and try again. throwSocketErrorWaitRead :: (Eq a, Num a) => Socket -> String -> IO a -> IO a throwSocketErrorWaitRead s name io = withFdSocket s $ \fd -> throwSocketErrorIfMinus1RetryMayBlock name (threadWaitRead $ fromIntegral fd) io -- | Like 'throwSocketErrorIfMinus1Retry', but if the action fails with -- @EWOULDBLOCK@ or similar, wait for the socket to be read-ready, -- and try again. If it fails with the error the user was expecting then -- ignore the error throwSocketErrorWaitReadBut :: (Eq a, Num a) => (CInt -> Bool) -> Socket -> String -> IO a -> IO a throwSocketErrorWaitReadBut exempt s name io = withFdSocket s $ \fd -> throwSocketErrorIfMinus1RetryMayBlockBut exempt name (threadWaitRead $ fromIntegral fd) io -- | Like 'throwSocketErrorIfMinus1Retry', but if the action fails with -- @EWOULDBLOCK@ or similar, wait for the socket to be write-ready, -- and try again. throwSocketErrorWaitWrite :: (Eq a, Num a) => Socket -> String -> IO a -> IO a throwSocketErrorWaitWrite s name io = withFdSocket s $ \fd -> throwSocketErrorIfMinus1RetryMayBlock name (threadWaitWrite $ fromIntegral fd) io -- --------------------------------------------------------------------------- -- WinSock support {-| With older versions of the @network@ library (version 2.6.0.2 or earlier) on Windows operating systems, the networking subsystem must be initialised using 'withSocketsDo' before any networking operations can be used. eg. > main = withSocketsDo $ do {...} It is fine to nest calls to 'withSocketsDo', and to perform networking operations after 'withSocketsDo' has returned. 'withSocketsDo' is not necessary for the current network library. However, for compatibility with older versions on Windows, it is good practice to always call 'withSocketsDo' (it's very cheap). -} {-# INLINE withSocketsDo #-} withSocketsDo :: IO a -> IO a #if defined(mingw32_HOST_OS) withSocketsDo act = evaluate withSocketsInit >> act {-# NOINLINE withSocketsInit #-} withSocketsInit :: () -- Use a CAF to make forcing it do initialisation once, but subsequent forces will be cheap withSocketsInit = unsafePerformIO $ do x <- initWinSock when (x /= 0) $ ioError $ userError "Network.Socket.Internal.withSocketsDo: Failed to initialise WinSock" foreign import ccall unsafe "initWinSock" initWinSock :: IO Int #else withSocketsDo x = x #endif network-3.1.4.0/Network/Socket/Name.hs0000644000000000000000000000450707346545000015642 0ustar0000000000000000{-# LANGUAGE CPP #-} #include "HsNetDef.h" module Network.Socket.Name ( getPeerName , getSocketName , socketPort , socketPortSafe ) where import Foreign.Marshal.Utils (with) import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Types -- | Getting peer's socket address. getPeerName :: SocketAddress sa => Socket -> IO sa getPeerName s = withNewSocketAddress $ \ptr sz -> with (fromIntegral sz) $ \int_star -> withFdSocket s $ \fd -> do throwSocketErrorIfMinus1Retry_ "Network.Socket.getPeerName" $ c_getpeername fd ptr int_star _sz <- peek int_star peekSocketAddress ptr -- | Getting my socket address. getSocketName :: SocketAddress sa => Socket -> IO sa getSocketName s = withNewSocketAddress $ \ptr sz -> with (fromIntegral sz) $ \int_star -> withFdSocket s $ \fd -> do throwSocketErrorIfMinus1Retry_ "Network.Socket.getSocketName" $ c_getsockname fd ptr int_star peekSocketAddress ptr foreign import CALLCONV unsafe "getpeername" c_getpeername :: CInt -> Ptr sa -> Ptr CInt -> IO CInt foreign import CALLCONV unsafe "getsockname" c_getsockname :: CInt -> Ptr sa -> Ptr CInt -> IO CInt -- --------------------------------------------------------------------------- -- socketPort -- -- The port number the given socket is currently connected to can be -- determined by calling $port$, is generally only useful when bind -- was given $aNY\_PORT$. -- | Getting the port of socket. -- `IOError` is thrown if a port is not available. socketPort :: Socket -- Connected & Bound Socket -> IO PortNumber -- Port Number of Socket socketPort s = do sa <- getSocketName s case sa of SockAddrInet port _ -> return port SockAddrInet6 port _ _ _ -> return port _ -> ioError $ userError "Network.Socket.socketPort: AF_UNIX not supported." -- --------------------------------------------------------------------------- -- socketPortSafe -- | Getting the port of socket. socketPortSafe :: Socket -- Connected & Bound Socket -> IO (Maybe PortNumber) -- Port Number of Socket socketPortSafe s = do sa <- getSocketName s return $ case sa of SockAddrInet port _ -> Just port SockAddrInet6 port _ _ _ -> Just port _ -> Nothing network-3.1.4.0/Network/Socket/Options.hsc0000644000000000000000000003740107346545000016557 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ViewPatterns #-} #include "HsNet.h" ##include "HsNetDef.h" module Network.Socket.Options ( SocketOption(SockOpt ,UnsupportedSocketOption ,AcceptConn,Debug,ReuseAddr,SoDomain,Type,SoProtocol,SoError ,DontRoute,Broadcast,SendBuffer,RecvBuffer,KeepAlive,OOBInline ,TimeToLive,MaxSegment,NoDelay,Cork,Linger,ReusePort ,RecvLowWater,SendLowWater,RecvTimeOut,SendTimeOut ,UseLoopBack,UserTimeout,IPv6Only ,RecvIPv4TTL,RecvIPv4TOS,RecvIPv4PktInfo ,RecvIPv6HopLimit,RecvIPv6TClass,RecvIPv6PktInfo ,CustomSockOpt) , isSupportedSocketOption , whenSupported , getSocketType , getSocketOption , setSocketOption , getSockOpt , setSockOpt , StructLinger (..) , SocketTimeout (..) ) where import qualified Text.Read as P import Foreign.Marshal.Alloc (alloca) import Foreign.Marshal.Utils (with) import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Types import Network.Socket.ReadShow #include ---------------------------------------------------------------- -- Socket Properties -- | Socket options for use with 'setSocketOption' and 'getSocketOption'. -- -- The existence of a constructor does not imply that the relevant option -- is supported on your system: see 'isSupportedSocketOption' data SocketOption = SockOpt #if __GLASGOW_HASKELL__ >= 806 !CInt -- ^ Option Level !CInt -- ^ Option Name #else !CInt -- Option Level !CInt -- Option Name #endif deriving (Eq) ---------------------------------------------------------------- socketOptionBijection :: Bijection SocketOption String socketOptionBijection = [ (UnsupportedSocketOption, "UnsupportedSocketOption") , (Debug, "Debug") , (ReuseAddr, "ReuseAddr") , (SoDomain, "SoDomain") , (Type, "Type") , (SoProtocol, "SoProtocol") , (SoError, "SoError") , (DontRoute, "DontRoute") , (Broadcast, "Broadcast") , (SendBuffer, "SendBuffer") , (RecvBuffer, "RecvBuffer") , (KeepAlive, "KeepAlive") , (OOBInline, "OOBInline") , (Linger, "Linger") , (ReusePort, "ReusePort") , (RecvLowWater, "RecvLowWater") , (SendLowWater, "SendLowWater") , (RecvTimeOut, "RecvTimeOut") , (SendTimeOut, "SendTimeOut") , (UseLoopBack, "UseLoopBack") , (MaxSegment, "MaxSegment") , (NoDelay, "NoDelay") , (UserTimeout, "UserTimeout") , (Cork, "Cork") , (TimeToLive, "TimeToLive") , (RecvIPv4TTL, "RecvIPv4TTL") , (RecvIPv4TOS, "RecvIPv4TOS") , (RecvIPv4PktInfo, "RecvIPv4PktInfo") , (IPv6Only, "IPv6Only") , (RecvIPv6HopLimit, "RecvIPv6HopLimit") , (RecvIPv6TClass, "RecvIPv6TClass") , (RecvIPv6PktInfo, "RecvIPv6PktInfo") ] instance Show SocketOption where showsPrec = bijectiveShow socketOptionBijection def where defname = "SockOpt" unwrap = \(CustomSockOpt nm) -> nm def = defShow defname unwrap showIntInt instance Read SocketOption where readPrec = bijectiveRead socketOptionBijection def where defname = "SockOpt" def = defRead defname CustomSockOpt readIntInt ---------------------------------------------------------------- pattern UnsupportedSocketOption :: SocketOption pattern UnsupportedSocketOption = SockOpt (-1) (-1) -- | Does the 'SocketOption' exist on this system? isSupportedSocketOption :: SocketOption -> Bool isSupportedSocketOption opt = opt /= SockOpt (-1) (-1) -- | Execute the given action only when the specified socket option is -- supported. Any return value is ignored. whenSupported :: SocketOption -> IO a -> IO () whenSupported s action | isSupportedSocketOption s = action >> return () | otherwise = return () ---------------------------------------------------------------- #ifdef SOL_SOCKET -- | SO_ACCEPTCONN, read-only pattern AcceptConn :: SocketOption #ifdef SO_ACCEPTCONN pattern AcceptConn = SockOpt (#const SOL_SOCKET) (#const SO_ACCEPTCONN) #else pattern AcceptConn = SockOpt (-1) (-1) #endif -- | SO_DEBUG pattern Debug :: SocketOption #ifdef SO_DEBUG pattern Debug = SockOpt (#const SOL_SOCKET) (#const SO_DEBUG) #else pattern Debug = SockOpt (-1) (-1) #endif -- | SO_REUSEADDR pattern ReuseAddr :: SocketOption #ifdef SO_REUSEADDR pattern ReuseAddr = SockOpt (#const SOL_SOCKET) (#const SO_REUSEADDR) #else pattern ReuseAddr = SockOpt (-1) (-1) #endif -- | SO_DOMAIN, read-only pattern SoDomain :: SocketOption #ifdef SO_DOMAIN pattern SoDomain = SockOpt (#const SOL_SOCKET) (#const SO_DOMAIN) #else pattern SoDomain = SockOpt (-1) (-1) #endif -- | SO_TYPE, read-only pattern Type :: SocketOption #ifdef SO_TYPE pattern Type = SockOpt (#const SOL_SOCKET) (#const SO_TYPE) #else pattern Type = SockOpt (-1) (-1) #endif -- | SO_PROTOCOL, read-only pattern SoProtocol :: SocketOption #ifdef SO_PROTOCOL pattern SoProtocol = SockOpt (#const SOL_SOCKET) (#const SO_PROTOCOL) #else pattern SoProtocol = SockOpt (-1) (-1) #endif -- | SO_ERROR pattern SoError :: SocketOption #ifdef SO_ERROR pattern SoError = SockOpt (#const SOL_SOCKET) (#const SO_ERROR) #else pattern SoError = SockOpt (-1) (-1) #endif -- | SO_DONTROUTE pattern DontRoute :: SocketOption #ifdef SO_DONTROUTE pattern DontRoute = SockOpt (#const SOL_SOCKET) (#const SO_DONTROUTE) #else pattern DontRoute = SockOpt (-1) (-1) #endif -- | SO_BROADCAST pattern Broadcast :: SocketOption #ifdef SO_BROADCAST pattern Broadcast = SockOpt (#const SOL_SOCKET) (#const SO_BROADCAST) #else pattern Broadcast = SockOpt (-1) (-1) #endif -- | SO_SNDBUF pattern SendBuffer :: SocketOption #ifdef SO_SNDBUF pattern SendBuffer = SockOpt (#const SOL_SOCKET) (#const SO_SNDBUF) #else pattern SendBuffer = SockOpt (-1) (-1) #endif -- | SO_RCVBUF pattern RecvBuffer :: SocketOption #ifdef SO_RCVBUF pattern RecvBuffer = SockOpt (#const SOL_SOCKET) (#const SO_RCVBUF) #else pattern RecvBuffer = SockOpt (-1) (-1) #endif -- | SO_KEEPALIVE pattern KeepAlive :: SocketOption #ifdef SO_KEEPALIVE pattern KeepAlive = SockOpt (#const SOL_SOCKET) (#const SO_KEEPALIVE) #else pattern KeepAlive = SockOpt (-1) (-1) #endif -- | SO_OOBINLINE pattern OOBInline :: SocketOption #ifdef SO_OOBINLINE pattern OOBInline = SockOpt (#const SOL_SOCKET) (#const SO_OOBINLINE) #else pattern OOBInline = SockOpt (-1) (-1) #endif -- | SO_LINGER: timeout in seconds, 0 means disabling/disabled. pattern Linger :: SocketOption #ifdef SO_LINGER pattern Linger = SockOpt (#const SOL_SOCKET) (#const SO_LINGER) #else pattern Linger = SockOpt (-1) (-1) #endif -- | SO_REUSEPORT pattern ReusePort :: SocketOption #ifdef SO_REUSEPORT pattern ReusePort = SockOpt (#const SOL_SOCKET) (#const SO_REUSEPORT) #else pattern ReusePort = SockOpt (-1) (-1) #endif -- | SO_RCVLOWAT pattern RecvLowWater :: SocketOption #ifdef SO_RCVLOWAT pattern RecvLowWater = SockOpt (#const SOL_SOCKET) (#const SO_RCVLOWAT) #else pattern RecvLowWater = SockOpt (-1) (-1) #endif -- | SO_SNDLOWAT pattern SendLowWater :: SocketOption #ifdef SO_SNDLOWAT pattern SendLowWater = SockOpt (#const SOL_SOCKET) (#const SO_SNDLOWAT) #else pattern SendLowWater = SockOpt (-1) (-1) #endif -- | SO_RCVTIMEO: timeout in microseconds pattern RecvTimeOut :: SocketOption #ifdef SO_RCVTIMEO pattern RecvTimeOut = SockOpt (#const SOL_SOCKET) (#const SO_RCVTIMEO) #else pattern RecvTimeOut = SockOpt (-1) (-1) #endif -- | SO_SNDTIMEO: timeout in microseconds pattern SendTimeOut :: SocketOption #ifdef SO_SNDTIMEO pattern SendTimeOut = SockOpt (#const SOL_SOCKET) (#const SO_SNDTIMEO) #else pattern SendTimeOut = SockOpt (-1) (-1) #endif -- | SO_USELOOPBACK pattern UseLoopBack :: SocketOption #ifdef SO_USELOOPBACK pattern UseLoopBack = SockOpt (#const SOL_SOCKET) (#const SO_USELOOPBACK) #else pattern UseLoopBack = SockOpt (-1) (-1) #endif #endif // SOL_SOCKET #if HAVE_DECL_IPPROTO_TCP -- | TCP_MAXSEG pattern MaxSegment :: SocketOption #ifdef TCP_MAXSEG pattern MaxSegment = SockOpt (#const IPPROTO_TCP) (#const TCP_MAXSEG) #else pattern MaxSegment = SockOpt (-1) (-1) #endif -- | TCP_NODELAY pattern NoDelay :: SocketOption #ifdef TCP_NODELAY pattern NoDelay = SockOpt (#const IPPROTO_TCP) (#const TCP_NODELAY) #else pattern NoDelay = SockOpt (-1) (-1) #endif -- | TCP_USER_TIMEOUT pattern UserTimeout :: SocketOption #ifdef TCP_USER_TIMEOUT pattern UserTimeout = SockOpt (#const IPPROTO_TCP) (#const TCP_USER_TIMEOUT) #else pattern UserTimeout = SockOpt (-1) (-1) #endif -- | TCP_CORK pattern Cork :: SocketOption #ifdef TCP_CORK pattern Cork = SockOpt (#const IPPROTO_TCP) (#const TCP_CORK) #else pattern Cork = SockOpt (-1) (-1) #endif #endif // HAVE_DECL_IPPROTO_TCP #if HAVE_DECL_IPPROTO_IP -- | IP_TTL pattern TimeToLive :: SocketOption #ifdef IP_TTL pattern TimeToLive = SockOpt (#const IPPROTO_IP) (#const IP_TTL) #else pattern TimeToLive = SockOpt (-1) (-1) #endif -- | Receiving IPv4 TTL. pattern RecvIPv4TTL :: SocketOption #ifdef IP_RECVTTL pattern RecvIPv4TTL = SockOpt (#const IPPROTO_IP) (#const IP_RECVTTL) #else pattern RecvIPv4TTL = SockOpt (-1) (-1) #endif -- | Receiving IPv4 TOS. pattern RecvIPv4TOS :: SocketOption #ifdef IP_RECVTOS pattern RecvIPv4TOS = SockOpt (#const IPPROTO_IP) (#const IP_RECVTOS) #else pattern RecvIPv4TOS = SockOpt (-1) (-1) #endif -- | Receiving IP_PKTINFO (struct in_pktinfo). pattern RecvIPv4PktInfo :: SocketOption #ifdef IP_RECVPKTINFO pattern RecvIPv4PktInfo = SockOpt (#const IPPROTO_IP) (#const IP_RECVPKTINFO) #elif defined(IP_PKTINFO) pattern RecvIPv4PktInfo = SockOpt (#const IPPROTO_IP) (#const IP_PKTINFO) #else pattern RecvIPv4PktInfo = SockOpt (-1) (-1) #endif #endif // HAVE_DECL_IPPROTO_IP #if HAVE_DECL_IPPROTO_IPV6 -- | IPV6_V6ONLY: don't use this on OpenBSD. pattern IPv6Only :: SocketOption #if HAVE_DECL_IPV6_V6ONLY pattern IPv6Only = SockOpt (#const IPPROTO_IPV6) (#const IPV6_V6ONLY) #else pattern IPv6Only = SockOpt (-1) (-1) #endif -- | Receiving IPv6 hop limit. pattern RecvIPv6HopLimit :: SocketOption #ifdef IPV6_RECVHOPLIMIT pattern RecvIPv6HopLimit = SockOpt (#const IPPROTO_IPV6) (#const IPV6_RECVHOPLIMIT) #else pattern RecvIPv6HopLimit = SockOpt (-1) (-1) #endif -- | Receiving IPv6 traffic class. pattern RecvIPv6TClass :: SocketOption #ifdef IPV6_RECVTCLASS pattern RecvIPv6TClass = SockOpt (#const IPPROTO_IPV6) (#const IPV6_RECVTCLASS) #else pattern RecvIPv6TClass = SockOpt (-1) (-1) #endif -- | Receiving IPV6_PKTINFO (struct in6_pktinfo). pattern RecvIPv6PktInfo :: SocketOption #ifdef IPV6_RECVPKTINFO pattern RecvIPv6PktInfo = SockOpt (#const IPPROTO_IPV6) (#const IPV6_RECVPKTINFO) #elif defined(IPV6_PKTINFO) pattern RecvIPv6PktInfo = SockOpt (#const IPPROTO_IPV6) (#const IPV6_PKTINFO) #else pattern RecvIPv6PktInfo = SockOpt (-1) (-1) #endif #endif // HAVE_DECL_IPPROTO_IPV6 pattern CustomSockOpt :: (CInt, CInt) -> SocketOption pattern CustomSockOpt xy <- ((\(SockOpt x y) -> (x, y)) -> xy) where CustomSockOpt (x, y) = SockOpt x y ---------------------------------------------------------------- -- | Set a socket option that expects an 'Int' value. setSocketOption :: Socket -> SocketOption -- Option Name -> Int -- Option Value -> IO () #ifdef SO_LINGER setSocketOption s so@Linger v = do let arg = if v == 0 then StructLinger 0 0 else StructLinger 1 (fromIntegral v) setSockOpt s so arg #endif setSocketOption s so@RecvTimeOut v = setSockOpt s so $ SocketTimeout $ fromIntegral v setSocketOption s so@SendTimeOut v = setSockOpt s so $ SocketTimeout $ fromIntegral v setSocketOption s sa v = setSockOpt s sa (fromIntegral v :: CInt) -- | Set a socket option. setSockOpt :: Storable a => Socket -> SocketOption -> a -> IO () setSockOpt s (SockOpt level opt) v = do with v $ \ptr -> void $ do let sz = fromIntegral $ sizeOf v withFdSocket s $ \fd -> throwSocketErrorIfMinus1_ "Network.Socket.setSockOpt" $ c_setsockopt fd level opt ptr sz ---------------------------------------------------------------- -- | Get a socket option that gives an 'Int' value. getSocketOption :: Socket -> SocketOption -- Option Name -> IO Int -- Option Value #ifdef SO_LINGER getSocketOption s so@Linger = do StructLinger onoff linger <- getSockOpt s so return $ fromIntegral $ if onoff == 0 then 0 else linger #endif getSocketOption s so@RecvTimeOut = do SocketTimeout to <- getSockOpt s so return $ fromIntegral to getSocketOption s so@SendTimeOut = do SocketTimeout to <- getSockOpt s so return $ fromIntegral to getSocketOption s so = do n :: CInt <- getSockOpt s so return $ fromIntegral n -- | Get a socket option. getSockOpt :: forall a . Storable a => Socket -> SocketOption -- Option Name -> IO a -- Option Value getSockOpt s (SockOpt level opt) = do alloca $ \ptr -> do let sz = fromIntegral $ sizeOf (undefined :: a) withFdSocket s $ \fd -> with sz $ \ptr_sz -> do throwSocketErrorIfMinus1Retry_ "Network.Socket.getSockOpt" $ c_getsockopt fd level opt ptr ptr_sz peek ptr ---------------------------------------------------------------- -- | Get the 'SocketType' of an active socket. -- -- Since: 3.0.1.0 getSocketType :: Socket -> IO SocketType getSocketType s = unpackSocketType <$> getSockOpt s Type ---------------------------------------------------------------- #if __GLASGOW_HASKELL__ >= 806 {-# COMPLETE CustomSockOpt #-} #endif #ifdef SO_LINGER -- | Low level 'SO_LINBER' option value, which can be used with 'setSockOpt'. -- data StructLinger = StructLinger { -- | Set the linger option on. sl_onoff :: CInt, -- | Linger timeout. sl_linger :: CInt } deriving (Eq, Ord, Show) instance Storable StructLinger where sizeOf _ = (#const sizeof(struct linger)) alignment _ = alignment (0 :: CInt) peek p = do onoff <- (#peek struct linger, l_onoff) p linger <- (#peek struct linger, l_linger) p return $ StructLinger onoff linger poke p (StructLinger onoff linger) = do (#poke struct linger, l_onoff) p onoff (#poke struct linger, l_linger) p linger #endif ---------------------------------------------------------------- -- | Timeout in microseconds. -- This will be converted into struct timeval on Unix and -- DWORD (as milliseconds) on Windows. newtype SocketTimeout = SocketTimeout Word32 deriving (Eq, Ord, Show) #if defined(mingw32_HOST_OS) instance Storable SocketTimeout where sizeOf (SocketTimeout to) = sizeOf to -- DWORD as milliseconds alignment _ = 0 peek ptr = do to <- peek (castPtr ptr) return $ SocketTimeout (to * 1000) poke ptr (SocketTimeout to) = poke (castPtr ptr) (to `div` 1000) #else instance Storable SocketTimeout where sizeOf _ = (#size struct timeval) alignment _ = (#const offsetof(struct {char x__; struct timeval (y__); }, y__)) peek ptr = do sec <- (#peek struct timeval, tv_sec) ptr usec <- (#peek struct timeval, tv_usec) ptr return $ SocketTimeout (sec * 1000000 + usec) poke ptr (SocketTimeout to) = do let (sec, usec) = to `divMod` 1000000 (#poke struct timeval, tv_sec) ptr sec (#poke struct timeval, tv_usec) ptr usec #endif ---------------------------------------------------------------- foreign import CALLCONV unsafe "getsockopt" c_getsockopt :: CInt -> CInt -> CInt -> Ptr a -> Ptr CInt -> IO CInt foreign import CALLCONV unsafe "setsockopt" c_setsockopt :: CInt -> CInt -> CInt -> Ptr a -> CInt -> IO CInt network-3.1.4.0/Network/Socket/Posix/0000755000000000000000000000000007346545000015522 5ustar0000000000000000network-3.1.4.0/Network/Socket/Posix/Cmsg.hsc0000644000000000000000000002017507346545000017117 0ustar0000000000000000{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} module Network.Socket.Posix.Cmsg where #include "HsNet.h" #include #include import Data.ByteString.Internal import Foreign.ForeignPtr import System.IO.Unsafe (unsafeDupablePerformIO) import System.Posix.Types (Fd(..)) import Network.Socket.Imports import Network.Socket.Types import Network.Socket.ReadShow import qualified Text.Read as P -- | Control message (ancillary data) including a pair of level and type. data Cmsg = Cmsg { cmsgId :: !CmsgId , cmsgData :: !ByteString } deriving (Eq, Show) ---------------------------------------------------------------- -- | Identifier of control message (ancillary data). data CmsgId = CmsgId { cmsgLevel :: !CInt , cmsgType :: !CInt } deriving (Eq) -- | Unsupported identifier pattern UnsupportedCmsgId :: CmsgId pattern UnsupportedCmsgId = CmsgId (-1) (-1) -- | The identifier for 'IPv4TTL'. pattern CmsgIdIPv4TTL :: CmsgId #if defined(darwin_HOST_OS) || defined(freebsd_HOST_OS) || defined(openbsd_HOST_OS) pattern CmsgIdIPv4TTL = CmsgId (#const IPPROTO_IP) (#const IP_RECVTTL) #else pattern CmsgIdIPv4TTL = CmsgId (#const IPPROTO_IP) (#const IP_TTL) #endif -- | The identifier for 'IPv6HopLimit'. pattern CmsgIdIPv6HopLimit :: CmsgId pattern CmsgIdIPv6HopLimit = CmsgId (#const IPPROTO_IPV6) (#const IPV6_HOPLIMIT) -- | The identifier for 'IPv4TOS'. pattern CmsgIdIPv4TOS :: CmsgId #if defined(darwin_HOST_OS) || defined(freebsd_HOST_OS) pattern CmsgIdIPv4TOS = CmsgId (#const IPPROTO_IP) (#const IP_RECVTOS) #else pattern CmsgIdIPv4TOS = CmsgId (#const IPPROTO_IP) (#const IP_TOS) #endif -- | The identifier for 'IPv6TClass'. pattern CmsgIdIPv6TClass :: CmsgId pattern CmsgIdIPv6TClass = CmsgId (#const IPPROTO_IPV6) (#const IPV6_TCLASS) -- | The identifier for 'IPv4PktInfo'. pattern CmsgIdIPv4PktInfo :: CmsgId #if defined(IP_PKTINFO) pattern CmsgIdIPv4PktInfo = CmsgId (#const IPPROTO_IP) (#const IP_PKTINFO) #else pattern CmsgIdIPv4PktInfo = CmsgId (-1) (-1) #endif -- | The identifier for 'IPv6PktInfo'. pattern CmsgIdIPv6PktInfo :: CmsgId #if defined(IPV6_PKTINFO) pattern CmsgIdIPv6PktInfo = CmsgId (#const IPPROTO_IPV6) (#const IPV6_PKTINFO) #else pattern CmsgIdIPv6PktInfo = CmsgId (-1) (-1) #endif -- | The identifier for 'Fd'. pattern CmsgIdFd :: CmsgId pattern CmsgIdFd = CmsgId (#const SOL_SOCKET) (#const SCM_RIGHTS) ---------------------------------------------------------------- -- | Locate a control message of the given type in a list of control -- messages. The following shows an example usage: -- -- > (lookupCmsg CmsgIdIPv4TOS cmsgs >>= decodeCmsg) :: Maybe IPv4TOS lookupCmsg :: CmsgId -> [Cmsg] -> Maybe Cmsg lookupCmsg cid cmsgs = find (\cmsg -> cmsgId cmsg == cid) cmsgs -- | Filtering control message. filterCmsg :: CmsgId -> [Cmsg] -> [Cmsg] filterCmsg cid cmsgs = filter (\cmsg -> cmsgId cmsg == cid) cmsgs ---------------------------------------------------------------- -- | Control message type class. -- Each control message type has a numeric 'CmsgId' and a 'Storable' -- data representation. class Storable a => ControlMessage a where controlMessageId :: CmsgId encodeCmsg :: forall a . ControlMessage a => a -> Cmsg encodeCmsg x = unsafeDupablePerformIO $ do bs <- create siz $ \p0 -> do let p = castPtr p0 poke p x let cmsid = controlMessageId @a return $ Cmsg cmsid bs where siz = sizeOf x decodeCmsg :: forall a . (ControlMessage a, Storable a) => Cmsg -> Maybe a decodeCmsg (Cmsg cmsid (PS fptr off len)) | cid /= cmsid = Nothing | len < siz = Nothing | otherwise = unsafeDupablePerformIO $ withForeignPtr fptr $ \p0 -> do let p = castPtr (p0 `plusPtr` off) Just <$> peek p where cid = controlMessageId @a siz = sizeOf (undefined :: a) ---------------------------------------------------------------- -- | Time to live of IPv4. #if defined(darwin_HOST_OS) || defined(freebsd_HOST_OS) || defined(openbsd_HOST_OS) newtype IPv4TTL = IPv4TTL CChar deriving (Eq, Show, Storable) #else newtype IPv4TTL = IPv4TTL CInt deriving (Eq, Show, Storable) #endif instance ControlMessage IPv4TTL where controlMessageId = CmsgIdIPv4TTL ---------------------------------------------------------------- -- | Hop limit of IPv6. newtype IPv6HopLimit = IPv6HopLimit CInt deriving (Eq, Show, Storable) instance ControlMessage IPv6HopLimit where controlMessageId = CmsgIdIPv6HopLimit ---------------------------------------------------------------- -- | TOS of IPv4. newtype IPv4TOS = IPv4TOS CChar deriving (Eq, Show, Storable) instance ControlMessage IPv4TOS where controlMessageId = CmsgIdIPv4TOS ---------------------------------------------------------------- -- | Traffic class of IPv6. newtype IPv6TClass = IPv6TClass CInt deriving (Eq, Show, Storable) instance ControlMessage IPv6TClass where controlMessageId = CmsgIdIPv6TClass ---------------------------------------------------------------- -- | Network interface ID and local IPv4 address. data IPv4PktInfo = IPv4PktInfo Int HostAddress HostAddress deriving (Eq) instance Show IPv4PktInfo where show (IPv4PktInfo n sa ha) = "IPv4PktInfo " ++ show n ++ " " ++ show (hostAddressToTuple sa) ++ " " ++ show (hostAddressToTuple ha) instance ControlMessage IPv4PktInfo where controlMessageId = CmsgIdIPv4PktInfo instance Storable IPv4PktInfo where #if defined (IP_PKTINFO) sizeOf _ = (#size struct in_pktinfo) alignment _ = alignment (0 :: CInt) poke p (IPv4PktInfo n sa ha) = do (#poke struct in_pktinfo, ipi_ifindex) p (fromIntegral n :: CInt) (#poke struct in_pktinfo, ipi_spec_dst) p sa (#poke struct in_pktinfo, ipi_addr) p ha peek p = do n <- (#peek struct in_pktinfo, ipi_ifindex) p sa <- (#peek struct in_pktinfo, ipi_spec_dst) p ha <- (#peek struct in_pktinfo, ipi_addr) p return $ IPv4PktInfo n sa ha #else sizeOf _ = 0 alignment _ = 1 poke _ _ = error "Unsupported control message type" peek _ = error "Unsupported control message type" #endif ---------------------------------------------------------------- -- | Network interface ID and local IPv4 address. data IPv6PktInfo = IPv6PktInfo Int HostAddress6 deriving (Eq) instance Show IPv6PktInfo where show (IPv6PktInfo n ha6) = "IPv6PktInfo " ++ show n ++ " " ++ show (hostAddress6ToTuple ha6) instance ControlMessage IPv6PktInfo where controlMessageId = CmsgIdIPv6PktInfo instance Storable IPv6PktInfo where #if defined (IPV6_PKTINFO) sizeOf _ = (#size struct in6_pktinfo) alignment _ = alignment (0 :: CInt) poke p (IPv6PktInfo n ha6) = do (#poke struct in6_pktinfo, ipi6_ifindex) p (fromIntegral n :: CInt) (#poke struct in6_pktinfo, ipi6_addr) p (In6Addr ha6) peek p = do In6Addr ha6 <- (#peek struct in6_pktinfo, ipi6_addr) p n :: CInt <- (#peek struct in6_pktinfo, ipi6_ifindex) p return $ IPv6PktInfo (fromIntegral n) ha6 #else sizeOf _ = 0 alignment _ = 1 poke _ _ = error "Unsupported control message type" peek _ = error "Unsupported control message type" #endif ---------------------------------------------------------------- instance ControlMessage Fd where controlMessageId = CmsgIdFd cmsgIdBijection :: Bijection CmsgId String cmsgIdBijection = [ (UnsupportedCmsgId, "UnsupportedCmsgId") , (CmsgIdIPv4TTL, "CmsgIdIPv4TTL") , (CmsgIdIPv6HopLimit, "CmsgIdIPv6HopLimit") , (CmsgIdIPv4TOS, "CmsgIdIPv4TOS") , (CmsgIdIPv6TClass, "CmsgIdIPv6TClass") , (CmsgIdIPv4PktInfo, "CmsgIdIPv4PktInfo") , (CmsgIdIPv6PktInfo, "CmsgIdIPv6PktInfo") , (CmsgIdFd, "CmsgIdFd") ] instance Show CmsgId where showsPrec = bijectiveShow cmsgIdBijection def where defname = "CmsgId" unId = \(CmsgId l t) -> (l,t) def = defShow defname unId showIntInt instance Read CmsgId where readPrec = bijectiveRead cmsgIdBijection def where defname = "CmsgId" def = defRead defname (uncurry CmsgId) readIntInt network-3.1.4.0/Network/Socket/Posix/CmsgHdr.hsc0000644000000000000000000000607507346545000017560 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} #include "HsNet.h" module Network.Socket.Posix.CmsgHdr ( Cmsg(..) , withCmsgs , parseCmsgs ) where #include #include import Foreign.Marshal.Alloc (allocaBytes) import Foreign.ForeignPtr import qualified Data.ByteString as B import Data.ByteString.Internal import Network.Socket.Imports import Network.Socket.Posix.Cmsg import Network.Socket.Posix.MsgHdr import Network.Socket.Types data CmsgHdr = CmsgHdr { #ifdef __linux__ cmsgHdrLen :: !CSize #else cmsgHdrLen :: !(#type socklen_t) #endif , cmsgHdrLevel :: !CInt , cmsgHdrType :: !CInt } deriving (Eq, Show) instance Storable CmsgHdr where sizeOf _ = (#size struct cmsghdr) alignment _ = alignment (0 :: CInt) peek p = do len <- (#peek struct cmsghdr, cmsg_len) p lvl <- (#peek struct cmsghdr, cmsg_level) p typ <- (#peek struct cmsghdr, cmsg_type) p return $ CmsgHdr len lvl typ poke p (CmsgHdr len lvl typ) = do zeroMemory p (#size struct cmsghdr) (#poke struct cmsghdr, cmsg_len) p len (#poke struct cmsghdr, cmsg_level) p lvl (#poke struct cmsghdr, cmsg_type) p typ withCmsgs :: [Cmsg] -> (Ptr CmsgHdr -> Int -> IO a) -> IO a withCmsgs cmsgs0 action | total == 0 = action nullPtr 0 | otherwise = allocaBytes total $ \ctrlPtr -> do loop ctrlPtr cmsgs0 spaces action ctrlPtr total where loop ctrlPtr (cmsg:cmsgs) (s:ss) = do toCmsgHdr cmsg ctrlPtr let nextPtr = ctrlPtr `plusPtr` s loop nextPtr cmsgs ss loop _ _ _ = return () cmsg_space = fromIntegral . c_cmsg_space . fromIntegral spaces = map (cmsg_space . B.length . cmsgData) cmsgs0 total = sum spaces toCmsgHdr :: Cmsg -> Ptr CmsgHdr -> IO () toCmsgHdr (Cmsg (CmsgId lvl typ) (PS fptr off len)) ctrlPtr = do poke ctrlPtr $ CmsgHdr (fromIntegral $ c_cmsg_len (fromIntegral len)) lvl typ withForeignPtr fptr $ \src0 -> do let src = src0 `plusPtr` off dst <- c_cmsg_data ctrlPtr memcpy dst src len parseCmsgs :: SocketAddress sa => Ptr (MsgHdr sa) -> IO [Cmsg] parseCmsgs msgptr = do ptr <- c_cmsg_firsthdr msgptr loop ptr id where loop ptr build | ptr == nullPtr = return $ build [] | otherwise = do cmsg <- fromCmsgHdr ptr nextPtr <- c_cmsg_nxthdr msgptr ptr loop nextPtr (build . (cmsg :)) fromCmsgHdr :: Ptr CmsgHdr -> IO Cmsg fromCmsgHdr ptr = do CmsgHdr len lvl typ <- peek ptr src <- c_cmsg_data ptr let siz = fromIntegral len - (src `minusPtr` ptr) Cmsg (CmsgId lvl typ) <$> create (fromIntegral siz) (\dst -> memcpy dst src siz) foreign import ccall unsafe "cmsg_firsthdr" c_cmsg_firsthdr :: Ptr (MsgHdr sa) -> IO (Ptr CmsgHdr) foreign import ccall unsafe "cmsg_nxthdr" c_cmsg_nxthdr :: Ptr (MsgHdr sa) -> Ptr CmsgHdr -> IO (Ptr CmsgHdr) foreign import ccall unsafe "cmsg_data" c_cmsg_data :: Ptr CmsgHdr -> IO (Ptr Word8) foreign import ccall unsafe "cmsg_space" c_cmsg_space :: CSize -> CSize foreign import ccall unsafe "cmsg_len" c_cmsg_len :: CSize -> CSize network-3.1.4.0/Network/Socket/Posix/IOVec.hsc0000644000000000000000000000252007346545000017165 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} -- | Support module for the POSIX writev system call. module Network.Socket.Posix.IOVec ( IOVec(..) , withIOVec ) where import Foreign.Marshal.Array (allocaArray) import Network.Socket.Imports #include #include data IOVec = IOVec { iovBase :: !(Ptr Word8) , iovLen :: !CSize } instance Storable IOVec where sizeOf _ = (#const sizeof(struct iovec)) alignment _ = alignment (0 :: CInt) peek p = do base <- (#peek struct iovec, iov_base) p len <- (#peek struct iovec, iov_len) p return $ IOVec base len poke p iov = do (#poke struct iovec, iov_base) p (iovBase iov) (#poke struct iovec, iov_len) p (iovLen iov) -- | @withIOVec cs f@ executes the computation @f@, passing as argument a pair -- consisting of a pointer to a temporarily allocated array of pointers to -- IOVec made from @cs@ and the number of pointers (@length cs@). -- /Unix only/. withIOVec :: [(Ptr Word8, Int)] -> ((Ptr IOVec, Int) -> IO a) -> IO a withIOVec [] f = f (nullPtr, 0) withIOVec cs f = allocaArray csLen $ \aPtr -> do zipWithM_ pokeIov (ptrs aPtr) cs f (aPtr, csLen) where csLen = length cs ptrs = iterate (`plusPtr` sizeOf (IOVec nullPtr 0)) pokeIov ptr (sPtr, sLen) = poke ptr $ IOVec sPtr (fromIntegral sLen) network-3.1.4.0/Network/Socket/Posix/MsgHdr.hsc0000644000000000000000000000374107346545000017412 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} -- | Support module for the POSIX 'sendmsg' system call. module Network.Socket.Posix.MsgHdr ( MsgHdr(..) ) where #include #include import Network.Socket.Imports import Network.Socket.Internal (zeroMemory) import Network.Socket.Posix.IOVec (IOVec) data MsgHdr sa = MsgHdr { msgName :: !(Ptr sa) , msgNameLen :: !(#type socklen_t) , msgIov :: !(Ptr IOVec) #ifdef __linux__ , msgIovLen :: !CSize #else , msgIovLen :: !CInt #endif , msgCtrl :: !(Ptr Word8) #ifdef __linux__ , msgCtrlLen :: !CSize #else , msgCtrlLen :: !(#type socklen_t) #endif , msgFlags :: !CInt } instance Storable (MsgHdr sa) where sizeOf _ = (#const sizeof(struct msghdr)) alignment _ = alignment (0 :: CInt) peek p = do name <- (#peek struct msghdr, msg_name) p nameLen <- (#peek struct msghdr, msg_namelen) p iov <- (#peek struct msghdr, msg_iov) p iovLen <- (#peek struct msghdr, msg_iovlen) p ctrl <- (#peek struct msghdr, msg_control) p ctrlLen <- (#peek struct msghdr, msg_controllen) p flags <- (#peek struct msghdr, msg_flags) p return $ MsgHdr name nameLen iov iovLen ctrl ctrlLen flags poke p mh = do -- We need to zero the msg_control, msg_controllen, and msg_flags -- fields, but they only exist on some platforms (e.g. not on -- Solaris). Instead of using CPP, we zero the entire struct. zeroMemory p (#const sizeof(struct msghdr)) (#poke struct msghdr, msg_name) p (msgName mh) (#poke struct msghdr, msg_namelen) p (msgNameLen mh) (#poke struct msghdr, msg_iov) p (msgIov mh) (#poke struct msghdr, msg_iovlen) p (msgIovLen mh) (#poke struct msghdr, msg_control) p (msgCtrl mh) (#poke struct msghdr, msg_controllen) p (msgCtrlLen mh) (#poke struct msghdr, msg_flags) p (msgFlags mh) network-3.1.4.0/Network/Socket/ReadShow.hs0000644000000000000000000001176007346545000016475 0ustar0000000000000000{-# LANGUAGE RecordWildCards #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RankNTypes #-} module Network.Socket.ReadShow where import Text.Read ((<++)) import qualified Text.Read as P import qualified Text.Read.Lex as P import Control.Monad (mzero) -- type alias for individual correspondences of a (possibly partial) bijection type Pair a b = (a, b) -- | helper function for equality on first tuple element {-# INLINE eqFst #-} eqFst :: Eq a => a -> (a, b) -> Bool eqFst x = \(x',_) -> x' == x -- | helper function for equality on snd tuple element {-# INLINE eqSnd #-} eqSnd :: Eq b => b -> (a, b) -> Bool eqSnd y = \(_,y') -> y' == y -- | Unified automorphic involution over @Either a b@ that converts between -- LHS and RHS elements of a list of @Pair a b@ mappings and is the identity -- function if no matching pair is found -- -- If list contains duplicate matches, short-circuits to the first matching @Pair@ lookBetween :: (Eq a, Eq b) => [Pair a b] -> Either a b -> Either a b lookBetween ps = \case Left x | (_,y):_ <- filter (eqFst x) ps -> Right y Right y | (x,_):_ <- filter (eqSnd y) ps -> Left x z -> z -- Type alias for partial bijections between two types, consisting of a list -- of individual correspondences that are checked in order and short-circuit -- on first match -- -- Depending on how this is used, may not actually be a true bijection over -- the partial types, as no overlap-checking is currently implemented. If -- overlaps are unavoidable, the canonical short-circuit pair should appear -- first to avoid round-trip inconsistencies. type Bijection a b = [Pair a b] -- | Helper function for prefixing an optional constructor name before arbitrary values, -- which only enforces high precedence on subsequent output if the constructor name is not -- blank and space-separates for non-blank constructor names namePrefix :: Int -> String -> (Int -> b -> ShowS) -> b -> ShowS namePrefix i name f x | null name = f i x | otherwise = showParen (i > app_prec) $ showString name . showChar ' ' . f (app_prec+1) x {-# INLINE namePrefix #-} -- | Helper function for defining bijective Show instances that represents -- a common use-case where a constructor (or constructor-like pattern) name -- (optionally) precedes an internal value with a separate show function defShow :: Eq a => String -> (a -> b) -> (Int -> b -> ShowS) -> (Int -> a -> ShowS) defShow name unwrap shoPrec = \i x -> namePrefix i name shoPrec (unwrap x) {-# INLINE defShow #-} -- Helper function for stripping an optional constructor-name prefix before parsing -- an arbitrary value, which only consumes an extra token and increases precedence -- if the provided name prefix is non-blank expectPrefix :: String -> P.ReadPrec a -> P.ReadPrec a expectPrefix name pars | null name = pars | otherwise = do P.lift $ P.expect $ P.Ident name P.step pars {-# INLINE expectPrefix #-} -- | Helper function for defining bijective Read instances that represent a -- common use case where a constructor (or constructor-like pattern) name -- (optionally) precedes an internal value with a separate parse function defRead :: Eq a => String -> (b -> a) -> P.ReadPrec b -> P.ReadPrec a defRead name wrap redPrec = expectPrefix name $ wrap <$> redPrec {-# INLINE defRead #-} -- | Alias for showsPrec that pairs well with `_readInt` _showInt :: (Show a) => Int -> a -> ShowS _showInt = showsPrec {-# INLINE _showInt #-} -- | More descriptive alias for `safeInt` _readInt :: (Bounded a, Integral a) => P.ReadPrec a _readInt = safeInt {-# INLINE _readInt #-} -- | show two elements of a tuple separated by a space character -- inverse function to readIntInt when used on integer-like values showIntInt :: (Show a, Show b) => Int -> (a, b) -> ShowS showIntInt i (x, y) = _showInt i x . showChar ' ' . _showInt i y {-# INLINE showIntInt #-} -- | consume and return two integer-like values from two consecutive lexical tokens readIntInt :: (Bounded a, Integral a, Bounded b, Integral b) => P.ReadPrec (a, b) readIntInt = do x <- _readInt y <- _readInt return (x, y) {-# INLINE readIntInt #-} bijectiveShow :: (Eq a) => Bijection a String -> (Int -> a -> ShowS) -> (Int -> a -> ShowS) bijectiveShow bi def = \i x -> case lookBetween bi (Left x) of Right y -> showString y _ -> def i x bijectiveRead :: (Eq a) => Bijection a String -> P.ReadPrec a -> P.ReadPrec a bijectiveRead bi def = P.parens $ bijective <++ def where bijective = do (P.Ident y) <- P.lexP case lookBetween bi (Right y) of Left x -> return x _ -> mzero app_prec :: Int app_prec = 10 {-# INLINE app_prec #-} -- Parse integral values with type-specific overflow and underflow bounds-checks safeInt :: forall a. (Bounded a, Integral a) => P.ReadPrec a safeInt = do i <- signed if (i >= fromIntegral (minBound :: a) && i <= fromIntegral (maxBound :: a)) then return $ fromIntegral i else mzero where signed :: P.ReadPrec Integer signed = P.readPrec network-3.1.4.0/Network/Socket/Shutdown.hs0000644000000000000000000000525507346545000016576 0ustar0000000000000000{-# LANGUAGE CPP #-} #include "HsNetDef.h" module Network.Socket.Shutdown ( ShutdownCmd(..) , shutdown , gracefulClose ) where import qualified Control.Exception as E import Foreign.Marshal.Alloc (mallocBytes, free) import Control.Concurrent (threadDelay) import Network.Socket.Buffer import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Types data ShutdownCmd = ShutdownReceive | ShutdownSend | ShutdownBoth sdownCmdToInt :: ShutdownCmd -> CInt sdownCmdToInt ShutdownReceive = 0 sdownCmdToInt ShutdownSend = 1 sdownCmdToInt ShutdownBoth = 2 -- | Shut down one or both halves of the connection, depending on the -- second argument to the function. If the second argument is -- 'ShutdownReceive', further receives are disallowed. If it is -- 'ShutdownSend', further sends are disallowed. If it is -- 'ShutdownBoth', further sends and receives are disallowed. shutdown :: Socket -> ShutdownCmd -> IO () shutdown s stype = void $ withFdSocket s $ \fd -> throwSocketErrorIfMinus1Retry_ "Network.Socket.shutdown" $ c_shutdown fd $ sdownCmdToInt stype foreign import CALLCONV unsafe "shutdown" c_shutdown :: CInt -> CInt -> IO CInt -- | Closing a socket gracefully. -- This sends TCP FIN and check if TCP FIN is received from the peer. -- The second argument is time out to receive TCP FIN in millisecond. -- In both normal cases and error cases, socket is deallocated finally. -- -- Since: 3.1.1.0 gracefulClose :: Socket -> Int -> IO () gracefulClose s tmout = sendRecvFIN `E.finally` close s where sendRecvFIN = do -- Sending TCP FIN. ex <- E.try $ shutdown s ShutdownSend case ex of Left (E.SomeException _) -> return () Right () -> do -- Waiting TCP FIN. E.bracket (mallocBytes bufSize) free $ \buf -> do {-# SCC "" #-} recvEOFloop buf -- milliseconds. Taken from BSD fast clock value. clock = 200 recvEOFloop buf = loop 0 where loop delay = do -- We don't check the (positive) length. -- In normal case, it's 0. That is, only FIN is received. -- In error cases, data is available. But there is no -- application which can read it. So, let's stop receiving -- to prevent attacks. r <- recvBufNoWait s buf bufSize let delay' = delay + clock when (r == -1 && delay' < tmout) $ do threadDelay (clock * 1000) loop delay' -- Don't use 4092 here. The GHC runtime takes the global lock -- if the length is over 3276 bytes in 32bit or 3272 bytes in 64bit. bufSize = 1024 network-3.1.4.0/Network/Socket/SockAddr.hs0000644000000000000000000001070407346545000016450 0ustar0000000000000000{-# LANGUAGE CPP #-} module Network.Socket.SockAddr ( getPeerName , getSocketName , connect , bind , accept , sendBufTo , recvBufFrom , sendBufMsg , recvBufMsg ) where import Control.Exception (try, throwIO, IOException) import System.Directory (removeFile) import System.IO.Error (isAlreadyInUseError, isDoesNotExistError) import qualified Network.Socket.Buffer as G import qualified Network.Socket.Name as G import qualified Network.Socket.Syscall as G import Network.Socket.Flag import Network.Socket.Imports #if !defined(mingw32_HOST_OS) import Network.Socket.Posix.Cmsg #else import Network.Socket.Win32.Cmsg #endif import Network.Socket.Types -- | Getting peer's 'SockAddr'. getPeerName :: Socket -> IO SockAddr getPeerName = G.getPeerName -- | Getting my 'SockAddr'. getSocketName :: Socket -> IO SockAddr getSocketName = G.getSocketName -- | Connect to a remote socket at address. connect :: Socket -> SockAddr -> IO () connect = G.connect -- | Bind the socket to an address. The socket must not already be -- bound. The 'Family' passed to @bind@ must be the -- same as that passed to 'socket'. If the special port number -- 'defaultPort' is passed then the system assigns the next available -- use port. bind :: Socket -> SockAddr -> IO () bind s a = case a of SockAddrUnix p -> do -- gracefully handle the fact that UNIX systems don't clean up closed UNIX -- domain sockets, inspired by https://stackoverflow.com/a/13719866 res <- try (G.bind s a) case res of Right () -> return () Left e | not (isAlreadyInUseError e) -> throwIO (e :: IOException) Left e | otherwise -> do -- socket might be in use, try to connect res2 <- try (G.connect s a) case res2 of Right () -> close s >> throwIO e Left e2 | not (isDoesNotExistError e2) -> throwIO (e2 :: IOException) _ -> do -- socket not actually in use, remove it and retry bind void (try $ removeFile p :: IO (Either IOError ())) G.bind s a _ -> G.bind s a -- | Accept a connection. The socket must be bound to an address and -- listening for connections. The return value is a pair @(conn, -- address)@ where @conn@ is a new socket object usable to send and -- receive data on the connection, and @address@ is the address bound -- to the socket on the other end of the connection. -- On Unix, FD_CLOEXEC is set to the new 'Socket'. accept :: Socket -> IO (Socket, SockAddr) accept = G.accept -- | Send data to the socket. The recipient can be specified -- explicitly, so the socket need not be in a connected state. -- Returns the number of bytes sent. Applications are responsible for -- ensuring that all data has been sent. sendBufTo :: Socket -> Ptr a -> Int -> SockAddr -> IO Int sendBufTo = G.sendBufTo -- | Receive data from the socket, writing it into buffer instead of -- creating a new string. The socket need not be in a connected -- state. Returns @(nbytes, address)@ where @nbytes@ is the number of -- bytes received and @address@ is a 'SockAddr' representing the -- address of the sending socket. -- -- If the first return value is zero, it means EOF. -- -- For 'Stream' sockets, the second return value would be invalid. -- -- NOTE: blocking on Windows unless you compile with -threaded (see -- GHC ticket #1129) recvBufFrom :: Socket -> Ptr a -> Int -> IO (Int, SockAddr) recvBufFrom = G.recvBufFrom -- | Send data to the socket using sendmsg(2). sendBufMsg :: Socket -- ^ Socket -> SockAddr -- ^ Destination address -> [(Ptr Word8,Int)] -- ^ Data to be sent -> [Cmsg] -- ^ Control messages -> MsgFlag -- ^ Message flags -> IO Int -- ^ The length actually sent sendBufMsg = G.sendBufMsg -- | Receive data from the socket using recvmsg(2). recvBufMsg :: Socket -- ^ Socket -> [(Ptr Word8,Int)] -- ^ A list of a pair of buffer and its size. -- If the total length is not large enough, -- 'MSG_TRUNC' is returned -> Int -- ^ The buffer size for control messages. -- If the length is not large enough, -- 'MSG_CTRUNC' is returned -> MsgFlag -- ^ Message flags -> IO (SockAddr,Int,[Cmsg],MsgFlag) -- ^ Source address, received data, control messages and message flags recvBufMsg = G.recvBufMsg network-3.1.4.0/Network/Socket/Syscall.hs0000644000000000000000000002357507346545000016402 0ustar0000000000000000{-# LANGUAGE CPP #-} #include "HsNetDef.h" module Network.Socket.Syscall where import Foreign.Marshal.Utils (with) import qualified Control.Exception as E # if defined(mingw32_HOST_OS) import System.IO.Error (catchIOError) #endif #if defined(mingw32_HOST_OS) import Foreign (FunPtr) import GHC.Conc (asyncDoProc) #else import Foreign.C.Error (getErrno, eINTR, eINPROGRESS) import GHC.Conc (threadWaitWrite) #endif #ifdef HAVE_ADVANCED_SOCKET_FLAGS import Network.Socket.Cbits #else import Network.Socket.Fcntl #endif import Network.Socket.Imports import Network.Socket.Internal import Network.Socket.Options import Network.Socket.Types -- ---------------------------------------------------------------------------- -- On Windows, our sockets are not put in non-blocking mode (non-blocking -- is not supported for regular file descriptors on Windows, and it would -- be a pain to support it only for sockets). So there are two cases: -- -- - the threaded RTS uses safe calls for socket operations to get -- non-blocking I/O, just like the rest of the I/O library -- -- - with the non-threaded RTS, only some operations on sockets will be -- non-blocking. Reads and writes go through the normal async I/O -- system. accept() uses asyncDoProc so is non-blocking. A handful -- of others (recvFrom, sendFd, recvFd) will block all threads - if this -- is a problem, -threaded is the workaround. -- ----------------------------------------------------------------------------- -- Connection Functions -- In the following connection and binding primitives. The names of -- the equivalent C functions have been preserved where possible. It -- should be noted that some of these names used in the C library, -- \tr{bind} in particular, have a different meaning to many Haskell -- programmers and have thus been renamed by appending the prefix -- Socket. -- | Create a new socket using the given address family, socket type -- and protocol number. The address family is usually 'AF_INET', -- 'AF_INET6', or 'AF_UNIX'. The socket type is usually 'Stream' or -- 'Datagram'. The protocol number is usually 'defaultProtocol'. -- If 'AF_INET6' is used and the socket type is 'Stream' or 'Datagram', -- the 'IPv6Only' socket option is set to 0 so that both IPv4 and IPv6 -- can be handled with one socket. -- -- >>> import Network.Socket -- >>> let hints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV], addrSocketType = Stream } -- >>> addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.1") (Just "5000") -- >>> sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) -- >>> Network.Socket.bind sock (addrAddress addr) -- >>> getSocketName sock -- 127.0.0.1:5000 socket :: Family -- Family Name (usually AF_INET) -> SocketType -- Socket Type (usually Stream) -> ProtocolNumber -- Protocol Number (getProtocolByName to find value) -> IO Socket -- Unconnected Socket socket family stype protocol = E.bracketOnError create c_close $ \fd -> do -- Let's ensure that the socket (file descriptor) is closed even on -- asynchronous exceptions. setNonBlock fd s <- mkSocket fd -- This socket is not managed by the IO manager yet. -- So, we don't have to call "close" which uses "closeFdWith". unsetIPv6Only s return s where create = do let c_stype = modifyFlag $ packSocketType stype throwSocketErrorIfMinus1Retry "Network.Socket.socket" $ c_socket (packFamily family) c_stype protocol #ifdef HAVE_ADVANCED_SOCKET_FLAGS modifyFlag c_stype = c_stype .|. sockNonBlock #else modifyFlag c_stype = c_stype #endif #ifdef HAVE_ADVANCED_SOCKET_FLAGS setNonBlock _ = return () #else setNonBlock fd = setNonBlockIfNeeded fd #endif #if HAVE_DECL_IPV6_V6ONLY unsetIPv6Only s = when (family == AF_INET6 && stype `elem` [Stream, Datagram]) $ # if defined(mingw32_HOST_OS) -- The IPv6Only option is only supported on Windows Vista and later, -- so trying to change it might throw an error. setSocketOption s IPv6Only 0 `catchIOError` \_ -> return () # elif defined(openbsd_HOST_OS) -- don't change IPv6Only return () # else -- The default value of the IPv6Only option is platform specific, -- so we explicitly set it to 0 to provide a common default. setSocketOption s IPv6Only 0 # endif #else unsetIPv6Only _ = return () #endif ----------------------------------------------------------------------------- -- Binding a socket -- | Bind the socket to an address. The socket must not already be -- bound. The 'Family' passed to @bind@ must be the -- same as that passed to 'socket'. If the special port number -- 'defaultPort' is passed then the system assigns the next available -- use port. bind :: SocketAddress sa => Socket -> sa -> IO () bind s sa = withSocketAddress sa $ \p_sa siz -> void $ withFdSocket s $ \fd -> do let sz = fromIntegral siz throwSocketErrorIfMinus1Retry "Network.Socket.bind" $ c_bind fd p_sa sz ----------------------------------------------------------------------------- -- Connecting a socket -- | Connect to a remote socket at address. connect :: SocketAddress sa => Socket -> sa -> IO () connect s sa = withSocketsDo $ withSocketAddress sa $ \p_sa sz -> connectLoop s p_sa (fromIntegral sz) connectLoop :: SocketAddress sa => Socket -> Ptr sa -> CInt -> IO () connectLoop s p_sa sz = withFdSocket s $ \fd -> loop fd where errLoc = "Network.Socket.connect: " ++ show s loop fd = do r <- c_connect fd p_sa sz when (r == -1) $ do #if defined(mingw32_HOST_OS) throwSocketError errLoc #else err <- getErrno case () of _ | err == eINTR -> loop fd _ | err == eINPROGRESS -> connectBlocked -- _ | err == eAGAIN -> connectBlocked _otherwise -> throwSocketError errLoc connectBlocked = do withFdSocket s $ threadWaitWrite . fromIntegral err <- getSocketOption s SoError when (err /= 0) $ throwSocketErrorCode errLoc (fromIntegral err) #endif ----------------------------------------------------------------------------- -- Listen -- | Listen for connections made to the socket. The second argument -- specifies the maximum number of queued connections and should be at -- least 1; the maximum value is system-dependent (usually 5). listen :: Socket -> Int -> IO () listen s backlog = withFdSocket s $ \fd -> do throwSocketErrorIfMinus1Retry_ "Network.Socket.listen" $ c_listen fd $ fromIntegral backlog ----------------------------------------------------------------------------- -- Accept -- -- A call to `accept' only returns when data is available on the given -- socket, unless the socket has been set to non-blocking. It will -- return a new socket which should be used to read the incoming data and -- should then be closed. Using the socket returned by `accept' allows -- incoming requests to be queued on the original socket. -- | Accept a connection. The socket must be bound to an address and -- listening for connections. The return value is a pair @(conn, -- address)@ where @conn@ is a new socket object usable to send and -- receive data on the connection, and @address@ is the address bound -- to the socket on the other end of the connection. -- On Unix, FD_CLOEXEC is set to the new 'Socket'. accept :: SocketAddress sa => Socket -> IO (Socket, sa) accept listing_sock = withNewSocketAddress $ \new_sa sz -> withFdSocket listing_sock $ \listing_fd -> do new_sock <- callAccept listing_fd new_sa sz >>= mkSocket new_addr <- peekSocketAddress new_sa return (new_sock, new_addr) where #if defined(mingw32_HOST_OS) callAccept fd sa sz | threaded = with (fromIntegral sz) $ \ ptr_len -> throwSocketErrorIfMinus1Retry "Network.Socket.accept" $ c_accept_safe fd sa ptr_len | otherwise = do paramData <- c_newAcceptParams fd (fromIntegral sz) sa rc <- asyncDoProc c_acceptDoProc paramData new_fd <- c_acceptNewSock paramData c_free paramData when (rc /= 0) $ throwSocketErrorCode "Network.Socket.accept" (fromIntegral rc) return new_fd #else callAccept fd sa sz = with (fromIntegral sz) $ \ ptr_len -> do # ifdef HAVE_ADVANCED_SOCKET_FLAGS throwSocketErrorWaitRead listing_sock "Network.Socket.accept" (c_accept4 fd sa ptr_len (sockNonBlock .|. sockCloexec)) # else new_fd <- throwSocketErrorWaitRead listing_sock "Network.Socket.accept" (c_accept fd sa ptr_len) setNonBlockIfNeeded new_fd setCloseOnExecIfNeeded new_fd return new_fd # endif /* HAVE_ADVANCED_SOCKET_FLAGS */ #endif foreign import CALLCONV unsafe "socket" c_socket :: CInt -> CInt -> CInt -> IO CInt foreign import CALLCONV unsafe "bind" c_bind :: CInt -> Ptr sa -> CInt{-CSockLen???-} -> IO CInt foreign import CALLCONV SAFE_ON_WIN "connect" c_connect :: CInt -> Ptr sa -> CInt{-CSockLen???-} -> IO CInt foreign import CALLCONV unsafe "listen" c_listen :: CInt -> CInt -> IO CInt #ifdef HAVE_ADVANCED_SOCKET_FLAGS foreign import CALLCONV unsafe "accept4" c_accept4 :: CInt -> Ptr sa -> Ptr CInt{-CSockLen???-} -> CInt -> IO CInt #else foreign import CALLCONV unsafe "accept" c_accept :: CInt -> Ptr sa -> Ptr CInt{-CSockLen???-} -> IO CInt #endif #if defined(mingw32_HOST_OS) foreign import CALLCONV safe "accept" c_accept_safe :: CInt -> Ptr sa -> Ptr CInt{-CSockLen???-} -> IO CInt foreign import ccall unsafe "rtsSupportsBoundThreads" threaded :: Bool foreign import ccall unsafe "HsNet.h acceptNewSock" c_acceptNewSock :: Ptr () -> IO CInt foreign import ccall unsafe "HsNet.h newAcceptParams" c_newAcceptParams :: CInt -> CInt -> Ptr a -> IO (Ptr ()) foreign import ccall unsafe "HsNet.h &acceptDoProc" c_acceptDoProc :: FunPtr (Ptr () -> IO Int) foreign import ccall unsafe "free" c_free:: Ptr a -> IO () #endif network-3.1.4.0/Network/Socket/Types.hsc0000644000000000000000000012463507346545000016236 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE MagicHash, UnboxedTuples #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} #include "HsNet.h" ##include "HsNetDef.h" module Network.Socket.Types ( -- * Socket type Socket , withFdSocket , unsafeFdSocket , touchSocket , socketToFd , fdSocket , mkSocket , invalidateSocket , close , close' , c_close -- * Types of socket , SocketType(GeneralSocketType, UnsupportedSocketType, NoSocketType , Stream, Datagram, Raw, RDM, SeqPacket) , isSupportedSocketType , packSocketType , unpackSocketType -- * Family , Family(GeneralFamily, UnsupportedFamily ,AF_UNSPEC,AF_UNIX,AF_INET,AF_INET6,AF_IMPLINK,AF_PUP,AF_CHAOS ,AF_NS,AF_NBS,AF_ECMA,AF_DATAKIT,AF_CCITT,AF_SNA,AF_DECnet ,AF_DLI,AF_LAT,AF_HYLINK,AF_APPLETALK,AF_ROUTE,AF_NETBIOS ,AF_NIT,AF_802,AF_ISO,AF_OSI,AF_NETMAN,AF_X25,AF_AX25,AF_OSINET ,AF_GOSSIP,AF_IPX,Pseudo_AF_XTP,AF_CTF,AF_WAN,AF_SDL,AF_NETWARE ,AF_NDD,AF_INTF,AF_COIP,AF_CNT,Pseudo_AF_RTIP,Pseudo_AF_PIP ,AF_SIP,AF_ISDN,Pseudo_AF_KEY,AF_NATM,AF_ARP,Pseudo_AF_HDRCMPLT ,AF_ENCAP,AF_LINK,AF_RAW,AF_RIF,AF_NETROM,AF_BRIDGE,AF_ATMPVC ,AF_ROSE,AF_NETBEUI,AF_SECURITY,AF_PACKET,AF_ASH,AF_ECONET ,AF_ATMSVC,AF_IRDA,AF_PPPOX,AF_WANPIPE,AF_BLUETOOTH,AF_CAN) , isSupportedFamily , packFamily , unpackFamily -- * Socket address typeclass , SocketAddress(..) , withSocketAddress , withNewSocketAddress -- * Socket address type , SockAddr(..) , isSupportedSockAddr , HostAddress , hostAddressToTuple , tupleToHostAddress , HostAddress6 , hostAddress6ToTuple , tupleToHostAddress6 , FlowInfo , ScopeID , peekSockAddr , pokeSockAddr , withSockAddr -- * Unsorted , ProtocolNumber , defaultProtocol , PortNumber , defaultPort -- * Low-level helpers , zeroMemory , htonl , ntohl , In6Addr(..) ) where import Data.IORef (IORef, newIORef, readIORef, atomicModifyIORef', mkWeakIORef) import Foreign.C.Error (throwErrno) import Foreign.Marshal.Alloc import GHC.Conc (closeFdWith) import System.Posix.Types (Fd) import Control.DeepSeq (NFData (..)) import GHC.Exts (touch##) import GHC.IORef (IORef (..)) import GHC.STRef (STRef (..)) import GHC.IO (IO (..)) import qualified Text.Read as P import Foreign.Marshal.Array import Network.Socket.Imports ----- readshow module import import Network.Socket.ReadShow ----------------------------------------------------------------------------- -- | Basic type for a socket. data Socket = Socket !(IORef CInt) !CInt {- for Show -} instance Show Socket where show (Socket _ ofd) = "" instance Eq Socket where Socket ref1 _ == Socket ref2 _ = ref1 == ref2 {-# DEPRECATED fdSocket "Use withFdSocket or unsafeFdSocket instead" #-} -- | Currently, this is an alias of `unsafeFdSocket`. fdSocket :: Socket -> IO CInt fdSocket = unsafeFdSocket -- | Getting a file descriptor from a socket. -- -- If a 'Socket' is shared with multiple threads and -- one uses 'unsafeFdSocket', unexpected issues may happen. -- Consider the following scenario: -- -- 1) Thread A acquires a 'Fd' from 'Socket' by 'unsafeFdSocket'. -- -- 2) Thread B close the 'Socket'. -- -- 3) Thread C opens a new 'Socket'. Unfortunately it gets the same 'Fd' -- number which thread A is holding. -- -- In this case, it is safer for Thread A to clone 'Fd' by -- 'System.Posix.IO.dup'. But this would still suffer from -- a race condition between 'unsafeFdSocket' and 'close'. -- -- If you use this function, you need to guarantee that the 'Socket' does not -- get garbage-collected until after you finish using the file descriptor. -- 'touchSocket' can be used for this purpose. -- -- A safer option is to use 'withFdSocket' instead. unsafeFdSocket :: Socket -> IO CInt unsafeFdSocket (Socket ref _) = readIORef ref -- | Ensure that the given 'Socket' stays alive (i.e. not garbage-collected) -- at the given place in the sequence of IO actions. This function can be -- used in conjunction with 'unsafeFdSocket' to guarantee that the file -- descriptor is not prematurely freed. -- -- > fd <- unsafeFdSocket sock -- > -- using fd with blocking operations such as accept(2) -- > touchSocket sock touchSocket :: Socket -> IO () touchSocket (Socket ref _) = touch ref touch :: IORef a -> IO () touch (IORef (STRef mutVar)) = -- Thanks to a GHC issue, this touch# may not be quite guaranteed -- to work. There's talk of replacing the touch# primop with one -- that works better with the optimizer. But this seems to be the -- "right" way to do it for now. IO $ \s -> (## touch## mutVar s, () ##) -- | Get a file descriptor from a 'Socket'. The socket will never -- be closed automatically before @withFdSocket@ completes, but -- it may still be closed by an explicit call to 'close' or `close'`, -- either before or during the call. -- -- The file descriptor must not be used after @withFdSocket@ returns, because -- the 'Socket' may have been garbage-collected, invalidating the file -- descriptor. -- -- Since: 3.1.0.0 withFdSocket :: Socket -> (CInt -> IO r) -> IO r withFdSocket (Socket ref _) f = do fd <- readIORef ref -- Should we throw an exception if the socket is already invalid? -- That will catch some mistakes but certainly not all. r <- f fd touch ref return r -- | Socket is closed and a duplicated file descriptor is returned. -- The duplicated descriptor is no longer subject to the possibility -- of unexpectedly being closed if the socket is finalized. It is -- now the caller's responsibility to ultimately close the -- duplicated file descriptor. socketToFd :: Socket -> IO CInt socketToFd s = do #if defined(mingw32_HOST_OS) fd <- unsafeFdSocket s fd2 <- c_wsaDuplicate fd -- FIXME: throw error no if -1 close s return fd2 foreign import ccall unsafe "wsaDuplicate" c_wsaDuplicate :: CInt -> IO CInt #else fd <- unsafeFdSocket s -- FIXME: throw error no if -1 fd2 <- c_dup fd close s return fd2 foreign import ccall unsafe "dup" c_dup :: CInt -> IO CInt #endif -- | Creating a socket from a file descriptor. mkSocket :: CInt -> IO Socket mkSocket fd = do ref <- newIORef fd let s = Socket ref fd void $ mkWeakIORef ref $ close s return s invalidSocket :: CInt #if defined(mingw32_HOST_OS) invalidSocket = #const INVALID_SOCKET #else invalidSocket = -1 #endif invalidateSocket :: Socket -> (CInt -> IO a) -> (CInt -> IO a) -> IO a invalidateSocket (Socket ref _) errorAction normalAction = do oldfd <- atomicModifyIORef' ref $ \cur -> (invalidSocket, cur) if oldfd == invalidSocket then errorAction oldfd else normalAction oldfd ----------------------------------------------------------------------------- -- | Close the socket. This function does not throw exceptions even if -- the underlying system call returns errors. -- -- If multiple threads use the same socket and one uses 'unsafeFdSocket' and -- the other use 'close', unexpected behavior may happen. -- For more information, please refer to the documentation of 'unsafeFdSocket'. close :: Socket -> IO () close s = invalidateSocket s (\_ -> return ()) $ \oldfd -> do -- closeFdWith avoids the deadlock of IO manager. closeFdWith closeFd (toFd oldfd) where toFd :: CInt -> Fd toFd = fromIntegral -- closeFd ignores the return value of c_close and -- does not throw exceptions closeFd :: Fd -> IO () closeFd = void . c_close . fromIntegral -- | Close the socket. This function throws exceptions if -- the underlying system call returns errors. close' :: Socket -> IO () close' s = invalidateSocket s (\_ -> return ()) $ \oldfd -> do -- closeFdWith avoids the deadlock of IO manager. closeFdWith closeFd (toFd oldfd) where toFd :: CInt -> Fd toFd = fromIntegral closeFd :: Fd -> IO () closeFd fd = do ret <- c_close $ fromIntegral fd when (ret == -1) $ throwErrno "Network.Socket.close'" #if defined(mingw32_HOST_OS) foreign import CALLCONV unsafe "closesocket" c_close :: CInt -> IO CInt #else foreign import ccall unsafe "close" c_close :: CInt -> IO CInt #endif ----------------------------------------------------------------------------- -- | Protocol number. type ProtocolNumber = CInt -- | This is the default protocol for a given service. -- -- >>> defaultProtocol -- 0 defaultProtocol :: ProtocolNumber defaultProtocol = 0 ----------------------------------------------------------------------------- -- Socket types -- There are a few possible ways to do this. The first is convert the -- structs used in the C library into an equivalent Haskell type. An -- other possible implementation is to keep all the internals in the C -- code and use an Int## and a status flag. The second method is used -- here since a lot of the C structures are not required to be -- manipulated. -- Originally the status was non-mutable so we had to return a new -- socket each time we changed the status. This version now uses -- mutable variables to avoid the need to do this. The result is a -- cleaner interface and better security since the application -- programmer now can't circumvent the status information to perform -- invalid operations on sockets. -- | Socket Types. -- -- Some of the defined patterns may be unsupported on some systems: -- see 'isSupportedSocketType'. newtype SocketType = SocketType { packSocketType :: CInt } deriving (Eq, Ord) unpackSocketType :: CInt -> SocketType unpackSocketType = SocketType {-# INLINE unpackSocketType #-} -- | Is the @SOCK_xxxxx@ constant corresponding to the given SocketType known -- on this system? 'GeneralSocketType' values, not equal to any of the named -- patterns or 'UnsupportedSocketType', will return 'True' even when not -- known on this system. isSupportedSocketType :: SocketType -> Bool isSupportedSocketType = (/= UnsupportedSocketType) -- | Pattern for a general socket type. pattern GeneralSocketType :: CInt -> SocketType pattern GeneralSocketType n = SocketType n #if __GLASGOW_HASKELL__ >= 806 {-# COMPLETE GeneralSocketType #-} #endif -- The actual constructor is not exported, which keeps the internal -- representation private, but for all purposes other than 'coerce' the -- above pattern is just as good. -- | Unsupported socket type, equal to any other types not supported on this -- system. pattern UnsupportedSocketType :: SocketType pattern UnsupportedSocketType = SocketType (-1) -- | Used in getAddrInfo hints, for example. pattern NoSocketType :: SocketType pattern NoSocketType = SocketType 0 pattern Stream :: SocketType #ifdef SOCK_STREAM pattern Stream = SocketType (#const SOCK_STREAM) #else pattern Stream = (-1) #endif pattern Datagram :: SocketType #ifdef SOCK_DGRAM pattern Datagram = SocketType (#const SOCK_DGRAM) #else pattern Datagram = (-1) #endif pattern Raw :: SocketType #ifdef SOCK_RAW pattern Raw = SocketType (#const SOCK_RAW) #else pattern Raw = (-1) #endif pattern RDM :: SocketType #ifdef SOCK_RDM pattern RDM = SocketType (#const SOCK_RDM) #else pattern RDM = (-1) #endif pattern SeqPacket :: SocketType #ifdef SOCK_SEQPACKET pattern SeqPacket = SocketType (#const SOCK_SEQPACKET) #else pattern SeqPacket = (-1) #endif ------------------------------------------------------------------------ -- Protocol Families. -- | Address families. The @AF_xxxxx@ constants are widely used as synonyms -- for the corresponding @PF_xxxxx@ protocol family values, to which they are -- numerically equal in mainstream socket API implementations. -- -- Strictly correct usage would be to pass the @PF_xxxxx@ constants as the first -- argument when creating a 'Socket', while the @AF_xxxxx@ constants should be -- used as @addrFamily@ values with 'getAddrInfo'. For now only the @AF_xxxxx@ -- constants are provided. -- -- Some of the defined patterns may be unsupported on some systems: -- see 'isSupportedFamily'. newtype Family = Family { packFamily :: CInt } deriving (Eq, Ord) -- | Does one of the AF_ constants correspond to a known address family on this -- system. 'GeneralFamily' values, not equal to any of the named @AF_xxxxx@ -- patterns or 'UnsupportedFamily', will return 'True' even when not known on -- this system. isSupportedFamily :: Family -> Bool isSupportedFamily f = case f of UnsupportedFamily -> False GeneralFamily _ -> True -- | Convert 'CInt' to 'Family'. unpackFamily :: CInt -> Family unpackFamily = Family {-# INLINE unpackFamily #-} -- | Pattern for a general protocol family (a.k.a. address family). -- -- @since 3.2.0.0 pattern GeneralFamily :: CInt -> Family pattern GeneralFamily n = Family n #if __GLASGOW_HASKELL__ >= 806 {-# COMPLETE GeneralFamily #-} #endif -- The actual constructor is not exported, which keeps the internal -- representation private, but for all purposes other than 'coerce' the -- above pattern is just as good. -- | Unsupported address family, equal to any other families that are not -- supported on the system. -- -- @since 3.2.0.0 pattern UnsupportedFamily :: Family pattern UnsupportedFamily = Family (-1) -- | unspecified pattern AF_UNSPEC :: Family pattern AF_UNSPEC = Family (#const AF_UNSPEC) -- | UNIX-domain pattern AF_UNIX :: Family #ifdef AF_UNIX pattern AF_UNIX = Family (#const AF_UNIX) #else pattern AF_UNIX = Family (-1) #endif -- | Internet Protocol version 4 pattern AF_INET :: Family #ifdef AF_INET pattern AF_INET = Family (#const AF_INET) #else pattern AF_INET = Family (-1) #endif -- | Internet Protocol version 6 pattern AF_INET6 :: Family #ifdef AF_INET6 pattern AF_INET6 = Family (#const AF_INET6) #else pattern AF_INET6 = Family (-1) #endif -- | Arpanet imp addresses pattern AF_IMPLINK :: Family #ifdef AF_IMPLINK pattern AF_IMPLINK = Family (#const AF_IMPLINK) #else pattern AF_IMPLINK = Family (-1) #endif -- | pup protocols: e.g. BSP pattern AF_PUP :: Family #ifdef AF_PUP pattern AF_PUP = Family (#const AF_PUP) #else pattern AF_PUP = Family (-1) #endif -- | mit CHAOS protocols pattern AF_CHAOS :: Family #ifdef AF_CHAOS pattern AF_CHAOS = Family (#const AF_CHAOS) #else pattern AF_CHAOS = Family (-1) #endif -- | XEROX NS protocols pattern AF_NS :: Family #ifdef AF_NS pattern AF_NS = Family (#const AF_NS) #else pattern AF_NS = Family (-1) #endif -- | nbs protocols pattern AF_NBS :: Family #ifdef AF_NBS pattern AF_NBS = Family (#const AF_NBS) #else pattern AF_NBS = Family (-1) #endif -- | european computer manufacturers pattern AF_ECMA :: Family #ifdef AF_ECMA pattern AF_ECMA = Family (#const AF_ECMA) #else pattern AF_ECMA = Family (-1) #endif -- | datakit protocols pattern AF_DATAKIT :: Family #ifdef AF_DATAKIT pattern AF_DATAKIT = Family (#const AF_DATAKIT) #else pattern AF_DATAKIT = Family (-1) #endif -- | CCITT protocols, X.25 etc pattern AF_CCITT :: Family #ifdef AF_CCITT pattern AF_CCITT = Family (#const AF_CCITT) #else pattern AF_CCITT = Family (-1) #endif -- | IBM SNA pattern AF_SNA :: Family #ifdef AF_SNA pattern AF_SNA = Family (#const AF_SNA) #else pattern AF_SNA = Family (-1) #endif -- | DECnet pattern AF_DECnet :: Family #ifdef AF_DECnet pattern AF_DECnet = Family (#const AF_DECnet) #else pattern AF_DECnet = Family (-1) #endif -- | Direct data link interface pattern AF_DLI :: Family #ifdef AF_DLI pattern AF_DLI = Family (#const AF_DLI) #else pattern AF_DLI = Family (-1) #endif -- | LAT pattern AF_LAT :: Family #ifdef AF_LAT pattern AF_LAT = Family (#const AF_LAT) #else pattern AF_LAT = Family (-1) #endif -- | NSC Hyperchannel pattern AF_HYLINK :: Family #ifdef AF_HYLINK pattern AF_HYLINK = Family (#const AF_HYLINK) #else pattern AF_HYLINK = Family (-1) #endif -- | Apple Talk pattern AF_APPLETALK :: Family #ifdef AF_APPLETALK pattern AF_APPLETALK = Family (#const AF_APPLETALK) #else pattern AF_APPLETALK = Family (-1) #endif -- | Internal Routing Protocol (aka AF_NETLINK) pattern AF_ROUTE :: Family #ifdef AF_ROUTE pattern AF_ROUTE = Family (#const AF_ROUTE) #else pattern AF_ROUTE = Family (-1) #endif -- | NetBios-style addresses pattern AF_NETBIOS :: Family #ifdef AF_NETBIOS pattern AF_NETBIOS = Family (#const AF_NETBIOS) #else pattern AF_NETBIOS = Family (-1) #endif -- | Network Interface Tap pattern AF_NIT :: Family #ifdef AF_NIT pattern AF_NIT = Family (#const AF_NIT) #else pattern AF_NIT = Family (-1) #endif -- | IEEE 802.2, also ISO 8802 pattern AF_802 :: Family #ifdef AF_802 pattern AF_802 = Family (#const AF_802) #else pattern AF_802 = Family (-1) #endif -- | ISO protocols pattern AF_ISO :: Family #ifdef AF_ISO pattern AF_ISO = Family (#const AF_ISO) #else pattern AF_ISO = Family (-1) #endif -- | umbrella of all families used by OSI pattern AF_OSI :: Family #ifdef AF_OSI pattern AF_OSI = Family (#const AF_OSI) #else pattern AF_OSI = Family (-1) #endif -- | DNA Network Management pattern AF_NETMAN :: Family #ifdef AF_NETMAN pattern AF_NETMAN = Family (#const AF_NETMAN) #else pattern AF_NETMAN = Family (-1) #endif -- | CCITT X.25 pattern AF_X25 :: Family #ifdef AF_X25 pattern AF_X25 = Family (#const AF_X25) #else pattern AF_X25 = Family (-1) #endif -- | AX25 pattern AF_AX25 :: Family #ifdef AF_AX25 pattern AF_AX25 = Family (#const AF_AX25) #else pattern AF_AX25 = Family (-1) #endif -- | AFI pattern AF_OSINET :: Family #ifdef AF_OSINET pattern AF_OSINET = Family (#const AF_OSINET) #else pattern AF_OSINET = Family (-1) #endif -- | US Government OSI pattern AF_GOSSIP :: Family #ifdef AF_GOSSIP pattern AF_GOSSIP = Family (#const AF_GOSSIP) #else pattern AF_GOSSIP = Family (-1) #endif -- | Novell Internet Protocol pattern AF_IPX :: Family #ifdef AF_IPX pattern AF_IPX = Family (#const AF_IPX) #else pattern AF_IPX = Family (-1) #endif -- | eXpress Transfer Protocol (no AF) pattern Pseudo_AF_XTP :: Family #ifdef Pseudo_AF_XTP pattern Pseudo_AF_XTP = Family (#const Pseudo_AF_XTP) #else pattern Pseudo_AF_XTP = Family (-1) #endif -- | Common Trace Facility pattern AF_CTF :: Family #ifdef AF_CTF pattern AF_CTF = Family (#const AF_CTF) #else pattern AF_CTF = Family (-1) #endif -- | Wide Area Network protocols pattern AF_WAN :: Family #ifdef AF_WAN pattern AF_WAN = Family (#const AF_WAN) #else pattern AF_WAN = Family (-1) #endif -- | SGI Data Link for DLPI pattern AF_SDL :: Family #ifdef AF_SDL pattern AF_SDL = Family (#const AF_SDL) #else pattern AF_SDL = Family (-1) #endif -- | Netware pattern AF_NETWARE :: Family #ifdef AF_NETWARE pattern AF_NETWARE = Family (#const AF_NETWARE) #else pattern AF_NETWARE = Family (-1) #endif -- | NDD pattern AF_NDD :: Family #ifdef AF_NDD pattern AF_NDD = Family (#const AF_NDD) #else pattern AF_NDD = Family (-1) #endif -- | Debugging use only pattern AF_INTF :: Family #ifdef AF_INTF pattern AF_INTF = Family (#const AF_INTF) #else pattern AF_INTF = Family (-1) #endif -- | connection-oriented IP, aka ST II pattern AF_COIP :: Family #ifdef AF_COIP pattern AF_COIP = Family (#const AF_COIP) #else pattern AF_COIP = Family (-1) #endif -- | Computer Network Technology pattern AF_CNT :: Family #ifdef AF_CNT pattern AF_CNT = Family (#const AF_CNT) #else pattern AF_CNT = Family (-1) #endif -- | Help Identify RTIP packets pattern Pseudo_AF_RTIP :: Family #ifdef Pseudo_AF_RTIP pattern Pseudo_AF_RTIP = Family (#const Pseudo_AF_RTIP) #else pattern Pseudo_AF_RTIP = Family (-1) #endif -- | Help Identify PIP packets pattern Pseudo_AF_PIP :: Family #ifdef Pseudo_AF_PIP pattern Pseudo_AF_PIP = Family (#const Pseudo_AF_PIP) #else pattern Pseudo_AF_PIP = Family (-1) #endif -- | Simple Internet Protocol pattern AF_SIP :: Family #ifdef AF_SIP pattern AF_SIP = Family (#const AF_SIP) #else pattern AF_SIP = Family (-1) #endif -- | Integrated Services Digital Network pattern AF_ISDN :: Family #ifdef AF_ISDN pattern AF_ISDN = Family (#const AF_ISDN) #else pattern AF_ISDN = Family (-1) #endif -- | Internal key-management function pattern Pseudo_AF_KEY :: Family #ifdef Pseudo_AF_KEY pattern Pseudo_AF_KEY = Family (#const Pseudo_AF_KEY) #else pattern Pseudo_AF_KEY = Family (-1) #endif -- | native ATM access pattern AF_NATM :: Family #ifdef AF_NATM pattern AF_NATM = Family (#const AF_NATM) #else pattern AF_NATM = Family (-1) #endif -- | ARP (RFC 826) pattern AF_ARP :: Family #ifdef AF_ARP pattern AF_ARP = Family (#const AF_ARP) #else pattern AF_ARP = Family (-1) #endif -- | Used by BPF to not rewrite hdrs in iface output pattern Pseudo_AF_HDRCMPLT :: Family #ifdef Pseudo_AF_HDRCMPLT pattern Pseudo_AF_HDRCMPLT = Family (#const Pseudo_AF_HDRCMPLT) #else pattern Pseudo_AF_HDRCMPLT = Family (-1) #endif -- | ENCAP pattern AF_ENCAP :: Family #ifdef AF_ENCAP pattern AF_ENCAP = Family (#const AF_ENCAP) #else pattern AF_ENCAP = Family (-1) #endif -- | Link layer interface pattern AF_LINK :: Family #ifdef AF_LINK pattern AF_LINK = Family (#const AF_LINK) #else pattern AF_LINK = Family (-1) #endif -- | Link layer interface pattern AF_RAW :: Family #ifdef AF_RAW pattern AF_RAW = Family (#const AF_RAW) #else pattern AF_RAW = Family (-1) #endif -- | raw interface pattern AF_RIF :: Family #ifdef AF_RIF pattern AF_RIF = Family (#const AF_RIF) #else pattern AF_RIF = Family (-1) #endif -- | Amateur radio NetROM pattern AF_NETROM :: Family #ifdef AF_NETROM pattern AF_NETROM = Family (#const AF_NETROM) #else pattern AF_NETROM = Family (-1) #endif -- | multiprotocol bridge pattern AF_BRIDGE :: Family #ifdef AF_BRIDGE pattern AF_BRIDGE = Family (#const AF_BRIDGE) #else pattern AF_BRIDGE = Family (-1) #endif -- | ATM PVCs pattern AF_ATMPVC :: Family #ifdef AF_ATMPVC pattern AF_ATMPVC = Family (#const AF_ATMPVC) #else pattern AF_ATMPVC = Family (-1) #endif -- | Amateur Radio X.25 PLP pattern AF_ROSE :: Family #ifdef AF_ROSE pattern AF_ROSE = Family (#const AF_ROSE) #else pattern AF_ROSE = Family (-1) #endif -- | Netbeui 802.2LLC pattern AF_NETBEUI :: Family #ifdef AF_NETBEUI pattern AF_NETBEUI = Family (#const AF_NETBEUI) #else pattern AF_NETBEUI = Family (-1) #endif -- | Security callback pseudo AF pattern AF_SECURITY :: Family #ifdef AF_SECURITY pattern AF_SECURITY = Family (#const AF_SECURITY) #else pattern AF_SECURITY = Family (-1) #endif -- | Packet family pattern AF_PACKET :: Family #ifdef AF_PACKET pattern AF_PACKET = Family (#const AF_PACKET) #else pattern AF_PACKET = Family (-1) #endif -- | Ash pattern AF_ASH :: Family #ifdef AF_ASH pattern AF_ASH = Family (#const AF_ASH) #else pattern AF_ASH = Family (-1) #endif -- | Acorn Econet pattern AF_ECONET :: Family #ifdef AF_ECONET pattern AF_ECONET = Family (#const AF_ECONET) #else pattern AF_ECONET = Family (-1) #endif -- | ATM SVCs pattern AF_ATMSVC :: Family #ifdef AF_ATMSVC pattern AF_ATMSVC = Family (#const AF_ATMSVC) #else pattern AF_ATMSVC = Family (-1) #endif -- | IRDA sockets pattern AF_IRDA :: Family #ifdef AF_IRDA pattern AF_IRDA = Family (#const AF_IRDA) #else pattern AF_IRDA = Family (-1) #endif -- | PPPoX sockets pattern AF_PPPOX :: Family #ifdef AF_PPPOX pattern AF_PPPOX = Family (#const AF_PPPOX) #else pattern AF_PPPOX = Family (-1) #endif -- | Wanpipe API sockets pattern AF_WANPIPE :: Family #ifdef AF_WANPIPE pattern AF_WANPIPE = Family (#const AF_WANPIPE) #else pattern AF_WANPIPE = Family (-1) #endif -- | bluetooth sockets pattern AF_BLUETOOTH :: Family #ifdef AF_BLUETOOTH pattern AF_BLUETOOTH = Family (#const AF_BLUETOOTH) #else pattern AF_BLUETOOTH = Family (-1) #endif -- | Controller Area Network pattern AF_CAN :: Family #ifdef AF_CAN pattern AF_CAN = Family (#const AF_CAN) #else pattern AF_CAN = Family (-1) #endif ------------------------------------------------------------------------ -- Port Numbers -- | Port number. -- Use the @Num@ instance (i.e. use a literal) to create a -- @PortNumber@ value. -- -- >>> 1 :: PortNumber -- 1 -- >>> read "1" :: PortNumber -- 1 -- >>> show (12345 :: PortNumber) -- "12345" -- >>> 50000 < (51000 :: PortNumber) -- True -- >>> 50000 < (52000 :: PortNumber) -- True -- >>> 50000 + (10000 :: PortNumber) -- 60000 newtype PortNumber = PortNum Word16 deriving (Eq, Ord, Num, Enum, Bounded, Real, Integral) foreign import CALLCONV unsafe "ntohs" ntohs :: Word16 -> Word16 foreign import CALLCONV unsafe "htons" htons :: Word16 -> Word16 -- | Converts the from host byte order to network byte order. foreign import CALLCONV unsafe "htonl" htonl :: Word32 -> Word32 -- | Converts the from network byte order to host byte order. foreign import CALLCONV unsafe "ntohl" ntohl :: Word32 -> Word32 {-# DEPRECATED htonl "Use getAddrInfo instead" #-} {-# DEPRECATED ntohl "Use getAddrInfo instead" #-} instance Storable PortNumber where sizeOf _ = sizeOf (0 :: Word16) alignment _ = alignment (0 :: Word16) poke p (PortNum po) = poke (castPtr p) (htons po) peek p = PortNum . ntohs <$> peek (castPtr p) -- | Default port number. -- -- >>> defaultPort -- 0 defaultPort :: PortNumber defaultPort = 0 ------------------------------------------------------------------------ -- | The core typeclass to unify socket addresses. class SocketAddress sa where sizeOfSocketAddress :: sa -> Int peekSocketAddress :: Ptr sa -> IO sa pokeSocketAddress :: Ptr a -> sa -> IO () -- sizeof(struct sockaddr_storage) which has enough space to contain -- sockaddr_in, sockaddr_in6 and sockaddr_un. sockaddrStorageLen :: Int sockaddrStorageLen = 128 withSocketAddress :: SocketAddress sa => sa -> (Ptr sa -> Int -> IO a) -> IO a withSocketAddress addr f = do let sz = sizeOfSocketAddress addr if sz == 0 then f nullPtr 0 else allocaBytes sz $ \p -> pokeSocketAddress p addr >> f (castPtr p) sz withNewSocketAddress :: SocketAddress sa => (Ptr sa -> Int -> IO a) -> IO a withNewSocketAddress f = allocaBytes sockaddrStorageLen $ \ptr -> do zeroMemory ptr $ fromIntegral sockaddrStorageLen f ptr sockaddrStorageLen ------------------------------------------------------------------------ -- Socket addresses -- The scheme used for addressing sockets is somewhat quirky. The -- calls in the BSD socket API that need to know the socket address -- all operate in terms of struct sockaddr, a `virtual' type of -- socket address. -- The Internet family of sockets are addressed as struct sockaddr_in, -- so when calling functions that operate on struct sockaddr, we have -- to type cast the Internet socket address into a struct sockaddr. -- Instances of the structure for different families might *not* be -- the same size. Same casting is required of other families of -- sockets such as Xerox NS. Similarly for UNIX-domain sockets. -- To represent these socket addresses in Haskell-land, we do what BSD -- didn't do, and use a union/algebraic type for the different -- families. Currently only UNIX-domain sockets and the Internet -- families are supported. -- | Flow information. type FlowInfo = Word32 -- | Scope identifier. type ScopeID = Word32 -- | Socket addresses. -- The existence of a constructor does not necessarily imply that -- that socket address type is supported on your system: see -- 'isSupportedSockAddr'. data SockAddr = SockAddrInet !PortNumber -- sin_port !HostAddress -- sin_addr (ditto) | SockAddrInet6 !PortNumber -- sin6_port !FlowInfo -- sin6_flowinfo (ditto) !HostAddress6 -- sin6_addr (ditto) !ScopeID -- sin6_scope_id (ditto) -- | The path must have fewer than 104 characters. All of these characters must have code points less than 256. | SockAddrUnix String -- sun_path deriving (Eq, Ord) instance NFData SockAddr where rnf (SockAddrInet _ _) = () rnf (SockAddrInet6 _ _ _ _) = () rnf (SockAddrUnix str) = rnf str -- | Is the socket address type supported on this system? isSupportedSockAddr :: SockAddr -> Bool isSupportedSockAddr addr = case addr of SockAddrInet{} -> True SockAddrInet6{} -> True SockAddrUnix{} -> True instance SocketAddress SockAddr where sizeOfSocketAddress = sizeOfSockAddr peekSocketAddress = peekSockAddr pokeSocketAddress = pokeSockAddr #if defined(mingw32_HOST_OS) type CSaFamily = (#type unsigned short) #elif defined(darwin_HOST_OS) type CSaFamily = (#type u_char) #else type CSaFamily = (#type sa_family_t) #endif -- | Computes the storage requirements (in bytes) of the given -- 'SockAddr'. This function differs from 'Foreign.Storable.sizeOf' -- in that the value of the argument /is/ used. sizeOfSockAddr :: SockAddr -> Int # ifdef linux_HOST_OS -- http://man7.org/linux/man-pages/man7/unix.7.html says: -- "an abstract socket address is distinguished (from a -- pathname socket) by the fact that sun_path[0] is a null byte -- ('\0'). The socket's address in this namespace is given by the -- additional bytes in sun_path that are covered by the specified -- length of the address structure. (Null bytes in the name have no -- special significance.) The name has no connection with filesystem -- pathnames. When the address of an abstract socket is returned, -- the returned addrlen is greater than sizeof(sa_family_t) (i.e., -- greater than 2), and the name of the socket is contained in the -- first (addrlen - sizeof(sa_family_t)) bytes of sun_path." sizeOfSockAddr (SockAddrUnix path) = case path of '\0':_ -> (#const sizeof(sa_family_t)) + length path _ -> #const sizeof(struct sockaddr_un) # else sizeOfSockAddr SockAddrUnix{} = #const sizeof(struct sockaddr_un) # endif sizeOfSockAddr SockAddrInet{} = #const sizeof(struct sockaddr_in) sizeOfSockAddr SockAddrInet6{} = #const sizeof(struct sockaddr_in6) -- | Use a 'SockAddr' with a function requiring a pointer to a -- 'SockAddr' and the length of that 'SockAddr'. withSockAddr :: SockAddr -> (Ptr SockAddr -> Int -> IO a) -> IO a withSockAddr addr f = do let sz = sizeOfSockAddr addr allocaBytes sz $ \p -> pokeSockAddr p addr >> f (castPtr p) sz -- We cannot bind sun_paths longer than than the space in the sockaddr_un -- structure, and attempting to do so could overflow the allocated storage -- space. This constant holds the maximum allowable path length. -- unixPathMax :: Int unixPathMax = #const sizeof(((struct sockaddr_un *)NULL)->sun_path) -- We can't write an instance of 'Storable' for 'SockAddr' because -- @sockaddr@ is a sum type of variable size but -- 'Foreign.Storable.sizeOf' is required to be constant. -- Note that on Darwin, the sockaddr structure must be zeroed before -- use. -- | Write the given 'SockAddr' to the given memory location. pokeSockAddr :: Ptr a -> SockAddr -> IO () pokeSockAddr p sa@(SockAddrUnix path) = do when (length path > unixPathMax) $ error $ "pokeSockAddr: path is too long in SockAddrUnix " <> show path <> ", length " <> show (length path) <> ", unixPathMax " <> show unixPathMax zeroMemory p $ fromIntegral $ sizeOfSockAddr sa # if defined(HAVE_STRUCT_SOCKADDR_SA_LEN) (#poke struct sockaddr_un, sun_len) p ((#const sizeof(struct sockaddr_un)) :: Word8) # endif (#poke struct sockaddr_un, sun_family) p ((#const AF_UNIX) :: CSaFamily) let pathC = map castCharToCChar path -- the buffer is already filled with nulls. pokeArray ((#ptr struct sockaddr_un, sun_path) p) pathC pokeSockAddr p (SockAddrInet port addr) = do zeroMemory p (#const sizeof(struct sockaddr_in)) #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN) (#poke struct sockaddr_in, sin_len) p ((#const sizeof(struct sockaddr_in)) :: Word8) #endif (#poke struct sockaddr_in, sin_family) p ((#const AF_INET) :: CSaFamily) (#poke struct sockaddr_in, sin_port) p port (#poke struct sockaddr_in, sin_addr) p addr pokeSockAddr p (SockAddrInet6 port flow addr scope) = do zeroMemory p (#const sizeof(struct sockaddr_in6)) # if defined(HAVE_STRUCT_SOCKADDR_SA_LEN) (#poke struct sockaddr_in6, sin6_len) p ((#const sizeof(struct sockaddr_in6)) :: Word8) # endif (#poke struct sockaddr_in6, sin6_family) p ((#const AF_INET6) :: CSaFamily) (#poke struct sockaddr_in6, sin6_port) p port (#poke struct sockaddr_in6, sin6_flowinfo) p flow (#poke struct sockaddr_in6, sin6_addr) p (In6Addr addr) (#poke struct sockaddr_in6, sin6_scope_id) p scope -- | Read a 'SockAddr' from the given memory location. peekSockAddr :: Ptr SockAddr -> IO SockAddr peekSockAddr p = do family <- (#peek struct sockaddr, sa_family) p case family :: CSaFamily of (#const AF_UNIX) -> do str <- peekCAString ((#ptr struct sockaddr_un, sun_path) p) return (SockAddrUnix str) (#const AF_INET) -> do addr <- (#peek struct sockaddr_in, sin_addr) p port <- (#peek struct sockaddr_in, sin_port) p return (SockAddrInet port addr) (#const AF_INET6) -> do port <- (#peek struct sockaddr_in6, sin6_port) p flow <- (#peek struct sockaddr_in6, sin6_flowinfo) p In6Addr addr <- (#peek struct sockaddr_in6, sin6_addr) p scope <- (#peek struct sockaddr_in6, sin6_scope_id) p return (SockAddrInet6 port flow addr scope) _ -> ioError $ userError $ "Network.Socket.Types.peekSockAddr: address family '" ++ show family ++ "' not supported." ------------------------------------------------------------------------ -- | The raw network byte order number is read using host byte order. -- Therefore on little-endian architectures the byte order is swapped. For -- example @127.0.0.1@ is represented as @0x0100007f@ on little-endian hosts -- and as @0x7f000001@ on big-endian hosts. -- -- For direct manipulation prefer 'hostAddressToTuple' and -- 'tupleToHostAddress'. type HostAddress = Word32 -- | Converts 'HostAddress' to representation-independent IPv4 quadruple. -- For example for @127.0.0.1@ the function will return @(0x7f, 0, 0, 1)@ -- regardless of host endianness. -- {- -- prop> tow == hostAddressToTuple (tupleToHostAddress tow) -} hostAddressToTuple :: HostAddress -> (Word8, Word8, Word8, Word8) hostAddressToTuple ha' = let ha = htonl ha' byte i = fromIntegral (ha `shiftR` i) :: Word8 in (byte 24, byte 16, byte 8, byte 0) -- | Converts IPv4 quadruple to 'HostAddress'. tupleToHostAddress :: (Word8, Word8, Word8, Word8) -> HostAddress tupleToHostAddress (b3, b2, b1, b0) = let x `sl` i = fromIntegral x `shiftL` i :: Word32 in ntohl $ (b3 `sl` 24) .|. (b2 `sl` 16) .|. (b1 `sl` 8) .|. (b0 `sl` 0) -- | Independent of endianness. For example @::1@ is stored as @(0, 0, 0, 1)@. -- -- For direct manipulation prefer 'hostAddress6ToTuple' and -- 'tupleToHostAddress6'. type HostAddress6 = (Word32, Word32, Word32, Word32) -- | Converts 'HostAddress6' to representation-independent IPv6 octuple. -- {- -- prop> (w1,w2,w3,w4,w5,w6,w7,w8) == hostAddress6ToTuple (tupleToHostAddress6 (w1,w2,w3,w4,w5,w6,w7,w8)) -} hostAddress6ToTuple :: HostAddress6 -> (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16) hostAddress6ToTuple (w3, w2, w1, w0) = let high, low :: Word32 -> Word16 high w = fromIntegral (w `shiftR` 16) low w = fromIntegral w in (high w3, low w3, high w2, low w2, high w1, low w1, high w0, low w0) -- | Converts IPv6 octuple to 'HostAddress6'. tupleToHostAddress6 :: (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16) -> HostAddress6 tupleToHostAddress6 (w7, w6, w5, w4, w3, w2, w1, w0) = let add :: Word16 -> Word16 -> Word32 high `add` low = (fromIntegral high `shiftL` 16) .|. (fromIntegral low) in (w7 `add` w6, w5 `add` w4, w3 `add` w2, w1 `add` w0) -- The peek32 and poke32 functions work around the fact that the RFCs -- don't require 32-bit-wide address fields to be present. We can -- only portably rely on an 8-bit field, s6_addr. s6_addr_offset :: Int s6_addr_offset = (#offset struct in6_addr, s6_addr) peek32 :: Ptr a -> Int -> IO Word32 peek32 p i0 = do let i' = i0 * 4 peekByte n = peekByteOff p (s6_addr_offset + i' + n) :: IO Word8 a `sl` i = fromIntegral a `shiftL` i a0 <- peekByte 0 a1 <- peekByte 1 a2 <- peekByte 2 a3 <- peekByte 3 return ((a0 `sl` 24) .|. (a1 `sl` 16) .|. (a2 `sl` 8) .|. (a3 `sl` 0)) poke32 :: Ptr a -> Int -> Word32 -> IO () poke32 p i0 a = do let i' = i0 * 4 pokeByte n = pokeByteOff p (s6_addr_offset + i' + n) x `sr` i = fromIntegral (x `shiftR` i) :: Word8 pokeByte 0 (a `sr` 24) pokeByte 1 (a `sr` 16) pokeByte 2 (a `sr` 8) pokeByte 3 (a `sr` 0) -- | Private newtype proxy for the Storable instance. To avoid orphan instances. newtype In6Addr = In6Addr HostAddress6 #if __GLASGOW_HASKELL__ < 800 #let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__) #endif instance Storable In6Addr where sizeOf _ = #const sizeof(struct in6_addr) alignment _ = #alignment struct in6_addr peek p = do a <- peek32 p 0 b <- peek32 p 1 c <- peek32 p 2 d <- peek32 p 3 return $ In6Addr (a, b, c, d) poke p (In6Addr (a, b, c, d)) = do poke32 p 0 a poke32 p 1 b poke32 p 2 c poke32 p 3 d ------------------------------------------------------------------------ -- Read and Show instance for pattern-based integral newtypes socktypeBijection :: Bijection SocketType String socktypeBijection = [ (UnsupportedSocketType, "UnsupportedSocketType") , (Stream, "Stream") , (Datagram, "Datagram") , (Raw, "Raw") , (RDM, "RDM") , (SeqPacket, "SeqPacket") , (NoSocketType, "NoSocketType") ] instance Show SocketType where showsPrec = bijectiveShow socktypeBijection def where gst = "GeneralSocketType" def = defShow gst packSocketType _showInt instance Read SocketType where readPrec = bijectiveRead socktypeBijection def where gst = "GeneralSocketType" def = defRead gst unpackSocketType _readInt familyBijection :: Bijection Family String familyBijection = [ (UnsupportedFamily, "UnsupportedFamily") , (AF_UNSPEC, "AF_UNSPEC") , (AF_UNIX, "AF_UNIX") , (AF_INET, "AF_INET") , (AF_INET6, "AF_INET6") , (AF_IMPLINK, "AF_IMPLINK") , (AF_PUP, "AF_PUP") , (AF_CHAOS, "AF_CHAOS") , (AF_NS, "AF_NS") , (AF_NBS, "AF_NBS") , (AF_ECMA, "AF_ECMA") , (AF_DATAKIT, "AF_DATAKIT") , (AF_CCITT, "AF_CCITT") , (AF_SNA, "AF_SNA") , (AF_DECnet, "AF_DECnet") , (AF_DLI, "AF_DLI") , (AF_LAT, "AF_LAT") , (AF_HYLINK, "AF_HYLINK") , (AF_APPLETALK, "AF_APPLETALK") , (AF_ROUTE, "AF_ROUTE") , (AF_NETBIOS, "AF_NETBIOS") , (AF_NIT, "AF_NIT") , (AF_802, "AF_802") , (AF_ISO, "AF_ISO") , (AF_OSI, "AF_OSI") , (AF_NETMAN, "AF_NETMAN") , (AF_X25, "AF_X25") , (AF_AX25, "AF_AX25") , (AF_OSINET, "AF_OSINET") , (AF_GOSSIP, "AF_GOSSIP") , (AF_IPX, "AF_IPX") , (Pseudo_AF_XTP, "Pseudo_AF_XTP") , (AF_CTF, "AF_CTF") , (AF_WAN, "AF_WAN") , (AF_SDL, "AF_SDL") , (AF_NETWARE, "AF_NETWARE") , (AF_NDD, "AF_NDD") , (AF_INTF, "AF_INTF") , (AF_COIP, "AF_COIP") , (AF_CNT, "AF_CNT") , (Pseudo_AF_RTIP, "Pseudo_AF_RTIP") , (Pseudo_AF_PIP, "Pseudo_AF_PIP") , (AF_SIP, "AF_SIP") , (AF_ISDN, "AF_ISDN") , (Pseudo_AF_KEY, "Pseudo_AF_KEY") , (AF_NATM, "AF_NATM") , (AF_ARP, "AF_ARP") , (Pseudo_AF_HDRCMPLT, "Pseudo_AF_HDRCMPLT") , (AF_ENCAP, "AF_ENCAP") , (AF_LINK, "AF_LINK") , (AF_RAW, "AF_RAW") , (AF_RIF, "AF_RIF") , (AF_NETROM, "AF_NETROM") , (AF_BRIDGE, "AF_BRIDGE") , (AF_ATMPVC, "AF_ATMPVC") , (AF_ROSE, "AF_ROSE") , (AF_NETBEUI, "AF_NETBEUI") , (AF_SECURITY, "AF_SECURITY") , (AF_PACKET, "AF_PACKET") , (AF_ASH, "AF_ASH") , (AF_ECONET, "AF_ECONET") , (AF_ATMSVC, "AF_ATMSVC") , (AF_IRDA, "AF_IRDA") , (AF_PPPOX, "AF_PPPOX") , (AF_WANPIPE, "AF_WANPIPE") , (AF_BLUETOOTH, "AF_BLUETOOTH") , (AF_CAN, "AF_CAN") ] instance Show Family where showsPrec = bijectiveShow familyBijection def where gf = "GeneralFamily" def = defShow gf packFamily _showInt instance Read Family where readPrec = bijectiveRead familyBijection def where gf = "GeneralFamily" def = defRead gf unpackFamily _readInt -- Print "n" instead of "PortNum n". instance Show PortNumber where showsPrec p (PortNum pn) = showsPrec p pn -- Read "n" instead of "PortNum n". instance Read PortNumber where readPrec = safeInt ------------------------------------------------------------------------ -- Helper functions foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO () -- | Zero a structure. zeroMemory :: Ptr a -> CSize -> IO () zeroMemory dest nbytes = memset dest 0 (fromIntegral nbytes) network-3.1.4.0/Network/Socket/Unix.hsc0000644000000000000000000001473307346545000016052 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE ScopedTypeVariables #-} #include "HsNet.h" ##include "HsNetDef.h" module Network.Socket.Unix ( isUnixDomainSocketAvailable , socketPair , sendFd , recvFd , getPeerCredential , getPeerCred , getPeerEid ) where import Foreign.Marshal.Alloc (allocaBytes) import Network.Socket.Buffer import Network.Socket.Fcntl import Network.Socket.Imports import Network.Socket.Types import System.Posix.Types (Fd(..)) #if defined(mingw32_HOST_OS) import Network.Socket.Syscall import Network.Socket.Win32.Cmsg import System.Directory import System.IO import System.IO.Temp #else import Foreign.Marshal.Array (peekArray) import Network.Socket.Internal import Network.Socket.Posix.Cmsg #endif #if defined(HAVE_GETPEEREID) import System.IO.Error (catchIOError) #endif #ifdef HAVE_GETPEEREID import Foreign.Marshal.Alloc (alloca) #endif #ifdef HAVE_STRUCT_UCRED_SO_PEERCRED import Network.Socket.Options #endif -- | Getting process ID, user ID and group ID for UNIX-domain sockets. -- -- This is implemented with SO_PEERCRED on Linux and getpeereid() -- on BSD variants. Unfortunately, on some BSD variants -- getpeereid() returns unexpected results, rather than an error, -- for AF_INET sockets. It is the user's responsibility to make sure -- that the socket is a UNIX-domain socket. -- Also, on some BSD variants, getpeereid() does not return credentials -- for sockets created via 'socketPair', only separately created and then -- explicitly connected UNIX-domain sockets work on such systems. -- -- Since 2.7.0.0. getPeerCredential :: Socket -> IO (Maybe CUInt, Maybe CUInt, Maybe CUInt) #ifdef HAVE_STRUCT_UCRED_SO_PEERCRED getPeerCredential sock = do (pid, uid, gid) <- getPeerCred sock if uid == maxBound then return (Nothing, Nothing, Nothing) else return (Just pid, Just uid, Just gid) #elif defined(HAVE_GETPEEREID) getPeerCredential sock = go `catchIOError` \_ -> return (Nothing,Nothing,Nothing) where go = do (uid, gid) <- getPeerEid sock return (Nothing, Just uid, Just gid) #else getPeerCredential _ = return (Nothing, Nothing, Nothing) #endif -- | Returns the processID, userID and groupID of the peer of -- a UNIX-domain socket. -- -- Only available on platforms that support SO_PEERCRED. getPeerCred :: Socket -> IO (CUInt, CUInt, CUInt) #ifdef HAVE_STRUCT_UCRED_SO_PEERCRED getPeerCred s = do let opt = SockOpt (#const SOL_SOCKET) (#const SO_PEERCRED) PeerCred cred <- getSockOpt s opt return cred newtype PeerCred = PeerCred (CUInt, CUInt, CUInt) instance Storable PeerCred where sizeOf _ = (#const sizeof(struct ucred)) alignment _ = alignment (0 :: CInt) poke _ _ = return () peek p = do pid <- (#peek struct ucred, pid) p uid <- (#peek struct ucred, uid) p gid <- (#peek struct ucred, gid) p return $ PeerCred (pid, uid, gid) #else getPeerCred _ = return (0, 0, 0) #endif {-# Deprecated getPeerCred "Use getPeerCredential instead" #-} -- | Returns the userID and groupID of the peer of -- a UNIX-domain socket. -- -- Only available on platforms that support getpeereid(). getPeerEid :: Socket -> IO (CUInt, CUInt) #ifdef HAVE_GETPEEREID getPeerEid s = do alloca $ \ ptr_uid -> alloca $ \ ptr_gid -> do withFdSocket s $ \fd -> throwSocketErrorIfMinus1Retry_ "Network.Socket.getPeerEid" $ c_getpeereid fd ptr_uid ptr_gid uid <- peek ptr_uid gid <- peek ptr_gid return (uid, gid) foreign import CALLCONV unsafe "getpeereid" c_getpeereid :: CInt -> Ptr CUInt -> Ptr CUInt -> IO CInt #else getPeerEid _ = return (0, 0) #endif {-# Deprecated getPeerEid "Use getPeerCredential instead" #-} -- | Whether or not UNIX-domain sockets are available. -- 'AF_UNIX' is supported on Windows since 3.1.3.0. -- So, this variable is 'True` on all platforms. -- -- Since 2.7.0.0. isUnixDomainSocketAvailable :: Bool isUnixDomainSocketAvailable = True data NullSockAddr = NullSockAddr instance SocketAddress NullSockAddr where sizeOfSocketAddress _ = 0 peekSocketAddress _ = return NullSockAddr pokeSocketAddress _ _ = return () -- | Send a file descriptor over a UNIX-domain socket. -- This function does not work on Windows. sendFd :: Socket -> CInt -> IO () sendFd s outfd = void $ allocaBytes dummyBufSize $ \buf -> do let cmsg = encodeCmsg $ Fd outfd sendBufMsg s NullSockAddr [(buf,dummyBufSize)] [cmsg] mempty where dummyBufSize = 1 -- | Receive a file descriptor over a UNIX-domain socket. Note that the resulting -- file descriptor may have to be put into non-blocking mode in order to be -- used safely. See 'setNonBlockIfNeeded'. -- This function does not work on Windows. recvFd :: Socket -> IO CInt recvFd s = allocaBytes dummyBufSize $ \buf -> do (NullSockAddr, _, cmsgs, _) <- recvBufMsg s [(buf,dummyBufSize)] 32 mempty case (lookupCmsg CmsgIdFd cmsgs >>= decodeCmsg) :: Maybe Fd of Nothing -> return (-1) Just (Fd fd) -> return fd where dummyBufSize = 16 -- | Build a pair of connected socket objects. -- On Windows, this function emulates socketpair() using -- 'AF_UNIX' and a temporary file will remain. socketPair :: Family -- Family Name (usually AF_UNIX) -> SocketType -- Socket Type (usually Stream) -> ProtocolNumber -- Protocol Number -> IO (Socket, Socket) -- unnamed and connected. #if defined(mingw32_HOST_OS) socketPair _ _ _ = withSystemTempFile "temp-for-pair" $ \file hdl -> do hClose hdl removeFile file listenSock <- socket AF_UNIX Stream defaultProtocol bind listenSock $ SockAddrUnix file listen listenSock 10 clientSock <- socket AF_UNIX Stream defaultProtocol connect clientSock $ SockAddrUnix file (serverSock, _ :: SockAddr) <- accept listenSock close listenSock withFdSocket clientSock setNonBlockIfNeeded withFdSocket serverSock setNonBlockIfNeeded return (clientSock, serverSock) #else socketPair family stype protocol = allocaBytes (2 * sizeOf (1 :: CInt)) $ \ fdArr -> do let c_stype = packSocketType stype _rc <- throwSocketErrorIfMinus1Retry "Network.Socket.socketpair" $ c_socketpair (packFamily family) c_stype protocol fdArr [fd1,fd2] <- peekArray 2 fdArr setNonBlockIfNeeded fd1 setNonBlockIfNeeded fd2 s1 <- mkSocket fd1 s2 <- mkSocket fd2 return (s1, s2) foreign import ccall unsafe "socketpair" c_socketpair :: CInt -> CInt -> CInt -> Ptr CInt -> IO CInt #endif network-3.1.4.0/Network/Socket/Win32/0000755000000000000000000000000007346545000015322 5ustar0000000000000000network-3.1.4.0/Network/Socket/Win32/Cmsg.hsc0000644000000000000000000001574707346545000016730 0ustar0000000000000000 {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} module Network.Socket.Win32.Cmsg where #include "HsNet.h" import Data.ByteString.Internal import System.Posix.Types (Fd(..)) import Foreign.ForeignPtr import System.IO.Unsafe (unsafeDupablePerformIO) import Network.Socket.Imports import Network.Socket.Types import Network.Socket.ReadShow import qualified Text.Read as P type DWORD = Word32 type ULONG = Word32 -- | Control message (ancillary data) including a pair of level and type. data Cmsg = Cmsg { cmsgId :: !CmsgId , cmsgData :: !ByteString } deriving (Eq, Show) ---------------------------------------------------------------- -- | Identifier of control message (ancillary data). data CmsgId = CmsgId { cmsgLevel :: !CInt , cmsgType :: !CInt } deriving (Eq) -- | Unsupported identifier pattern UnsupportedCmsgId :: CmsgId pattern UnsupportedCmsgId = CmsgId (-1) (-1) -- | The identifier for 'IPv4TTL'. pattern CmsgIdIPv4TTL :: CmsgId pattern CmsgIdIPv4TTL = CmsgId (#const IPPROTO_IP) (#const IP_TTL) -- | The identifier for 'IPv6HopLimit'. pattern CmsgIdIPv6HopLimit :: CmsgId pattern CmsgIdIPv6HopLimit = CmsgId (#const IPPROTO_IPV6) (#const IPV6_HOPLIMIT) -- | The identifier for 'IPv4TOS'. pattern CmsgIdIPv4TOS :: CmsgId pattern CmsgIdIPv4TOS = CmsgId (#const IPPROTO_IP) (#const IP_TOS) -- | The identifier for 'IPv6TClass'. pattern CmsgIdIPv6TClass :: CmsgId pattern CmsgIdIPv6TClass = CmsgId (#const IPPROTO_IPV6) (#const IPV6_TCLASS) -- | The identifier for 'IPv4PktInfo'. pattern CmsgIdIPv4PktInfo :: CmsgId pattern CmsgIdIPv4PktInfo = CmsgId (#const IPPROTO_IP) (#const IP_PKTINFO) -- | The identifier for 'IPv6PktInfo'. pattern CmsgIdIPv6PktInfo :: CmsgId pattern CmsgIdIPv6PktInfo = CmsgId (#const IPPROTO_IPV6) (#const IPV6_PKTINFO) -- | Control message ID for POSIX file-descriptor passing. -- -- Not supported on Windows; use WSADuplicateSocket instead pattern CmsgIdFd :: CmsgId pattern CmsgIdFd = CmsgId (-1) (-1) ---------------------------------------------------------------- -- | Looking up control message. The following shows an example usage: -- -- > (lookupCmsg CmsgIdIPv4TOS cmsgs >>= decodeCmsg) :: Maybe IPv4TOS lookupCmsg :: CmsgId -> [Cmsg] -> Maybe Cmsg lookupCmsg _ [] = Nothing lookupCmsg cid (cmsg:cmsgs) | cmsgId cmsg == cid = Just cmsg | otherwise = lookupCmsg cid cmsgs -- | Filtering control message. filterCmsg :: CmsgId -> [Cmsg] -> [Cmsg] filterCmsg cid cmsgs = filter (\cmsg -> cmsgId cmsg == cid) cmsgs ---------------------------------------------------------------- -- | A class to encode and decode control message. class Storable a => ControlMessage a where controlMessageId :: CmsgId encodeCmsg :: forall a. ControlMessage a => a -> Cmsg encodeCmsg x = unsafeDupablePerformIO $ do bs <- create siz $ \p0 -> do let p = castPtr p0 poke p x let cmsid = controlMessageId @a return $ Cmsg cmsid bs where siz = sizeOf x decodeCmsg :: forall a . (ControlMessage a, Storable a) => Cmsg -> Maybe a decodeCmsg (Cmsg cmsid (PS fptr off len)) | cid /= cmsid = Nothing | len < siz = Nothing | otherwise = unsafeDupablePerformIO $ withForeignPtr fptr $ \p0 -> do let p = castPtr (p0 `plusPtr` off) Just <$> peek p where cid = controlMessageId @a siz = sizeOf (undefined :: a) ---------------------------------------------------------------- -- | Time to live of IPv4. newtype IPv4TTL = IPv4TTL DWORD deriving (Eq, Show, Storable) instance ControlMessage IPv4TTL where controlMessageId = CmsgIdIPv4TTL ---------------------------------------------------------------- -- | Hop limit of IPv6. newtype IPv6HopLimit = IPv6HopLimit DWORD deriving (Eq, Show, Storable) instance ControlMessage IPv6HopLimit where controlMessageId = CmsgIdIPv6HopLimit ---------------------------------------------------------------- -- | TOS of IPv4. newtype IPv4TOS = IPv4TOS DWORD deriving (Eq, Show, Storable) instance ControlMessage IPv4TOS where controlMessageId = CmsgIdIPv4TOS ---------------------------------------------------------------- -- | Traffic class of IPv6. newtype IPv6TClass = IPv6TClass DWORD deriving (Eq, Show, Storable) instance ControlMessage IPv6TClass where controlMessageId = CmsgIdIPv6TClass ---------------------------------------------------------------- -- | Network interface ID and local IPv4 address. The second member is -- redundant to be the same as Unix's one and is always 0.0.0.0. data IPv4PktInfo = IPv4PktInfo Int HostAddress HostAddress deriving (Eq) instance Show IPv4PktInfo where show (IPv4PktInfo n sa ha) = "IPv4PktInfo " ++ show n ++ " " ++ show (hostAddressToTuple sa) ++ " " ++ show (hostAddressToTuple ha) instance ControlMessage IPv4PktInfo where controlMessageId = CmsgIdIPv4PktInfo instance Storable IPv4PktInfo where sizeOf _ = #{size IN_PKTINFO} alignment _ = #alignment IN_PKTINFO poke p (IPv4PktInfo n _ ha) = do (#poke IN_PKTINFO, ipi_ifindex) p (fromIntegral n :: CInt) (#poke IN_PKTINFO, ipi_addr) p ha peek p = do n <- (#peek IN_PKTINFO, ipi_ifindex) p ha <- (#peek IN_PKTINFO, ipi_addr) p return $ IPv4PktInfo n 0 ha ---------------------------------------------------------------- -- | Network interface ID and local IPv4 address. data IPv6PktInfo = IPv6PktInfo Int HostAddress6 deriving (Eq) instance Show IPv6PktInfo where show (IPv6PktInfo n ha6) = "IPv6PktInfo " ++ show n ++ " " ++ show (hostAddress6ToTuple ha6) instance ControlMessage IPv6PktInfo where controlMessageId = CmsgIdIPv6PktInfo instance Storable IPv6PktInfo where sizeOf _ = #{size IN6_PKTINFO} alignment _ = #alignment IN6_PKTINFO poke p (IPv6PktInfo n ha6) = do (#poke IN6_PKTINFO, ipi6_ifindex) p (fromIntegral n :: CInt) (#poke IN6_PKTINFO, ipi6_addr) p (In6Addr ha6) peek p = do In6Addr ha6 <- (#peek IN6_PKTINFO, ipi6_addr) p n :: ULONG <- (#peek IN6_PKTINFO, ipi6_ifindex) p return $ IPv6PktInfo (fromIntegral n) ha6 instance ControlMessage Fd where controlMessageId = CmsgIdFd cmsgIdBijection :: Bijection CmsgId String cmsgIdBijection = [ (UnsupportedCmsgId, "UnsupportedCmsgId") , (CmsgIdIPv4TTL, "CmsgIdIPv4TTL") , (CmsgIdIPv6HopLimit, "CmsgIdIPv6HopLimit") , (CmsgIdIPv4TOS, "CmsgIdIPv4TOS") , (CmsgIdIPv6TClass, "CmsgIdIPv6TClass") , (CmsgIdIPv4PktInfo, "CmsgIdIPv4PktInfo") , (CmsgIdIPv6PktInfo, "CmsgIdIPv6PktInfo") , (CmsgIdFd, "CmsgIdFd") ] instance Show CmsgId where showsPrec = bijectiveShow cmsgIdBijection def where defname = "CmsgId" unId = \(CmsgId l t) -> (l,t) def = defShow defname unId showIntInt instance Read CmsgId where readPrec = bijectiveRead cmsgIdBijection def where defname = "CmsgId" def = defRead defname (uncurry CmsgId) readIntInt network-3.1.4.0/Network/Socket/Win32/CmsgHdr.hsc0000644000000000000000000000610007346545000017345 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} #include "HsNet.h" module Network.Socket.Win32.CmsgHdr ( Cmsg(..) , withCmsgs , parseCmsgs ) where import Foreign.Marshal.Alloc (allocaBytes) import Foreign.ForeignPtr import qualified Data.ByteString as B import Data.ByteString.Internal import Network.Socket.Imports import Network.Socket.Win32.Cmsg import Network.Socket.Win32.MsgHdr import Network.Socket.Types data CmsgHdr = CmsgHdr { cmsgHdrLen :: !CUInt , cmsgHdrLevel :: !CInt , cmsgHdrType :: !CInt } deriving (Eq, Show) instance Storable CmsgHdr where sizeOf _ = #{size WSACMSGHDR} alignment _ = #alignment WSACMSGHDR peek p = do len <- (#peek WSACMSGHDR, cmsg_len) p lvl <- (#peek WSACMSGHDR, cmsg_level) p typ <- (#peek WSACMSGHDR, cmsg_type) p return $ CmsgHdr len lvl typ poke p (CmsgHdr len lvl typ) = do zeroMemory p (#size WSACMSGHDR) (#poke WSACMSGHDR, cmsg_len) p len (#poke WSACMSGHDR, cmsg_level) p lvl (#poke WSACMSGHDR, cmsg_type) p typ withCmsgs :: [Cmsg] -> (Ptr CmsgHdr -> Int -> IO a) -> IO a withCmsgs cmsgs0 action | total == 0 = action nullPtr 0 | otherwise = allocaBytes total $ \ctrlPtr -> do loop ctrlPtr cmsgs0 spaces action ctrlPtr total where loop ctrlPtr (cmsg:cmsgs) (s:ss) = do toCmsgHdr cmsg ctrlPtr let nextPtr = ctrlPtr `plusPtr` s loop nextPtr cmsgs ss loop _ _ _ = return () cmsg_space = fromIntegral . c_cmsg_space . fromIntegral spaces = map (cmsg_space . B.length . cmsgData) cmsgs0 total = sum spaces toCmsgHdr :: Cmsg -> Ptr CmsgHdr -> IO () toCmsgHdr (Cmsg (CmsgId lvl typ) (PS fptr off len)) ctrlPtr = do poke ctrlPtr $ CmsgHdr (c_cmsg_len (fromIntegral len)) lvl typ withForeignPtr fptr $ \src0 -> do let src = src0 `plusPtr` off dst <- c_cmsg_data ctrlPtr memcpy dst src len parseCmsgs :: SocketAddress sa => Ptr (MsgHdr sa) -> IO [Cmsg] parseCmsgs msgptr = do ptr <- c_cmsg_firsthdr msgptr loop ptr id where loop ptr build | ptr == nullPtr = return $ build [] | otherwise = do val <- fromCmsgHdr ptr case val of Nothing -> return $ build [] Just cmsg -> do nextPtr <- c_cmsg_nxthdr msgptr ptr loop nextPtr (build . (cmsg :)) fromCmsgHdr :: Ptr CmsgHdr -> IO (Maybe Cmsg) fromCmsgHdr ptr = do CmsgHdr len lvl typ <- peek ptr src <- c_cmsg_data ptr let siz = fromIntegral len - (src `minusPtr` ptr) if siz < 0 then return Nothing else Just . Cmsg (CmsgId lvl typ) <$> create (fromIntegral siz) (\dst -> memcpy dst src siz) foreign import ccall unsafe "cmsg_firsthdr" c_cmsg_firsthdr :: Ptr (MsgHdr sa) -> IO (Ptr CmsgHdr) foreign import ccall unsafe "cmsg_nxthdr" c_cmsg_nxthdr :: Ptr (MsgHdr sa) -> Ptr CmsgHdr -> IO (Ptr CmsgHdr) foreign import ccall unsafe "cmsg_data" c_cmsg_data :: Ptr CmsgHdr -> IO (Ptr Word8) foreign import ccall unsafe "cmsg_space" c_cmsg_space :: CUInt -> CUInt foreign import ccall unsafe "cmsg_len" c_cmsg_len :: CUInt -> CUInt network-3.1.4.0/Network/Socket/Win32/MsgHdr.hsc0000644000000000000000000000363307346545000017212 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} {-# LANGUAGE CPP #-} -- | Support module for the Windows 'WSASendMsg' system call. module Network.Socket.Win32.MsgHdr ( MsgHdr(..) ) where #include "HsNet.h" import Network.Socket.Imports import Network.Socket.Internal (zeroMemory) import Network.Socket.Win32.WSABuf type DWORD = Word32 type ULONG = Word32 -- The size of BufferLen is different on pre-vista compilers. -- But since those platforms are out of support anyway we ignore that. data MsgHdr sa = MsgHdr { msgName :: !(Ptr sa) , msgNameLen :: !CInt , msgBuffer :: !(Ptr WSABuf) , msgBufferLen :: !DWORD , msgCtrl :: !(Ptr Word8) , msgCtrlLen :: !ULONG , msgFlags :: !DWORD } deriving Show instance Storable (MsgHdr sa) where sizeOf _ = #{size WSAMSG} alignment _ = #alignment WSAMSG peek p = do name <- (#peek WSAMSG, name) p nameLen <- (#peek WSAMSG, namelen) p buffer <- (#peek WSAMSG, lpBuffers) p bufferLen <- (#peek WSAMSG, dwBufferCount) p ctrl <- (#peek WSAMSG, Control.buf) p ctrlLen <- (#peek WSAMSG, Control.len) p flags <- (#peek WSAMSG, dwFlags) p return $ MsgHdr name nameLen buffer bufferLen ctrl ctrlLen flags poke p mh = do -- We need to zero the msg_control, msg_controllen, and msg_flags -- fields, but they only exist on some platforms (e.g. not on -- Solaris). Instead of using CPP, we zero the entire struct. zeroMemory p (#const sizeof(WSAMSG)) (#poke WSAMSG, name) p (msgName mh) (#poke WSAMSG, namelen) p (msgNameLen mh) (#poke WSAMSG, lpBuffers) p (msgBuffer mh) (#poke WSAMSG, dwBufferCount) p (msgBufferLen mh) (#poke WSAMSG, Control.buf) p (msgCtrl mh) (#poke WSAMSG, Control.len) p (msgCtrlLen mh) (#poke WSAMSG, dwFlags) p (msgFlags mh) network-3.1.4.0/Network/Socket/Win32/WSABuf.hsc0000644000000000000000000000246307346545000017115 0ustar0000000000000000{-# OPTIONS_GHC -funbox-strict-fields #-} -- | Support module for the Windows winsock system calls. module Network.Socket.Win32.WSABuf ( WSABuf(..) , withWSABuf ) where #include "HsNet.h" import Foreign.Marshal.Array (allocaArray) import Network.Socket.Imports type ULONG = Word32 data WSABuf = WSABuf { wsaBufPtr :: !(Ptr Word8) , wsaBufLen :: !ULONG } instance Storable WSABuf where sizeOf _ = #{size WSABUF} alignment _ = #alignment WSABUF peek p = do base <- (#peek WSABUF, buf) p len <- (#peek WSABUF, len) p return $ WSABuf base len poke p iov = do (#poke WSABUF, buf) p (wsaBufPtr iov) (#poke WSABUF, len) p (wsaBufLen iov) -- | @withWSABuf cs f@ executes the computation @f@, passing as argument a pair -- consisting of a pointer to a temporarily allocated array of pointers to -- WSABBUF made from @cs@ and the number of pointers (@length cs@). -- /Windows only/. withWSABuf :: [(Ptr Word8, Int)] -> ((Ptr WSABuf, Int) -> IO a) -> IO a withWSABuf [] f = f (nullPtr, 0) withWSABuf cs f = allocaArray csLen $ \aPtr -> do zipWithM_ pokeWsaBuf (ptrs aPtr) cs f (aPtr, csLen) where csLen = length cs ptrs = iterate (`plusPtr` sizeOf (WSABuf nullPtr 0)) pokeWsaBuf ptr (sPtr, sLen) = poke ptr $ WSABuf sPtr (fromIntegral sLen) network-3.1.4.0/README.md0000644000000000000000000000337307346545000013024 0ustar0000000000000000![GitHub Actions status](https://github.com/haskell/network/workflows/Haskell%20CI/badge.svg) # [`network`](http://hackage.haskell.org/package/network) To build this package directly from git, you must run `autoreconf -i`. And then use `cabal configure; cabal build` or `stack build`. ## Support Policy ### GHC The `network` package support [3 major versions of GHC](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/intro.html#ghc-version-numbering-policy) only. This means that the current stable version and two previous stable versions are supported. However, all GHC 8.x are supported currently. ### Windows We use MSYS to build this package on Windows. To use the `network` package on Cygwin, use `stack`. ## Coding ### .hs files If you need C macros created by "configure" or `CALLCONV`/`SAFE_ON_WIN`, put ``` #include "HsNetDef.h" ``` "HsNet.h" does now work well since Mac's cpp sucks. ### .hsc files If you need `#peek`, `#poke` and others, create a `.hsc` file with ``` #include "HsNet.h" ``` `HsNet.h` includes `HsNefDef.h` and necessary C structures. Unfortunately, `hsc2hs` does not convert C macros. So, if you use `CALLCONV`/`SAFE_ON_WIN`, the following is also necessary: ``` ##include "HsNetDef.h" ``` ## Milestones ### 2.6 - [x] Making `SockAddrCan` deprecated ### 2.7 See https://github.com/haskell/network/issues/296 - [x] Making `Network` deprecated - [x] Making `Network.BSD` deprecated - [x] Making `MkSocket` deprecated - [x] Making many APIs deprecated ### 2.8 - [x] Stop exporting the `PortNum` Constructor in `PortNumber` ### 3.0 - [x] Removing `Network` - [x] Removing `Network.BSD` - [x] Removing `SockAddrCan` - [x] Changing the internal structure of `Socket`. - [x] Make address extensible. - [x] Remove EOF errors network-3.1.4.0/Setup.hs0000644000000000000000000000016207346545000013172 0ustar0000000000000000module Main (main) where import Distribution.Simple main :: IO () main = defaultMainWithHooks autoconfUserHooks network-3.1.4.0/cbits/0000755000000000000000000000000007346545000012643 5ustar0000000000000000network-3.1.4.0/cbits/HsNet.c0000644000000000000000000000044607346545000014034 0ustar0000000000000000/* ----------------------------------------------------------------------------- * (c) The University of Glasgow 2002 * * static versions of the inline functions from HsNet.h * -------------------------------------------------------------------------- */ #define INLINE #include "HsNet.h" network-3.1.4.0/cbits/asyncAccept.c0000644000000000000000000000251507346545000015247 0ustar0000000000000000/* * (c) sof, 2003. */ #include "HsNet.h" #include "HsFFI.h" #if defined(_WIN32) /* all the way to the end */ /* * To support non-blocking accept()s with WinSock, we use the asyncDoProc# * primop, which lets a Haskell thread call an external routine without * blocking the progress of other threads. * * As can readily be seen, this is a low-level mechanism. * */ typedef struct AcceptData { int fdSock; int newSock; void* sockAddr; int size; } AcceptData; /* * Fill in parameter block that's passed along when the RTS invokes the * accept()-calling proc below (acceptDoProc()) */ void* newAcceptParams(int sock, int sz, void* sockaddr) { AcceptData* data = (AcceptData*)malloc(sizeof(AcceptData)); if (!data) return NULL; data->fdSock = sock; data->newSock = 0; data->sockAddr = sockaddr; data->size = sz; return data; } /* Accessors for return code and accept()'s socket result. */ int acceptNewSock(void* d) { return (((AcceptData*)d)->newSock); } /* Routine invoked by an RTS worker thread */ int acceptDoProc(void* param) { SOCKET s; AcceptData* data = (AcceptData*)param; s = accept( data->fdSock, data->sockAddr, &data->size); data->newSock = s; if ( s == INVALID_SOCKET ) { return GetLastError(); } else { return 0; } } #endif network-3.1.4.0/cbits/cmsg.c0000644000000000000000000000463407346545000013747 0ustar0000000000000000#include "HsNet.h" #include #ifdef _WIN32 LPWSACMSGHDR cmsg_firsthdr(LPWSAMSG mhdr) { return (WSA_CMSG_FIRSTHDR(mhdr)); } LPWSACMSGHDR cmsg_nxthdr(LPWSAMSG mhdr, LPWSACMSGHDR cmsg) { return (WSA_CMSG_NXTHDR(mhdr, cmsg)); } unsigned char *cmsg_data(LPWSACMSGHDR cmsg) { return (WSA_CMSG_DATA(cmsg)); } unsigned int cmsg_space(unsigned int l) { return (WSA_CMSG_SPACE(l)); } unsigned int cmsg_len(unsigned int l) { return (WSA_CMSG_LEN(l)); } static LPFN_WSASENDMSG ptr_SendMsg; static LPFN_WSARECVMSG ptr_RecvMsg; /* GUIDS to lookup WSASend/RecvMsg */ static GUID WSARecvMsgGUID = WSAID_WSARECVMSG; static GUID WSASendMsgGUID = WSAID_WSASENDMSG; int WINAPI WSASendMsg (SOCKET s, LPWSAMSG lpMsg, DWORD flags, LPDWORD lpdwNumberOfBytesRecvd, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) { if (!ptr_SendMsg) { DWORD len; if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsgGUID, sizeof(WSASendMsgGUID), &ptr_SendMsg, sizeof(ptr_SendMsg), &len, NULL, NULL) != 0) return -1; } return ptr_SendMsg (s, lpMsg, flags, lpdwNumberOfBytesRecvd, lpOverlapped, lpCompletionRoutine); } /** * WSARecvMsg function */ int WINAPI WSARecvMsg (SOCKET s, LPWSAMSG lpMsg, LPDWORD lpdwNumberOfBytesRecvd, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) { if (!ptr_RecvMsg) { DWORD len; if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsgGUID, sizeof(WSARecvMsgGUID), &ptr_RecvMsg, sizeof(ptr_RecvMsg), &len, NULL, NULL) != 0) return -1; } int res = ptr_RecvMsg (s, lpMsg, lpdwNumberOfBytesRecvd, lpOverlapped, lpCompletionRoutine); /* If the msg was truncated then this pointer can be garbage. */ if (res == SOCKET_ERROR && GetLastError () == WSAEMSGSIZE) { lpMsg->Control.len = 0; lpMsg->Control.buf = NULL; } return res; } #else struct cmsghdr *cmsg_firsthdr(struct msghdr *mhdr) { return (CMSG_FIRSTHDR(mhdr)); } struct cmsghdr *cmsg_nxthdr(struct msghdr *mhdr, struct cmsghdr *cmsg) { return (CMSG_NXTHDR(mhdr, cmsg)); } unsigned char *cmsg_data(struct cmsghdr *cmsg) { return (CMSG_DATA(cmsg)); } size_t cmsg_space(size_t l) { return (CMSG_SPACE(l)); } size_t cmsg_len(size_t l) { return (CMSG_LEN(l)); } #endif /* _WIN32 */ network-3.1.4.0/cbits/initWinSock.c0000644000000000000000000000173607346545000015257 0ustar0000000000000000#include "HsNet.h" #include "HsFFI.h" #if defined(_WIN32) static int winsock_inited = 0; static void shutdownHandler(void) { WSACleanup(); } /* Initialising WinSock... */ int initWinSock () { WORD wVersionRequested; WSADATA wsaData; int err; if (!winsock_inited) { wVersionRequested = MAKEWORD( 2, 2 ); err = WSAStartup ( wVersionRequested, &wsaData ); if ( err != 0 ) { return err; } if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 2 ) { WSACleanup(); return (-1); } atexit(shutdownHandler); winsock_inited = 1; } return 0; } SOCKET wsaDuplicate (SOCKET s) { WSAPROTOCOL_INFOW protocolInfo; if (WSADuplicateSocketW (s, GetCurrentProcessId (), &protocolInfo) != 0) return -1; SOCKET res = WSASocketW(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, &protocolInfo, 0, 0); if (res == SOCKET_ERROR) return -1; return res; } #endif network-3.1.4.0/cbits/winSockErr.c0000644000000000000000000001034107346545000015074 0ustar0000000000000000#include "HsNet.h" #include "HsFFI.h" #if defined(_WIN32) #include /* to the end */ const char* getWSErrorDescr(int err) { static char otherErrMsg[256]; switch (err) { case WSAEINTR: return "Interrupted function call (WSAEINTR)"; case WSAEBADF: return "bad socket descriptor (WSAEBADF)"; case WSAEACCES: return "Permission denied (WSAEACCESS)"; case WSAEFAULT: return "Bad address (WSAEFAULT)"; case WSAEINVAL: return "Invalid argument (WSAEINVAL)"; case WSAEMFILE: return "Too many open files (WSAEMFILE)"; case WSAEWOULDBLOCK: return "Resource temporarily unavailable (WSAEWOULDBLOCK)"; case WSAEINPROGRESS: return "Operation now in progress (WSAEINPROGRESS)"; case WSAEALREADY: return "Operation already in progress (WSAEALREADY)"; case WSAENOTSOCK: return "Socket operation on non-socket (WSAENOTSOCK)"; case WSAEDESTADDRREQ: return "Destination address required (WSAEDESTADDRREQ)"; case WSAEMSGSIZE: return "Message too long (WSAEMSGSIZE)"; case WSAEPROTOTYPE: return "Protocol wrong type for socket (WSAEPROTOTYPE)"; case WSAENOPROTOOPT: return "Bad protocol option (WSAENOPROTOOPT)"; case WSAEPROTONOSUPPORT: return "Protocol not supported (WSAEPROTONOSUPPORT)"; case WSAESOCKTNOSUPPORT: return "Socket type not supported (WSAESOCKTNOSUPPORT)"; case WSAEOPNOTSUPP: return "Operation not supported (WSAEOPNOTSUPP)"; case WSAEPFNOSUPPORT: return "Protocol family not supported (WSAEPFNOSUPPORT)"; case WSAEAFNOSUPPORT: return "Address family not supported by protocol family (WSAEAFNOSUPPORT)"; case WSAEADDRINUSE: return "Address already in use (WSAEADDRINUSE)"; case WSAEADDRNOTAVAIL: return "Cannot assign requested address (WSAEADDRNOTAVAIL)"; case WSAENETDOWN: return "Network is down (WSAENETDOWN)"; case WSAENETUNREACH: return "Network is unreachable (WSAENETUNREACH)"; case WSAENETRESET: return "Network dropped connection on reset (WSAENETRESET)"; case WSAECONNABORTED: return "Software caused connection abort (WSAECONNABORTED)"; case WSAECONNRESET: return "Connection reset by peer (WSAECONNRESET)"; case WSAENOBUFS: return "No buffer space available (WSAENOBUFS)"; case WSAEISCONN: return "Socket is already connected (WSAEISCONN)"; case WSAENOTCONN: return "Socket is not connected (WSAENOTCONN)"; case WSAESHUTDOWN: return "Cannot send after socket shutdown (WSAESHUTDOWN)"; case WSAETOOMANYREFS: return "Too many references (WSAETOOMANYREFS)"; case WSAETIMEDOUT: return "Connection timed out (WSAETIMEDOUT)"; case WSAECONNREFUSED: return "Connection refused (WSAECONNREFUSED)"; case WSAELOOP: return "Too many levels of symbolic links (WSAELOOP)"; case WSAENAMETOOLONG: return "Filename too long (WSAENAMETOOLONG)"; case WSAEHOSTDOWN: return "Host is down (WSAEHOSTDOWN)"; case WSAEHOSTUNREACH: return "Host is unreachable (WSAEHOSTUNREACH)"; case WSAENOTEMPTY: return "Resource not empty (WSAENOTEMPTY)"; case WSAEPROCLIM: return "Too many processes (WSAEPROCLIM)"; case WSAEUSERS: return "Too many users (WSAEUSERS)"; case WSAEDQUOT: return "Disk quota exceeded (WSAEDQUOT)"; case WSAESTALE: return "Stale NFS file handle (WSAESTALE)"; case WSAEREMOTE: return "Too many levels of remote in path (WSAEREMOTE)"; case WSAEDISCON: return "Graceful shutdown in progress (WSAEDISCON)"; case WSASYSNOTREADY: return "Network subsystem is unavailable (WSASYSNOTREADY)"; case WSAVERNOTSUPPORTED: return "Winsock.dll version out of range (WSAVERNOTSUPPORTED)"; case WSANOTINITIALISED: return "Successful WSAStartup not yet performed (WSANOTINITIALISED)"; #ifdef WSATYPE_NOT_FOUND case WSATYPE_NOT_FOUND: return "Class type not found (WSATYPE_NOT_FOUND)"; #endif case WSAHOST_NOT_FOUND: return "Host not found (WSAHOST_NOT_FOUND)"; case WSATRY_AGAIN: return "Nonauthoritative host not found (WSATRY_AGAIN)"; case WSANO_RECOVERY: return "This is a nonrecoverable error (WSANO_RECOVERY)"; case WSANO_DATA: return "Valid name, no data record of requested type (WSANO_DATA)"; default: sprintf(otherErrMsg, "Unknown WinSock error: %u", err); return otherErrMsg; } } #endif network-3.1.4.0/config.guess0000644000000000000000000014030407346545000014056 0ustar0000000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright 1992-2021 Free Software Foundation, Inc. # shellcheck disable=SC2006,SC2268 # see below for rationale timestamp='2021-06-03' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: # https://git.savannah.gnu.org/cgit/config.git/plain/config.guess # # Please send patches to . # The "shellcheck disable" line above the timestamp inhibits complaints # about features and limitations of the classic Bourne shell that were # superseded or lifted in POSIX. However, this script identifies a wide # variety of pre-POSIX systems that do not have POSIX shells at all, and # even some reasonably current systems (Solaris 10 as case-in-point) still # have a pre-POSIX /bin/sh. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright 1992-2021 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi # Just in case it came from the environment. GUESS= # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. tmp= # shellcheck disable=SC2172 trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15 set_cc_for_build() { # prevent multiple calls if $tmp is already set test "$tmp" && return 0 : "${TMPDIR=/tmp}" # shellcheck disable=SC2039,SC3028 { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } dummy=$tmp/dummy case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in ,,) echo "int x;" > "$dummy.c" for driver in cc gcc c89 c99 ; do if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then CC_FOR_BUILD=$driver break fi done if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac } # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if test -f /.attbin/uname ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown case $UNAME_SYSTEM in Linux|GNU|GNU/*) LIBC=unknown set_cc_for_build cat <<-EOF > "$dummy.c" #include #if defined(__UCLIBC__) LIBC=uclibc #elif defined(__dietlibc__) LIBC=dietlibc #elif defined(__GLIBC__) LIBC=gnu #else #include /* First heuristic to detect musl libc. */ #ifdef __DEFINED_va_list LIBC=musl #endif #endif EOF cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` eval "$cc_set_libc" # Second heuristic to detect musl libc. if [ "$LIBC" = unknown ] && command -v ldd >/dev/null && ldd --version 2>&1 | grep -q ^musl; then LIBC=musl fi # If the system lacks a compiler, then just pick glibc. # We could probably try harder. if [ "$LIBC" = unknown ]; then LIBC=gnu fi ;; esac # Note: order is significant - the case branches are not exclusive. case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ /sbin/sysctl -n hw.machine_arch 2>/dev/null || \ /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \ echo unknown)` case $UNAME_MACHINE_ARCH in aarch64eb) machine=aarch64_be-unknown ;; armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; earmv*) arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` machine=${arch}${endian}-unknown ;; *) machine=$UNAME_MACHINE_ARCH-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently (or will in the future) and ABI. case $UNAME_MACHINE_ARCH in earm*) os=netbsdelf ;; arm*|i386|m68k|ns32k|sh3*|sparc|vax) set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # Determine ABI tags. case $UNAME_MACHINE_ARCH in earm*) expr='s/^earmv[0-9]/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case $UNAME_VERSION in Debian*) release='-gnu' ;; *) release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. GUESS=$machine-${os}${release}${abi-} ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE ;; *:SecBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE ;; *:LibertyBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE ;; *:MidnightBSD:*:*) GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE ;; *:ekkoBSD:*:*) GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE ;; *:SolidBSD:*:*) GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE ;; *:OS108:*:*) GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE ;; macppc:MirBSD:*:*) GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE ;; *:MirBSD:*:*) GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE ;; *:Sortix:*:*) GUESS=$UNAME_MACHINE-unknown-sortix ;; *:Twizzler:*:*) GUESS=$UNAME_MACHINE-unknown-twizzler ;; *:Redox:*:*) GUESS=$UNAME_MACHINE-unknown-redox ;; mips:OSF1:*.*) GUESS=mips-dec-osf1 ;; alpha:OSF1:*:*) # Reset EXIT trap before exiting to avoid spurious non-zero exit code. trap '' 0 case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case $ALPHA_CPU_TYPE in "EV4 (21064)") UNAME_MACHINE=alpha ;; "EV4.5 (21064)") UNAME_MACHINE=alpha ;; "LCA4 (21066/21068)") UNAME_MACHINE=alpha ;; "EV5 (21164)") UNAME_MACHINE=alphaev5 ;; "EV5.6 (21164A)") UNAME_MACHINE=alphaev56 ;; "EV5.6 (21164PC)") UNAME_MACHINE=alphapca56 ;; "EV5.7 (21164PC)") UNAME_MACHINE=alphapca57 ;; "EV6 (21264)") UNAME_MACHINE=alphaev6 ;; "EV6.7 (21264A)") UNAME_MACHINE=alphaev67 ;; "EV6.8CB (21264C)") UNAME_MACHINE=alphaev68 ;; "EV6.8AL (21264B)") UNAME_MACHINE=alphaev68 ;; "EV6.8CX (21264D)") UNAME_MACHINE=alphaev68 ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE=alphaev69 ;; "EV7 (21364)") UNAME_MACHINE=alphaev7 ;; "EV7.9 (21364A)") UNAME_MACHINE=alphaev79 ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` GUESS=$UNAME_MACHINE-dec-osf$OSF_REL ;; Amiga*:UNIX_System_V:4.0:*) GUESS=m68k-unknown-sysv4 ;; *:[Aa]miga[Oo][Ss]:*:*) GUESS=$UNAME_MACHINE-unknown-amigaos ;; *:[Mm]orph[Oo][Ss]:*:*) GUESS=$UNAME_MACHINE-unknown-morphos ;; *:OS/390:*:*) GUESS=i370-ibm-openedition ;; *:z/VM:*:*) GUESS=s390-ibm-zvmoe ;; *:OS400:*:*) GUESS=powerpc-ibm-os400 ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) GUESS=arm-acorn-riscix$UNAME_RELEASE ;; arm*:riscos:*:*|arm*:RISCOS:*:*) GUESS=arm-unknown-riscos ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) GUESS=hppa1.1-hitachi-hiuxmpp ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. case `(/bin/universe) 2>/dev/null` in att) GUESS=pyramid-pyramid-sysv3 ;; *) GUESS=pyramid-pyramid-bsd ;; esac ;; NILE*:*:*:dcosx) GUESS=pyramid-pyramid-svr4 ;; DRS?6000:unix:4.0:6*) GUESS=sparc-icl-nx6 ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) GUESS=sparc-icl-nx7 ;; esac ;; s390x:SunOS:*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL ;; sun4H:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-hal-solaris2$SUN_REL ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-sun-solaris2$SUN_REL ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) GUESS=i386-pc-auroraux$UNAME_RELEASE ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) set_cc_for_build SUN_ARCH=i386 # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH=x86_64 fi fi SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=$SUN_ARCH-pc-solaris2$SUN_REL ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=sparc-sun-solaris3$SUN_REL ;; sun4*:SunOS:*:*) case `/usr/bin/arch -k` in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'` GUESS=sparc-sun-sunos$SUN_REL ;; sun3*:SunOS:*:*) GUESS=m68k-sun-sunos$UNAME_RELEASE ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 case `/bin/arch` in sun3) GUESS=m68k-sun-sunos$UNAME_RELEASE ;; sun4) GUESS=sparc-sun-sunos$UNAME_RELEASE ;; esac ;; aushp:SunOS:*:*) GUESS=sparc-auspex-sunos$UNAME_RELEASE ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) GUESS=m68k-atari-mint$UNAME_RELEASE ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) GUESS=m68k-milan-mint$UNAME_RELEASE ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) GUESS=m68k-hades-mint$UNAME_RELEASE ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) GUESS=m68k-unknown-mint$UNAME_RELEASE ;; m68k:machten:*:*) GUESS=m68k-apple-machten$UNAME_RELEASE ;; powerpc:machten:*:*) GUESS=powerpc-apple-machten$UNAME_RELEASE ;; RISC*:Mach:*:*) GUESS=mips-dec-mach_bsd4.3 ;; RISC*:ULTRIX:*:*) GUESS=mips-dec-ultrix$UNAME_RELEASE ;; VAX*:ULTRIX*:*:*) GUESS=vax-dec-ultrix$UNAME_RELEASE ;; 2020:CLIX:*:* | 2430:CLIX:*:*) GUESS=clipper-intergraph-clix$UNAME_RELEASE ;; mips:*:*:UMIPS | mips:*:*:RISCos) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`"$dummy" "$dummyarg"` && { echo "$SYSTEM_NAME"; exit; } GUESS=mips-mips-riscos$UNAME_RELEASE ;; Motorola:PowerMAX_OS:*:*) GUESS=powerpc-motorola-powermax ;; Motorola:*:4.3:PL8-*) GUESS=powerpc-harris-powermax ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) GUESS=powerpc-harris-powermax ;; Night_Hawk:Power_UNIX:*:*) GUESS=powerpc-harris-powerunix ;; m88k:CX/UX:7*:*) GUESS=m88k-harris-cxux7 ;; m88k:*:4*:R4*) GUESS=m88k-motorola-sysv4 ;; m88k:*:3*:R3*) GUESS=m88k-motorola-sysv3 ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110 then if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \ test "$TARGET_BINARY_INTERFACE"x = x then GUESS=m88k-dg-dgux$UNAME_RELEASE else GUESS=m88k-dg-dguxbcs$UNAME_RELEASE fi else GUESS=i586-dg-dgux$UNAME_RELEASE fi ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) GUESS=m88k-dolphin-sysv3 ;; M88*:*:R3*:*) # Delta 88k system running SVR3 GUESS=m88k-motorola-sysv3 ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) GUESS=m88k-tektronix-sysv3 ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) GUESS=m68k-tektronix-bsd ;; *:IRIX*:*:*) IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'` GUESS=mips-sgi-irix$IRIX_REL ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) GUESS=i386-ibm-aix ;; ia64:AIX:*:*) if test -x /usr/bin/oslevel ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` then GUESS=$SYSTEM_NAME else GUESS=rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then GUESS=rs6000-ibm-aix3.2.4 else GUESS=rs6000-ibm-aix3.2 fi ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if test -x /usr/bin/lslpp ; then IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \ awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` else IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi GUESS=$IBM_ARCH-ibm-aix$IBM_REV ;; *:AIX:*:*) GUESS=rs6000-ibm-aix ;; ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) GUESS=romp-ibm-bsd4.4 ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) GUESS=rs6000-bull-bosx ;; DPX/2?00:B.O.S.:*:*) GUESS=m68k-bull-sysv3 ;; 9000/[34]??:4.3bsd:1.*:*) GUESS=m68k-hp-bsd ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) GUESS=m68k-hp-bsd4.4 ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` case $UNAME_MACHINE in 9000/31?) HP_ARCH=m68000 ;; 9000/[34]??) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if test -x /usr/bin/getconf; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case $sc_cpu_version in 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case $sc_kernel_bits in 32) HP_ARCH=hppa2.0n ;; 64) HP_ARCH=hppa2.0w ;; '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 esac ;; esac fi if test "$HP_ARCH" = ""; then set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if test "$HP_ARCH" = hppa2.0w then set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH=hppa2.0w else HP_ARCH=hppa64 fi fi GUESS=$HP_ARCH-hp-hpux$HPUX_REV ;; ia64:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` GUESS=ia64-hp-hpux$HPUX_REV ;; 3050*:HI-UX:*:*) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } GUESS=unknown-hitachi-hiuxwe2 ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) GUESS=hppa1.1-hp-bsd ;; 9000/8??:4.3bsd:*:*) GUESS=hppa1.0-hp-bsd ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) GUESS=hppa1.0-hp-mpeix ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) GUESS=hppa1.1-hp-osf ;; hp8??:OSF1:*:*) GUESS=hppa1.0-hp-osf ;; i*86:OSF1:*:*) if test -x /usr/sbin/sysversion ; then GUESS=$UNAME_MACHINE-unknown-osf1mk else GUESS=$UNAME_MACHINE-unknown-osf1 fi ;; parisc*:Lites*:*:*) GUESS=hppa1.1-hp-lites ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) GUESS=c1-convex-bsd ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) GUESS=c34-convex-bsd ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) GUESS=c38-convex-bsd ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) GUESS=c4-convex-bsd ;; CRAY*Y-MP:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=ymp-cray-unicos$CRAY_REL ;; CRAY*[A-Z]90:*:*:*) echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=t90-cray-unicos$CRAY_REL ;; CRAY*T3E:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=alphaev5-cray-unicosmk$CRAY_REL ;; CRAY*SV1:*:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=sv1-cray-unicos$CRAY_REL ;; *:UNICOS/mp:*:*) CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` GUESS=craynv-cray-unicosmp$CRAY_REL ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE ;; sparc*:BSD/OS:*:*) GUESS=sparc-unknown-bsdi$UNAME_RELEASE ;; *:BSD/OS:*:*) GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE ;; arm:FreeBSD:*:*) UNAME_PROCESSOR=`uname -p` set_cc_for_build if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi else FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf fi ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case $UNAME_PROCESSOR in amd64) UNAME_PROCESSOR=x86_64 ;; i386) UNAME_PROCESSOR=i586 ;; esac FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL ;; i*:CYGWIN*:*) GUESS=$UNAME_MACHINE-pc-cygwin ;; *:MINGW64*:*) GUESS=$UNAME_MACHINE-pc-mingw64 ;; *:MINGW*:*) GUESS=$UNAME_MACHINE-pc-mingw32 ;; *:MSYS*:*) GUESS=$UNAME_MACHINE-pc-msys ;; i*:PW*:*) GUESS=$UNAME_MACHINE-pc-pw32 ;; *:Interix*:*) case $UNAME_MACHINE in x86) GUESS=i586-pc-interix$UNAME_RELEASE ;; authenticamd | genuineintel | EM64T) GUESS=x86_64-unknown-interix$UNAME_RELEASE ;; IA64) GUESS=ia64-unknown-interix$UNAME_RELEASE ;; esac ;; i*:UWIN*:*) GUESS=$UNAME_MACHINE-pc-uwin ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) GUESS=x86_64-pc-cygwin ;; prep*:SunOS:5.*:*) SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` GUESS=powerpcle-unknown-solaris2$SUN_REL ;; *:GNU:*:*) # the GNU system GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'` GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'` GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL ;; *:GNU/*:*:*) # other systems with GNU libc and userland GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"` GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC ;; *:Minix:*:*) GUESS=$UNAME_MACHINE-unknown-minix ;; aarch64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC=gnulibc1 ; fi GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; arm*:Linux:*:*) set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then GUESS=$UNAME_MACHINE-unknown-linux-$LIBC else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi else GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf fi fi ;; avr32*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; cris:Linux:*:*) GUESS=$UNAME_MACHINE-axis-linux-$LIBC ;; crisv32:Linux:*:*) GUESS=$UNAME_MACHINE-axis-linux-$LIBC ;; e2k:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; frv:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; hexagon:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; i*86:Linux:*:*) GUESS=$UNAME_MACHINE-pc-linux-$LIBC ;; ia64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; k1om:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; m32r*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; m68*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; mips:Linux:*:* | mips64:Linux:*:*) set_cc_for_build IS_GLIBC=0 test x"${LIBC}" = xgnu && IS_GLIBC=1 sed 's/^ //' << EOF > "$dummy.c" #undef CPU #undef mips #undef mipsel #undef mips64 #undef mips64el #if ${IS_GLIBC} && defined(_ABI64) LIBCABI=gnuabi64 #else #if ${IS_GLIBC} && defined(_ABIN32) LIBCABI=gnuabin32 #else LIBCABI=${LIBC} #endif #endif #if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 CPU=mipsisa64r6 #else #if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 CPU=mipsisa32r6 #else #if defined(__mips64) CPU=mips64 #else CPU=mips #endif #endif #endif #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) MIPS_ENDIAN=el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) MIPS_ENDIAN= #else MIPS_ENDIAN= #endif #endif EOF cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'` eval "$cc_set_vars" test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; } ;; mips64el:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; openrisc*:Linux:*:*) GUESS=or1k-unknown-linux-$LIBC ;; or32:Linux:*:* | or1k*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; padre:Linux:*:*) GUESS=sparc-unknown-linux-$LIBC ;; parisc64:Linux:*:* | hppa64:Linux:*:*) GUESS=hppa64-unknown-linux-$LIBC ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;; PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;; *) GUESS=hppa-unknown-linux-$LIBC ;; esac ;; ppc64:Linux:*:*) GUESS=powerpc64-unknown-linux-$LIBC ;; ppc:Linux:*:*) GUESS=powerpc-unknown-linux-$LIBC ;; ppc64le:Linux:*:*) GUESS=powerpc64le-unknown-linux-$LIBC ;; ppcle:Linux:*:*) GUESS=powerpcle-unknown-linux-$LIBC ;; riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; s390:Linux:*:* | s390x:Linux:*:*) GUESS=$UNAME_MACHINE-ibm-linux-$LIBC ;; sh64*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; sh*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; sparc:Linux:*:* | sparc64:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; tile*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; vax:Linux:*:*) GUESS=$UNAME_MACHINE-dec-linux-$LIBC ;; x86_64:Linux:*:*) set_cc_for_build LIBCABI=$LIBC if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_X32 >/dev/null then LIBCABI=${LIBC}x32 fi fi GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI ;; xtensa*:Linux:*:*) GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. GUESS=i386-sequent-sysv4 ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. GUESS=$UNAME_MACHINE-pc-os2-emx ;; i*86:XTS-300:*:STOP) GUESS=$UNAME_MACHINE-unknown-stop ;; i*86:atheos:*:*) GUESS=$UNAME_MACHINE-unknown-atheos ;; i*86:syllable:*:*) GUESS=$UNAME_MACHINE-pc-syllable ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) GUESS=i386-unknown-lynxos$UNAME_RELEASE ;; i*86:*DOS:*:*) GUESS=$UNAME_MACHINE-pc-msdosdjgpp ;; i*86:*:4.*:*) UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL else GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL fi ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL else GUESS=$UNAME_MACHINE-pc-sysv32 fi ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configure will decide that # this is a cross-build. GUESS=i586-pc-msdosdjgpp ;; Intel:Mach:3*:*) GUESS=i386-pc-mach3 ;; paragon:*:*:*) GUESS=i860-intel-osf1 ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4 fi ;; mini*:CTIX:SYS*5:*) # "miniframe" GUESS=m68010-convergent-sysv ;; mc68k:UNIX:SYSTEM5:3.51m) GUESS=m68k-convergent-sysv ;; M680?0:D-NIX:5.3:*) GUESS=m68k-diab-dnix ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) GUESS=m68k-unknown-lynxos$UNAME_RELEASE ;; mc68030:UNIX_System_V:4.*:*) GUESS=m68k-atari-sysv4 ;; TSUNAMI:LynxOS:2.*:*) GUESS=sparc-unknown-lynxos$UNAME_RELEASE ;; rs6000:LynxOS:2.*:*) GUESS=rs6000-unknown-lynxos$UNAME_RELEASE ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) GUESS=powerpc-unknown-lynxos$UNAME_RELEASE ;; SM[BE]S:UNIX_SV:*:*) GUESS=mips-dde-sysv$UNAME_RELEASE ;; RM*:ReliantUNIX-*:*:*) GUESS=mips-sni-sysv4 ;; RM*:SINIX-*:*:*) GUESS=mips-sni-sysv4 ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` GUESS=$UNAME_MACHINE-sni-sysv4 else GUESS=ns32k-sni-sysv fi ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says GUESS=i586-unisys-sysv4 ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm GUESS=hppa1.1-stratus-sysv4 ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. GUESS=i860-stratus-sysv4 ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. GUESS=$UNAME_MACHINE-stratus-vos ;; *:VOS:*:*) # From Paul.Green@stratus.com. GUESS=hppa1.1-stratus-vos ;; mc68*:A/UX:*:*) GUESS=m68k-apple-aux$UNAME_RELEASE ;; news*:NEWS-OS:6*:*) GUESS=mips-sony-newsos6 ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if test -d /usr/nec; then GUESS=mips-nec-sysv$UNAME_RELEASE else GUESS=mips-unknown-sysv$UNAME_RELEASE fi ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. GUESS=powerpc-be-beos ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. GUESS=powerpc-apple-beos ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. GUESS=i586-pc-beos ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. GUESS=i586-pc-haiku ;; x86_64:Haiku:*:*) GUESS=x86_64-unknown-haiku ;; SX-4:SUPER-UX:*:*) GUESS=sx4-nec-superux$UNAME_RELEASE ;; SX-5:SUPER-UX:*:*) GUESS=sx5-nec-superux$UNAME_RELEASE ;; SX-6:SUPER-UX:*:*) GUESS=sx6-nec-superux$UNAME_RELEASE ;; SX-7:SUPER-UX:*:*) GUESS=sx7-nec-superux$UNAME_RELEASE ;; SX-8:SUPER-UX:*:*) GUESS=sx8-nec-superux$UNAME_RELEASE ;; SX-8R:SUPER-UX:*:*) GUESS=sx8r-nec-superux$UNAME_RELEASE ;; SX-ACE:SUPER-UX:*:*) GUESS=sxace-nec-superux$UNAME_RELEASE ;; Power*:Rhapsody:*:*) GUESS=powerpc-apple-rhapsody$UNAME_RELEASE ;; *:Rhapsody:*:*) GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE ;; arm64:Darwin:*:*) GUESS=aarch64-apple-darwin$UNAME_RELEASE ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` case $UNAME_PROCESSOR in unknown) UNAME_PROCESSOR=powerpc ;; esac if command -v xcode-select > /dev/null 2> /dev/null && \ ! xcode-select --print-path > /dev/null 2> /dev/null ; then # Avoid executing cc if there is no toolchain installed as # cc will be a stub that puts up a graphical alert # prompting the user to install developer tools. CC_FOR_BUILD=no_compiler_found else set_cc_for_build fi if test "$CC_FOR_BUILD" != no_compiler_found; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then case $UNAME_PROCESSOR in i386) UNAME_PROCESSOR=x86_64 ;; powerpc) UNAME_PROCESSOR=powerpc64 ;; esac fi # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_PPC >/dev/null then UNAME_PROCESSOR=powerpc fi elif test "$UNAME_PROCESSOR" = i386 ; then # uname -m returns i386 or x86_64 UNAME_PROCESSOR=$UNAME_MACHINE fi GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = x86; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE ;; *:QNX:*:4*) GUESS=i386-pc-qnx ;; NEO-*:NONSTOP_KERNEL:*:*) GUESS=neo-tandem-nsk$UNAME_RELEASE ;; NSE-*:NONSTOP_KERNEL:*:*) GUESS=nse-tandem-nsk$UNAME_RELEASE ;; NSR-*:NONSTOP_KERNEL:*:*) GUESS=nsr-tandem-nsk$UNAME_RELEASE ;; NSV-*:NONSTOP_KERNEL:*:*) GUESS=nsv-tandem-nsk$UNAME_RELEASE ;; NSX-*:NONSTOP_KERNEL:*:*) GUESS=nsx-tandem-nsk$UNAME_RELEASE ;; *:NonStop-UX:*:*) GUESS=mips-compaq-nonstopux ;; BS2000:POSIX*:*:*) GUESS=bs2000-siemens-sysv ;; DS/*:UNIX_System_V:*:*) GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "${cputype-}" = 386; then UNAME_MACHINE=i386 elif test "x${cputype-}" != x; then UNAME_MACHINE=$cputype fi GUESS=$UNAME_MACHINE-unknown-plan9 ;; *:TOPS-10:*:*) GUESS=pdp10-unknown-tops10 ;; *:TENEX:*:*) GUESS=pdp10-unknown-tenex ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) GUESS=pdp10-dec-tops20 ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) GUESS=pdp10-xkl-tops20 ;; *:TOPS-20:*:*) GUESS=pdp10-unknown-tops20 ;; *:ITS:*:*) GUESS=pdp10-unknown-its ;; SEI:*:*:SEIUX) GUESS=mips-sei-seiux$UNAME_RELEASE ;; *:DragonFly:*:*) DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case $UNAME_MACHINE in A*) GUESS=alpha-dec-vms ;; I*) GUESS=ia64-dec-vms ;; V*) GUESS=vax-dec-vms ;; esac ;; *:XENIX:*:SysV) GUESS=i386-pc-xenix ;; i*86:skyos:*:*) SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'` GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL ;; i*86:rdos:*:*) GUESS=$UNAME_MACHINE-pc-rdos ;; *:AROS:*:*) GUESS=$UNAME_MACHINE-unknown-aros ;; x86_64:VMkernel:*:*) GUESS=$UNAME_MACHINE-unknown-esx ;; amd64:Isilon\ OneFS:*:*) GUESS=x86_64-unknown-onefs ;; *:Unleashed:*:*) GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE ;; esac # Do we have a guess based on uname results? if test "x$GUESS" != x; then echo "$GUESS" exit fi # No uname command or uname output not recognized. set_cc_for_build cat > "$dummy.c" < #include #endif #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) #if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) #include #if defined(_SIZE_T_) || defined(SIGLOST) #include #endif #endif #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) #if !defined (ultrix) #include #if defined (BSD) #if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); #else #if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); #else printf ("vax-dec-bsd\n"); exit (0); #endif #endif #else printf ("vax-dec-bsd\n"); exit (0); #endif #else #if defined(_SIZE_T_) || defined(SIGLOST) struct utsname un; uname (&un); printf ("vax-dec-ultrix%s\n", un.release); exit (0); #else printf ("vax-dec-ultrix\n"); exit (0); #endif #endif #endif #if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) #if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) #if defined(_SIZE_T_) || defined(SIGLOST) struct utsname *un; uname (&un); printf ("mips-dec-ultrix%s\n", un.release); exit (0); #else printf ("mips-dec-ultrix\n"); exit (0); #endif #endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; } echo "$0: unable to guess system type" >&2 case $UNAME_MACHINE:$UNAME_SYSTEM in mips:Linux | mips64:Linux) # If we got here on MIPS GNU/Linux, output extra information. cat >&2 <&2 <&2 </dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = "$UNAME_MACHINE" UNAME_RELEASE = "$UNAME_RELEASE" UNAME_SYSTEM = "$UNAME_SYSTEM" UNAME_VERSION = "$UNAME_VERSION" EOF fi exit 1 # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: network-3.1.4.0/config.sub0000644000000000000000000010476207346545000013531 0ustar0000000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright 1992-2021 Free Software Foundation, Inc. # shellcheck disable=SC2006,SC2268 # see below for rationale timestamp='2021-08-14' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that # program. This Exception is an additional permission under section 7 # of the GNU General Public License, version 3 ("GPLv3"). # Please send patches to . # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # https://git.savannah.gnu.org/cgit/config.git/plain/config.sub # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. # The "shellcheck disable" line above the timestamp inhibits complaints # about features and limitations of the classic Bourne shell that were # superseded or lifted in POSIX. However, this script identifies a wide # variety of pre-POSIX systems that do not have POSIX shells at all, and # even some reasonably current systems (Solaris 10 as case-in-point) still # have a pre-POSIX /bin/sh. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS Canonicalize a configuration name. Options: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright 1992-2021 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; *local*) # First pass through any local machine types. echo "$1" exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Split fields of configuration type # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read field1 field2 field3 field4 <&2 exit 1 ;; *-*-*-*) basic_machine=$field1-$field2 basic_os=$field3-$field4 ;; *-*-*) # Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two # parts maybe_os=$field2-$field3 case $maybe_os in nto-qnx* | linux-* | uclinux-uclibc* \ | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \ | netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \ | storm-chaos* | os2-emx* | rtmk-nova*) basic_machine=$field1 basic_os=$maybe_os ;; android-linux) basic_machine=$field1-unknown basic_os=linux-android ;; *) basic_machine=$field1-$field2 basic_os=$field3 ;; esac ;; *-*) # A lone config we happen to match not fitting any pattern case $field1-$field2 in decstation-3100) basic_machine=mips-dec basic_os= ;; *-*) # Second component is usually, but not always the OS case $field2 in # Prevent following clause from handling this valid os sun*os*) basic_machine=$field1 basic_os=$field2 ;; zephyr*) basic_machine=$field1-unknown basic_os=$field2 ;; # Manufacturers dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ | unicom* | ibm* | next | hp | isi* | apollo | altos* \ | convergent* | ncr* | news | 32* | 3600* | 3100* \ | hitachi* | c[123]* | convex* | sun | crds | omron* | dg \ | ultra | tti* | harris | dolphin | highlevel | gould \ | cbm | ns | masscomp | apple | axis | knuth | cray \ | microblaze* | sim | cisco \ | oki | wec | wrs | winbond) basic_machine=$field1-$field2 basic_os= ;; *) basic_machine=$field1 basic_os=$field2 ;; esac ;; esac ;; *) # Convert single-component short-hands not valid as part of # multi-component configurations. case $field1 in 386bsd) basic_machine=i386-pc basic_os=bsd ;; a29khif) basic_machine=a29k-amd basic_os=udi ;; adobe68k) basic_machine=m68010-adobe basic_os=scout ;; alliant) basic_machine=fx80-alliant basic_os= ;; altos | altos3068) basic_machine=m68k-altos basic_os= ;; am29k) basic_machine=a29k-none basic_os=bsd ;; amdahl) basic_machine=580-amdahl basic_os=sysv ;; amiga) basic_machine=m68k-unknown basic_os= ;; amigaos | amigados) basic_machine=m68k-unknown basic_os=amigaos ;; amigaunix | amix) basic_machine=m68k-unknown basic_os=sysv4 ;; apollo68) basic_machine=m68k-apollo basic_os=sysv ;; apollo68bsd) basic_machine=m68k-apollo basic_os=bsd ;; aros) basic_machine=i386-pc basic_os=aros ;; aux) basic_machine=m68k-apple basic_os=aux ;; balance) basic_machine=ns32k-sequent basic_os=dynix ;; blackfin) basic_machine=bfin-unknown basic_os=linux ;; cegcc) basic_machine=arm-unknown basic_os=cegcc ;; convex-c1) basic_machine=c1-convex basic_os=bsd ;; convex-c2) basic_machine=c2-convex basic_os=bsd ;; convex-c32) basic_machine=c32-convex basic_os=bsd ;; convex-c34) basic_machine=c34-convex basic_os=bsd ;; convex-c38) basic_machine=c38-convex basic_os=bsd ;; cray) basic_machine=j90-cray basic_os=unicos ;; crds | unos) basic_machine=m68k-crds basic_os= ;; da30) basic_machine=m68k-da30 basic_os= ;; decstation | pmax | pmin | dec3100 | decstatn) basic_machine=mips-dec basic_os= ;; delta88) basic_machine=m88k-motorola basic_os=sysv3 ;; dicos) basic_machine=i686-pc basic_os=dicos ;; djgpp) basic_machine=i586-pc basic_os=msdosdjgpp ;; ebmon29k) basic_machine=a29k-amd basic_os=ebmon ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson basic_os=ose ;; gmicro) basic_machine=tron-gmicro basic_os=sysv ;; go32) basic_machine=i386-pc basic_os=go32 ;; h8300hms) basic_machine=h8300-hitachi basic_os=hms ;; h8300xray) basic_machine=h8300-hitachi basic_os=xray ;; h8500hms) basic_machine=h8500-hitachi basic_os=hms ;; harris) basic_machine=m88k-harris basic_os=sysv3 ;; hp300 | hp300hpux) basic_machine=m68k-hp basic_os=hpux ;; hp300bsd) basic_machine=m68k-hp basic_os=bsd ;; hppaosf) basic_machine=hppa1.1-hp basic_os=osf ;; hppro) basic_machine=hppa1.1-hp basic_os=proelf ;; i386mach) basic_machine=i386-mach basic_os=mach ;; isi68 | isi) basic_machine=m68k-isi basic_os=sysv ;; m68knommu) basic_machine=m68k-unknown basic_os=linux ;; magnum | m3230) basic_machine=mips-mips basic_os=sysv ;; merlin) basic_machine=ns32k-utek basic_os=sysv ;; mingw64) basic_machine=x86_64-pc basic_os=mingw64 ;; mingw32) basic_machine=i686-pc basic_os=mingw32 ;; mingw32ce) basic_machine=arm-unknown basic_os=mingw32ce ;; monitor) basic_machine=m68k-rom68k basic_os=coff ;; morphos) basic_machine=powerpc-unknown basic_os=morphos ;; moxiebox) basic_machine=moxie-unknown basic_os=moxiebox ;; msdos) basic_machine=i386-pc basic_os=msdos ;; msys) basic_machine=i686-pc basic_os=msys ;; mvs) basic_machine=i370-ibm basic_os=mvs ;; nacl) basic_machine=le32-unknown basic_os=nacl ;; ncr3000) basic_machine=i486-ncr basic_os=sysv4 ;; netbsd386) basic_machine=i386-pc basic_os=netbsd ;; netwinder) basic_machine=armv4l-rebel basic_os=linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony basic_os=newsos ;; news1000) basic_machine=m68030-sony basic_os=newsos ;; necv70) basic_machine=v70-nec basic_os=sysv ;; nh3000) basic_machine=m68k-harris basic_os=cxux ;; nh[45]000) basic_machine=m88k-harris basic_os=cxux ;; nindy960) basic_machine=i960-intel basic_os=nindy ;; mon960) basic_machine=i960-intel basic_os=mon960 ;; nonstopux) basic_machine=mips-compaq basic_os=nonstopux ;; os400) basic_machine=powerpc-ibm basic_os=os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson basic_os=ose ;; os68k) basic_machine=m68k-none basic_os=os68k ;; paragon) basic_machine=i860-intel basic_os=osf ;; parisc) basic_machine=hppa-unknown basic_os=linux ;; psp) basic_machine=mipsallegrexel-sony basic_os=psp ;; pw32) basic_machine=i586-unknown basic_os=pw32 ;; rdos | rdos64) basic_machine=x86_64-pc basic_os=rdos ;; rdos32) basic_machine=i386-pc basic_os=rdos ;; rom68k) basic_machine=m68k-rom68k basic_os=coff ;; sa29200) basic_machine=a29k-amd basic_os=udi ;; sei) basic_machine=mips-sei basic_os=seiux ;; sequent) basic_machine=i386-sequent basic_os= ;; sps7) basic_machine=m68k-bull basic_os=sysv2 ;; st2000) basic_machine=m68k-tandem basic_os= ;; stratus) basic_machine=i860-stratus basic_os=sysv4 ;; sun2) basic_machine=m68000-sun basic_os= ;; sun2os3) basic_machine=m68000-sun basic_os=sunos3 ;; sun2os4) basic_machine=m68000-sun basic_os=sunos4 ;; sun3) basic_machine=m68k-sun basic_os= ;; sun3os3) basic_machine=m68k-sun basic_os=sunos3 ;; sun3os4) basic_machine=m68k-sun basic_os=sunos4 ;; sun4) basic_machine=sparc-sun basic_os= ;; sun4os3) basic_machine=sparc-sun basic_os=sunos3 ;; sun4os4) basic_machine=sparc-sun basic_os=sunos4 ;; sun4sol2) basic_machine=sparc-sun basic_os=solaris2 ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun basic_os= ;; sv1) basic_machine=sv1-cray basic_os=unicos ;; symmetry) basic_machine=i386-sequent basic_os=dynix ;; t3e) basic_machine=alphaev5-cray basic_os=unicos ;; t90) basic_machine=t90-cray basic_os=unicos ;; toad1) basic_machine=pdp10-xkl basic_os=tops20 ;; tpf) basic_machine=s390x-ibm basic_os=tpf ;; udi29k) basic_machine=a29k-amd basic_os=udi ;; ultra3) basic_machine=a29k-nyu basic_os=sym1 ;; v810 | necv810) basic_machine=v810-nec basic_os=none ;; vaxv) basic_machine=vax-dec basic_os=sysv ;; vms) basic_machine=vax-dec basic_os=vms ;; vsta) basic_machine=i386-pc basic_os=vsta ;; vxworks960) basic_machine=i960-wrs basic_os=vxworks ;; vxworks68) basic_machine=m68k-wrs basic_os=vxworks ;; vxworks29k) basic_machine=a29k-wrs basic_os=vxworks ;; xbox) basic_machine=i686-pc basic_os=mingw32 ;; ymp) basic_machine=ymp-cray basic_os=unicos ;; *) basic_machine=$1 basic_os= ;; esac ;; esac # Decode 1-component or ad-hoc basic machines case $basic_machine in # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) cpu=hppa1.1 vendor=winbond ;; op50n) cpu=hppa1.1 vendor=oki ;; op60c) cpu=hppa1.1 vendor=oki ;; ibm*) cpu=i370 vendor=ibm ;; orion105) cpu=clipper vendor=highlevel ;; mac | mpw | mac-mpw) cpu=m68k vendor=apple ;; pmac | pmac-mpw) cpu=powerpc vendor=apple ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) cpu=m68000 vendor=att ;; 3b*) cpu=we32k vendor=att ;; bluegene*) cpu=powerpc vendor=ibm basic_os=cnk ;; decsystem10* | dec10*) cpu=pdp10 vendor=dec basic_os=tops10 ;; decsystem20* | dec20*) cpu=pdp10 vendor=dec basic_os=tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) cpu=m68k vendor=motorola ;; dpx2*) cpu=m68k vendor=bull basic_os=sysv3 ;; encore | umax | mmax) cpu=ns32k vendor=encore ;; elxsi) cpu=elxsi vendor=elxsi basic_os=${basic_os:-bsd} ;; fx2800) cpu=i860 vendor=alliant ;; genix) cpu=ns32k vendor=ns ;; h3050r* | hiux*) cpu=hppa1.1 vendor=hitachi basic_os=hiuxwe2 ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) cpu=m68000 vendor=hp ;; hp9k3[2-9][0-9]) cpu=m68k vendor=hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) cpu=hppa1.1 vendor=hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp cpu=hppa1.1 vendor=hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp cpu=hppa1.1 vendor=hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) cpu=hppa1.1 vendor=hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) cpu=hppa1.0 vendor=hp ;; i*86v32) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv32 ;; i*86v4*) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv4 ;; i*86v) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=sysv ;; i*86sol2) cpu=`echo "$1" | sed -e 's/86.*/86/'` vendor=pc basic_os=solaris2 ;; j90 | j90-cray) cpu=j90 vendor=cray basic_os=${basic_os:-unicos} ;; iris | iris4d) cpu=mips vendor=sgi case $basic_os in irix*) ;; *) basic_os=irix4 ;; esac ;; miniframe) cpu=m68000 vendor=convergent ;; *mint | mint[0-9]* | *MiNT | *MiNT[0-9]*) cpu=m68k vendor=atari basic_os=mint ;; news-3600 | risc-news) cpu=mips vendor=sony basic_os=newsos ;; next | m*-next) cpu=m68k vendor=next case $basic_os in openstep*) ;; nextstep*) ;; ns2*) basic_os=nextstep2 ;; *) basic_os=nextstep3 ;; esac ;; np1) cpu=np1 vendor=gould ;; op50n-* | op60c-*) cpu=hppa1.1 vendor=oki basic_os=proelf ;; pa-hitachi) cpu=hppa1.1 vendor=hitachi basic_os=hiuxwe2 ;; pbd) cpu=sparc vendor=tti ;; pbb) cpu=m68k vendor=tti ;; pc532) cpu=ns32k vendor=pc532 ;; pn) cpu=pn vendor=gould ;; power) cpu=power vendor=ibm ;; ps2) cpu=i386 vendor=ibm ;; rm[46]00) cpu=mips vendor=siemens ;; rtpc | rtpc-*) cpu=romp vendor=ibm ;; sde) cpu=mipsisa32 vendor=sde basic_os=${basic_os:-elf} ;; simso-wrs) cpu=sparclite vendor=wrs basic_os=vxworks ;; tower | tower-32) cpu=m68k vendor=ncr ;; vpp*|vx|vx-*) cpu=f301 vendor=fujitsu ;; w65) cpu=w65 vendor=wdc ;; w89k-*) cpu=hppa1.1 vendor=winbond basic_os=proelf ;; none) cpu=none vendor=none ;; leon|leon[3-9]) cpu=sparc vendor=$basic_machine ;; leon-*|leon[3-9]-*) cpu=sparc vendor=`echo "$basic_machine" | sed 's/-.*//'` ;; *-*) # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read cpu vendor <&2 exit 1 ;; esac ;; esac # Here we canonicalize certain aliases for manufacturers. case $vendor in digital*) vendor=dec ;; commodore*) vendor=cbm ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if test x$basic_os != x then # First recognize some ad-hoc caes, or perhaps split kernel-os, or else just # set os. case $basic_os in gnu/linux*) kernel=linux os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'` ;; os2-emx) kernel=os2 os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'` ;; nto-qnx*) kernel=nto os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'` ;; *-*) # shellcheck disable=SC2162 saved_IFS=$IFS IFS="-" read kernel os <&2 exit 1 ;; esac # As a final step for OS-related things, validate the OS-kernel combination # (given a valid OS), if there is a kernel. case $kernel-$os in linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* \ | linux-musl* | linux-relibc* | linux-uclibc* ) ;; uclinux-uclibc* ) ;; -dietlibc* | -newlib* | -musl* | -relibc* | -uclibc* ) # These are just libc implementations, not actual OSes, and thus # require a kernel. echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2 exit 1 ;; kfreebsd*-gnu* | kopensolaris*-gnu*) ;; vxworks-simlinux | vxworks-simwindows | vxworks-spe) ;; nto-qnx*) ;; os2-emx) ;; *-eabi* | *-gnueabi*) ;; -*) # Blank kernel with real OS is always fine. ;; *-*) echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2 exit 1 ;; esac # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. case $vendor in unknown) case $cpu-$os in *-riscix*) vendor=acorn ;; *-sunos*) vendor=sun ;; *-cnk* | *-aix*) vendor=ibm ;; *-beos*) vendor=be ;; *-hpux*) vendor=hp ;; *-mpeix*) vendor=hp ;; *-hiux*) vendor=hitachi ;; *-unos*) vendor=crds ;; *-dgux*) vendor=dg ;; *-luna*) vendor=omron ;; *-genix*) vendor=ns ;; *-clix*) vendor=intergraph ;; *-mvs* | *-opened*) vendor=ibm ;; *-os400*) vendor=ibm ;; s390-* | s390x-*) vendor=ibm ;; *-ptx*) vendor=sequent ;; *-tpf*) vendor=ibm ;; *-vxsim* | *-vxworks* | *-windiss*) vendor=wrs ;; *-aux*) vendor=apple ;; *-hms*) vendor=hitachi ;; *-mpw* | *-macos*) vendor=apple ;; *-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*) vendor=atari ;; *-vos*) vendor=stratus ;; esac ;; esac echo "$cpu-$vendor-${kernel:+$kernel-}$os" exit # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: network-3.1.4.0/configure0000644000000000000000000042752507346545000013462 0ustar0000000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for Haskell network package 3.1.4.0. # # Report bugs to . # # # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 as_fn_exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and $0: libraries@haskell.org about your system, including any $0: error possibly output before this message. Then install $0: a modern shell, or manually run the script under such a $0: shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='Haskell network package' PACKAGE_TARNAME='network' PACKAGE_VERSION='3.1.4.0' PACKAGE_STRING='Haskell network package 3.1.4.0' PACKAGE_BUGREPORT='libraries@haskell.org' PACKAGE_URL='' ac_unique_file="include/HsNet.h" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS EGREP GREP CPP OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking with_cc ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures Haskell network package 3.1.4.0 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/network] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of Haskell network package 3.1.4.0:";; esac cat <<\_ACEOF Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) C compiler Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF Haskell network package configure 3.1.4.0 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## ------------------------------------ ## ## Report this to libraries@haskell.org ## ## ------------------------------------ ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- # Tests whether TYPE exists after having included INCLUDES, setting cache # variable VAR accordingly. ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else eval "$3=yes" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_type # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. Prefer to if __STDC__ is defined, since exists even on freestanding compilers. */ #ifdef __STDC__ # include #else # include #endif #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined __stub_$2 || defined __stub___$2 choke me #endif int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_func # ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES # --------------------------------------------- # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR # accordingly. ac_fn_c_check_decl () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack as_decl_name=`echo $2|sed 's/ *(.*//'` as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 $as_echo_n "checking whether $as_decl_name is declared... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { #ifndef $as_decl_name #ifdef __cplusplus (void) $as_decl_use; #else (void) $as_decl_name; #endif #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_decl # ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES # ---------------------------------------------------- # Tries to find if the field MEMBER exists in type AGGR, after including # INCLUDES, setting cache variable VAR accordingly. ac_fn_c_check_member () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 $as_echo_n "checking for $2.$3... " >&6; } if eval \${$4+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int main () { static $2 ac_aggr; if (ac_aggr.$3) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$4=yes" else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int main () { static $2 ac_aggr; if (sizeof ac_aggr.$3) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$4=yes" else eval "$4=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$4 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_member cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by Haskell network package $as_me 3.1.4.0, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_includes_default="#ifndef _WIN32 # define _GNU_SOURCE 1 /* for struct ucred on Linux */ #endif $ac_includes_default #ifdef _WIN32 # include # include # define IPV6_V6ONLY 27 #endif #ifdef HAVE_LIMITS_H # include #endif #ifdef HAVE_STDLIB_H # include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_FCNTL_H # include #endif #ifdef HAVE_SYS_UIO_H # include #endif #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif #ifdef HAVE_NETINET_TCP_H # include #endif #ifdef HAVE_SYS_UN_H # include #endif #ifdef HAVE_ARPA_INET_H # include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_NET_IF_H # include #endif #ifdef HAVE_NETIOAPI_H # include #endif " ac_config_headers="$ac_config_headers include/HsNetworkConfig.h" ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac # Check whether --with-cc was given. if test "${with_cc+set}" = set; then : withval=$with_cc; CC=$withval fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 $as_echo_n "checking for an ANSI C-conforming const... " >&6; } if ${ac_cv_c_const+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __cplusplus /* Ultrix mips cc rejects this sort of thing. */ typedef int charset[2]; const charset cs = { 0, 0 }; /* SunOS 4.1.1 cc rejects this. */ char const *const *pcpcc; char **ppc; /* NEC SVR4.0.2 mips cc rejects this. */ struct point {int x, y;}; static struct point const zero = {0,0}; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; pcpcc = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++pcpcc; ppc = (char**) pcpcc; pcpcc = (char const *const *) ppc; { /* SCO 3.2v4 cc rejects this sort of thing. */ char tx; char *t = &tx; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; if (s) return 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25, 17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; } bx; struct s *b = &bx; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x; #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_const=yes else ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 $as_echo "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then $as_echo "#define const /**/" >>confdefs.h fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in limits.h stdlib.h unistd.h sys/types.h fcntl.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in sys/uio.h sys/socket.h netinet/in.h netinet/tcp.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in sys/un.h arpa/inet.h netdb.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in net/if.h netioapi.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_type "$LINENO" "struct ucred" "ac_cv_type_struct_ucred" "$ac_includes_default" if test "x$ac_cv_type_struct_ucred" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STRUCT_UCRED 1 _ACEOF fi for ac_func in gai_strerror gethostent accept4 do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in getpeereid do : ac_fn_c_check_func "$LINENO" "getpeereid" "ac_cv_func_getpeereid" if test "x$ac_cv_func_getpeereid" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_GETPEEREID 1 _ACEOF fi done ac_fn_c_check_decl "$LINENO" "AI_ADDRCONFIG" "ac_cv_have_decl_AI_ADDRCONFIG" "$ac_includes_default" if test "x$ac_cv_have_decl_AI_ADDRCONFIG" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_AI_ADDRCONFIG $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "AI_ALL" "ac_cv_have_decl_AI_ALL" "$ac_includes_default" if test "x$ac_cv_have_decl_AI_ALL" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_AI_ALL $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "AI_NUMERICSERV" "ac_cv_have_decl_AI_NUMERICSERV" "$ac_includes_default" if test "x$ac_cv_have_decl_AI_NUMERICSERV" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_AI_NUMERICSERV $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "AI_V4MAPPED" "ac_cv_have_decl_AI_V4MAPPED" "$ac_includes_default" if test "x$ac_cv_have_decl_AI_V4MAPPED" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_AI_V4MAPPED $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "IPV6_V6ONLY" "ac_cv_have_decl_IPV6_V6ONLY" "$ac_includes_default" if test "x$ac_cv_have_decl_IPV6_V6ONLY" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_IPV6_V6ONLY $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "IPPROTO_IP" "ac_cv_have_decl_IPPROTO_IP" "$ac_includes_default" if test "x$ac_cv_have_decl_IPPROTO_IP" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_IPPROTO_IP $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "IPPROTO_TCP" "ac_cv_have_decl_IPPROTO_TCP" "$ac_includes_default" if test "x$ac_cv_have_decl_IPPROTO_TCP" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_IPPROTO_TCP $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "IPPROTO_IPV6" "ac_cv_have_decl_IPPROTO_IPV6" "$ac_includes_default" if test "x$ac_cv_have_decl_IPPROTO_IPV6" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_IPPROTO_IPV6 $ac_have_decl _ACEOF ac_fn_c_check_decl "$LINENO" "SO_PEERCRED" "ac_cv_have_decl_SO_PEERCRED" "$ac_includes_default" if test "x$ac_cv_have_decl_SO_PEERCRED" = xyes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_SO_PEERCRED $ac_have_decl _ACEOF ac_fn_c_check_member "$LINENO" "struct msghdr" "msg_control" "ac_cv_member_struct_msghdr_msg_control" "$ac_includes_default" if test "x$ac_cv_member_struct_msghdr_msg_control" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STRUCT_MSGHDR_MSG_CONTROL 1 _ACEOF fi ac_fn_c_check_member "$LINENO" "struct msghdr" "msg_accrights" "ac_cv_member_struct_msghdr_msg_accrights" "$ac_includes_default" if test "x$ac_cv_member_struct_msghdr_msg_accrights" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS 1 _ACEOF fi ac_fn_c_check_member "$LINENO" "struct sockaddr" "sa_len" "ac_cv_member_struct_sockaddr_sa_len" "$ac_includes_default" if test "x$ac_cv_member_struct_sockaddr_sa_len" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_STRUCT_SOCKADDR_SA_LEN 1 _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: creating ./network.buildinfo" >&5 $as_echo "$as_me: creating ./network.buildinfo" >&6;} echo "install-includes: HsNetworkConfig.h" > network.buildinfo cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by Haskell network package $as_me 3.1.4.0, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_headers="$ac_config_headers" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration headers: $config_headers Report bugs to ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ Haskell network package config.status 3.1.4.0 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "include/HsNetworkConfig.h") CONFIG_HEADERS="$CONFIG_HEADERS include/HsNetworkConfig.h" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :H $CONFIG_HEADERS " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi network-3.1.4.0/configure.ac0000644000000000000000000000401607346545000014026 0ustar0000000000000000AC_INIT([Haskell network package], [3.1.4.0], [libraries@haskell.org], [network]) dnl See also HsNet.h ac_includes_default="#ifndef _WIN32 # define _GNU_SOURCE 1 /* for struct ucred on Linux */ #endif $ac_includes_default #ifdef _WIN32 # include # include # define IPV6_V6ONLY 27 #endif #ifdef HAVE_LIMITS_H # include #endif #ifdef HAVE_STDLIB_H # include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_FCNTL_H # include #endif #ifdef HAVE_SYS_UIO_H # include #endif #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif #ifdef HAVE_NETINET_TCP_H # include #endif #ifdef HAVE_SYS_UN_H # include #endif #ifdef HAVE_ARPA_INET_H # include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_NET_IF_H # include #endif #ifdef HAVE_NETIOAPI_H # include #endif " AC_CONFIG_SRCDIR([include/HsNet.h]) AC_CONFIG_HEADERS([include/HsNetworkConfig.h]) AC_CANONICAL_HOST AC_ARG_WITH([cc], [C compiler], [CC=$withval]) AC_PROG_CC() AC_C_CONST AC_CHECK_HEADERS([limits.h stdlib.h unistd.h sys/types.h fcntl.h]) AC_CHECK_HEADERS([sys/uio.h sys/socket.h netinet/in.h netinet/tcp.h]) AC_CHECK_HEADERS([sys/un.h arpa/inet.h netdb.h]) AC_CHECK_HEADERS([net/if.h netioapi.h]) AC_CHECK_TYPES([struct ucred]) AC_CHECK_FUNCS([gai_strerror gethostent accept4]) AC_CHECK_FUNCS([getpeereid]) AC_CHECK_DECLS([AI_ADDRCONFIG, AI_ALL, AI_NUMERICSERV, AI_V4MAPPED]) AC_CHECK_DECLS([IPV6_V6ONLY]) AC_CHECK_DECLS([IPPROTO_IP, IPPROTO_TCP, IPPROTO_IPV6]) AC_CHECK_DECLS([SO_PEERCRED]) AC_CHECK_MEMBERS([struct msghdr.msg_control, struct msghdr.msg_accrights]) AC_CHECK_MEMBERS([struct sockaddr.sa_len]) dnl This is a necessary hack AC_MSG_NOTICE([creating ./network.buildinfo]) echo "install-includes: HsNetworkConfig.h" > network.buildinfo AC_OUTPUT network-3.1.4.0/examples/0000755000000000000000000000000007346545000013355 5ustar0000000000000000network-3.1.4.0/examples/EchoClient.hs0000644000000000000000000000160107346545000015724 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} -- Echo client program module Main (main) where import qualified Control.Exception as E import qualified Data.ByteString.Char8 as C import Network.Socket import Network.Socket.ByteString (recv, sendAll) main :: IO () main = runTCPClient "127.0.0.1" "3000" $ \s -> do sendAll s "Hello, world!" msg <- recv s 1024 putStr "Received: " C.putStrLn msg -- from the "network-run" package. runTCPClient :: HostName -> ServiceName -> (Socket -> IO a) -> IO a runTCPClient host port client = withSocketsDo $ do addr <- resolve E.bracket (open addr) close client where resolve = do let hints = defaultHints { addrSocketType = Stream } head <$> getAddrInfo (Just hints) (Just host) (Just port) open addr = E.bracketOnError (openSocket addr) close $ \sock -> do connect sock $ addrAddress addr return sock network-3.1.4.0/examples/EchoServer.hs0000644000000000000000000000310507346545000015755 0ustar0000000000000000-- Echo server program module Main (main) where import Control.Concurrent (forkFinally) import qualified Control.Exception as E import Control.Monad (unless, forever, void) import qualified Data.ByteString as S import Network.Socket import Network.Socket.ByteString (recv, sendAll) main :: IO () main = runTCPServer Nothing "3000" talk where talk s = do msg <- recv s 1024 unless (S.null msg) $ do sendAll s msg talk s -- from the "network-run" package. runTCPServer :: Maybe HostName -> ServiceName -> (Socket -> IO a) -> IO a runTCPServer mhost port server = withSocketsDo $ do addr <- resolve E.bracket (open addr) close loop where resolve = do let hints = defaultHints { addrFlags = [AI_PASSIVE] , addrSocketType = Stream } head <$> getAddrInfo (Just hints) mhost (Just port) open addr = E.bracketOnError (openSocket addr) close $ \sock -> do setSocketOption sock ReuseAddr 1 withFdSocket sock setCloseOnExecIfNeeded bind sock $ addrAddress addr listen sock 1024 return sock loop sock = forever $ E.bracketOnError (accept sock) (close . fst) $ \(conn, _peer) -> void $ -- 'forkFinally' alone is unlikely to fail thus leaking @conn@, -- but 'E.bracketOnError' above will be necessary if some -- non-atomic setups (e.g. spawning a subprocess to handle -- @conn@) before proper cleanup of @conn@ is your case forkFinally (server conn) (const $ gracefulClose conn 5000) network-3.1.4.0/include/0000755000000000000000000000000007346545000013162 5ustar0000000000000000network-3.1.4.0/include/HsNet.h0000644000000000000000000000655007346545000014362 0ustar0000000000000000/* ----------------------------------------------------------------------------- * * Definitions for package `network' which are visible in Haskell land. * * ---------------------------------------------------------------------------*/ #ifndef HSNET_H #define HSNET_H #include "HsNetDef.h" #ifndef INLINE # if defined(_MSC_VER) # define INLINE extern __inline # elif defined(__GNUC_GNU_INLINE__) # define INLINE extern inline # else # define INLINE inline # endif #endif #ifndef _WIN32 # define _GNU_SOURCE 1 /* for struct ucred on Linux */ #endif #define __APPLE_USE_RFC_3542 1 /* for IPV6_RECVPKTINFO */ #ifdef _WIN32 # include # include # include # include "win32defs.h" # include "afunix_compat.h" # define IPV6_V6ONLY 27 #endif #ifdef HAVE_LIMITS_H # include #endif #ifdef HAVE_STDLIB_H # include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_FCNTL_H # include #endif #ifdef HAVE_SYS_UIO_H # include #endif #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif #ifdef HAVE_NETINET_TCP_H # include #endif #ifdef HAVE_SYS_UN_H # include #endif #ifdef HAVE_ARPA_INET_H # include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_NET_IF_H # include #endif #ifdef HAVE_NETIOAPI_H # include #endif #ifdef _WIN32 extern int initWinSock (); extern const char* getWSErrorDescr(int err); extern void* newAcceptParams(int sock, int sz, void* sockaddr); extern int acceptNewSock(void* d); extern int acceptDoProc(void* param); extern LPWSACMSGHDR cmsg_firsthdr(LPWSAMSG mhdr); extern LPWSACMSGHDR cmsg_nxthdr(LPWSAMSG mhdr, LPWSACMSGHDR cmsg); extern unsigned char * cmsg_data(LPWSACMSGHDR cmsg); extern unsigned int cmsg_space(unsigned int l); extern unsigned int cmsg_len(unsigned int l); /** * WSASendMsg function */ extern WINAPI int WSASendMsg (SOCKET, LPWSAMSG, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); /** * WSARecvMsg function */ extern WINAPI int WSARecvMsg (SOCKET, LPWSAMSG, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE); #else /* _WIN32 */ extern int sendFd(int sock, int outfd); extern int recvFd(int sock); extern struct cmsghdr * cmsg_firsthdr(struct msghdr *mhdr); extern struct cmsghdr * cmsg_nxthdr(struct msghdr *mhdr, struct cmsghdr *cmsg); extern unsigned char * cmsg_data(struct cmsghdr *cmsg); extern size_t cmsg_space(size_t l); extern size_t cmsg_len(size_t l); #endif /* _WIN32 */ INLINE int hsnet_getnameinfo(const struct sockaddr* a,socklen_t b, char* c, # if defined(_WIN32) DWORD d, char* e, DWORD f, int g) # else socklen_t d, char* e, socklen_t f, int g) # endif { return getnameinfo(a,b,c,d,e,f,g); } INLINE int hsnet_getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res) { return getaddrinfo(hostname, servname, hints, res); } INLINE void hsnet_freeaddrinfo(struct addrinfo *ai) { freeaddrinfo(ai); } #ifndef IOV_MAX # define IOV_MAX 1024 #endif #ifndef SOCK_NONBLOCK // Missing define in Bionic libc (Android) # define SOCK_NONBLOCK O_NONBLOCK #endif #endif /* HSNET_H */ network-3.1.4.0/include/HsNetDef.h0000644000000000000000000000210507346545000014771 0ustar0000000000000000#ifndef HSNETDEF_H #define HSNETDEF_H #include "HsNetworkConfig.h" /* ultra-evil... */ #undef PACKAGE_BUGREPORT #undef PACKAGE_NAME #undef PACKAGE_STRING #undef PACKAGE_TARNAME #undef PACKAGE_VERSION #if defined(HAVE_STRUCT_UCRED) && HAVE_DECL_SO_PEERCRED # define HAVE_STRUCT_UCRED_SO_PEERCRED 1 #else # undef HAVE_STRUCT_UCRED_SO_PEERCRED #endif #ifdef HAVE_ACCEPT4 # define HAVE_ADVANCED_SOCKET_FLAGS 1 #else # undef HAVE_ADVANCED_SOCKET_FLAGS #endif /* stdcall is for Windows 32. Haskell FFI does not have a keyword for Windows 64. If ccall/stdcall is specified on Windows 64, GHC ignores it and use a proper ABI for Windows 64. But if stdcall is specified, GHC displays a warning. So, let's use ccall for Windows 64. */ #if defined(mingw32_HOST_OS) # if defined(i386_HOST_ARCH) # define CALLCONV stdcall # elif defined(x86_64_HOST_ARCH) # define CALLCONV ccall # else # error Unknown mingw32 arch # endif #else # define CALLCONV ccall #endif #if defined(mingw32_HOST_OS) # define SAFE_ON_WIN safe #else # define SAFE_ON_WIN unsafe #endif #endif /* HSNETDEF_H */ network-3.1.4.0/include/HsNetworkConfig.h.in0000644000000000000000000001010207346545000017004 0ustar0000000000000000/* include/HsNetworkConfig.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if you have the `accept4' function. */ #undef HAVE_ACCEPT4 /* Define to 1 if you have the header file. */ #undef HAVE_ARPA_INET_H /* Define to 1 if you have the declaration of `AI_ADDRCONFIG', and to 0 if you don't. */ #undef HAVE_DECL_AI_ADDRCONFIG /* Define to 1 if you have the declaration of `AI_ALL', and to 0 if you don't. */ #undef HAVE_DECL_AI_ALL /* Define to 1 if you have the declaration of `AI_NUMERICSERV', and to 0 if you don't. */ #undef HAVE_DECL_AI_NUMERICSERV /* Define to 1 if you have the declaration of `AI_V4MAPPED', and to 0 if you don't. */ #undef HAVE_DECL_AI_V4MAPPED /* Define to 1 if you have the declaration of `IPPROTO_IP', and to 0 if you don't. */ #undef HAVE_DECL_IPPROTO_IP /* Define to 1 if you have the declaration of `IPPROTO_IPV6', and to 0 if you don't. */ #undef HAVE_DECL_IPPROTO_IPV6 /* Define to 1 if you have the declaration of `IPPROTO_TCP', and to 0 if you don't. */ #undef HAVE_DECL_IPPROTO_TCP /* Define to 1 if you have the declaration of `IPV6_V6ONLY', and to 0 if you don't. */ #undef HAVE_DECL_IPV6_V6ONLY /* Define to 1 if you have the declaration of `SO_PEERCRED', and to 0 if you don't. */ #undef HAVE_DECL_SO_PEERCRED /* Define to 1 if you have the header file. */ #undef HAVE_FCNTL_H /* Define to 1 if you have the `gai_strerror' function. */ #undef HAVE_GAI_STRERROR /* Define to 1 if you have the `gethostent' function. */ #undef HAVE_GETHOSTENT /* Define to 1 if you have the `getpeereid' function. */ #undef HAVE_GETPEEREID /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_LIMITS_H /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #undef HAVE_NETDB_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_TCP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETIOAPI_H /* Define to 1 if you have the header file. */ #undef HAVE_NET_IF_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if `msg_accrights' is a member of `struct msghdr'. */ #undef HAVE_STRUCT_MSGHDR_MSG_ACCRIGHTS /* Define to 1 if `msg_control' is a member of `struct msghdr'. */ #undef HAVE_STRUCT_MSGHDR_MSG_CONTROL /* Define to 1 if `sa_len' is a member of `struct sockaddr'. */ #undef HAVE_STRUCT_SOCKADDR_SA_LEN /* Define to 1 if the system has the type `struct ucred'. */ #undef HAVE_STRUCT_UCRED /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SOCKET_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_UIO_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_UN_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define to empty if `const' does not conform to ANSI C. */ #undef const network-3.1.4.0/include/afunix_compat.h0000644000000000000000000000114507346545000016171 0ustar0000000000000000/* The version of afunix.h provided by the version of MSYS2 included with x86 * versions of GHC before GHC 9.2 excludes certain components introduced with * Windows Vista. */ #ifndef AFUNIX_COMPAT_H #define AFUNIX_COMPAT_H #if defined(_AFUNIX_) || !defined(_WIN32) || __GLASGOW_HASKELL__ > 902 # include #else #define UNIX_PATH_MAX 108 typedef struct sockaddr_un { ADDRESS_FAMILY sun_family; char sun_path[UNIX_PATH_MAX]; } SOCKADDR_UN, *PSOCKADDR_UN; #define SIO_AF_UNIX_GETPEERPID _WSAIOR(IOC_VENDOR, 256) #endif /* GHC version check */ #endif /* AFUNIX_COMPAT_H */network-3.1.4.0/include/alignment.h0000644000000000000000000000022207346545000015305 0ustar0000000000000000#if __GLASGOW_HASKELL__ < 711 #define hsc_alignment(t ) hsc_printf ( "%lu", (unsigned long)offsetof(struct {char x__; t(y__); }, y__)); #endif network-3.1.4.0/include/win32defs.h0000644000000000000000000000762207346545000015146 0ustar0000000000000000#ifndef IP_OPTIONS #define IP_OPTIONS 1 // Set/get IP options. #endif #ifndef IP_HDRINCL #define IP_HDRINCL 2 // Header is included with data. #endif #ifndef IP_TOS #define IP_TOS 3 // IP type of service. #endif #ifndef IP_TTL #define IP_TTL 4 // IP TTL (hop limit). #endif #ifndef IP_MULTICAST_IF #define IP_MULTICAST_IF 9 // IP multicast interface. #endif #ifndef IP_MULTICAST_TTL #define IP_MULTICAST_TTL 10 // IP multicast TTL (hop limit). #endif #ifndef IP_MULTICAST_LOOP #define IP_MULTICAST_LOOP 11 // IP multicast loopback. #endif #ifndef IP_ADD_MEMBERSHIP #define IP_ADD_MEMBERSHIP 12 // Add an IP group membership. #endif #ifndef IP_DROP_MEMBERSHIP #define IP_DROP_MEMBERSHIP 13 // Drop an IP group membership. #endif #ifndef IP_DONTFRAGMENT #define IP_DONTFRAGMENT 14 // Don't fragment IP datagrams. #endif #ifndef IP_ADD_SOURCE_MEMBERSHIP #define IP_ADD_SOURCE_MEMBERSHIP 15 // Join IP group/source. #endif #ifndef IP_DROP_SOURCE_MEMBERSHIP #define IP_DROP_SOURCE_MEMBERSHIP 16 // Leave IP group/source. #endif #ifndef IP_BLOCK_SOURCE #define IP_BLOCK_SOURCE 17 // Block IP group/source. #endif #ifndef IP_UNBLOCK_SOURCE #define IP_UNBLOCK_SOURCE 18 // Unblock IP group/source. #endif #ifndef IP_PKTINFO #define IP_PKTINFO 19 // Receive packet information. #endif #ifndef IP_HOPLIMIT #define IP_HOPLIMIT 21 // Receive packet hop limit. #endif #ifndef IP_RECVTTL #define IP_RECVTTL 21 // Receive packet Time To Live (TTL). #endif #ifndef IP_RECEIVE_BROADCAST #define IP_RECEIVE_BROADCAST 22 // Allow/block broadcast reception. #endif #ifndef IP_RECVIF #define IP_RECVIF 24 // Receive arrival interface. #endif #ifndef IP_RECVDSTADDR #define IP_RECVDSTADDR 25 // Receive destination address. #endif #ifndef IP_IFLIST #define IP_IFLIST 28 // Enable/Disable an interface list. #endif #ifndef IP_ADD_IFLIST #define IP_ADD_IFLIST 29 // Add an interface list entry. #endif #ifndef IP_DEL_IFLIST #define IP_DEL_IFLIST 30 // Delete an interface list entry. #endif #ifndef IP_UNICAST_IF #define IP_UNICAST_IF 31 // IP unicast interface. #endif #ifndef IP_RTHDR #define IP_RTHDR 32 // Set/get IPv6 routing header. #endif #ifndef IP_GET_IFLIST #define IP_GET_IFLIST 33 // Get an interface list. #endif #ifndef IP_RECVRTHDR #define IP_RECVRTHDR 38 // Receive the routing header. #endif #ifndef IP_TCLASS #define IP_TCLASS 39 // Packet traffic class. #endif #ifndef IP_RECVTCLASS #define IP_RECVTCLASS 40 // Receive packet traffic class. #endif #ifndef IP_RECVTOS #define IP_RECVTOS 40 // Receive packet Type Of Service (TOS). #endif #ifndef IP_ORIGINAL_ARRIVAL_IF #define IP_ORIGINAL_ARRIVAL_IF 47 // Original Arrival Interface Index. #endif #ifndef IP_ECN #define IP_ECN 50 // Receive ECN codepoints in the IP header. #endif #ifndef IP_PKTINFO_EX #define IP_PKTINFO_EX 51 // Receive extended packet information. #endif #ifndef IP_WFP_REDIRECT_RECORDS #define IP_WFP_REDIRECT_RECORDS 60 // WFP's Connection Redirect Records. #endif #ifndef IP_WFP_REDIRECT_CONTEXT #define IP_WFP_REDIRECT_CONTEXT 70 // WFP's Connection Redirect Context. #endif #ifndef IP_MTU_DISCOVER #define IP_MTU_DISCOVER 71 // Set/get path MTU discover state. #endif #ifndef IP_MTU #define IP_MTU 73 // Get path MTU. #endif #ifndef IP_NRT_INTERFACE #define IP_NRT_INTERFACE 74 // Set NRT interface constraint (outbound). #endif #ifndef IP_RECVERR #define IP_RECVERR 75 // Receive ICMP errors. #endif #ifndef IPV6_TCLASS #define IPV6_TCLASS 39 #endifnetwork-3.1.4.0/install-sh0000644000000000000000000002017407346545000013544 0ustar0000000000000000#!/bin/sh # install - install a program, script, or datafile scriptversion=2003-09-24.23 # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. It can only install one file at a time, a restriction # shared with many OS's install programs. # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename= transform_arg= instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd= chgrpcmd= stripcmd= rmcmd="$rmprog -f" mvcmd="$mvprog" src= dst= dir_arg= usage="Usage: $0 [OPTION]... SRCFILE DSTFILE or: $0 -d DIR1 DIR2... In the first form, install SRCFILE to DSTFILE, removing SRCFILE by default. In the second, create the directory path DIR. Options: -b=TRANSFORMBASENAME -c copy source (using $cpprog) instead of moving (using $mvprog). -d create directories instead of installing files. -g GROUP $chgrp installed files to GROUP. -m MODE $chmod installed files to MODE. -o USER $chown installed files to USER. -s strip installed files (using $stripprog). -t=TRANSFORM --help display this help and exit. --version display version info and exit. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test -n "$1"; do case $1 in -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; -c) instcmd=$cpprog shift continue;; -d) dir_arg=true shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; --help) echo "$usage"; exit 0;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -s) stripcmd=$stripprog shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; --version) echo "$0 $scriptversion"; exit 0;; *) if test -z "$src"; then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if test -z "$src"; then echo "$0: no input file specified." >&2 exit 1 fi # Protect names starting with `-'. case $src in -*) src=./$src ;; esac if test -n "$dir_arg"; then dst=$src src= if test -d "$dst"; then instcmd=: chmodcmd= else instcmd=$mkdirprog fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst"; then echo "$0: no destination specified." >&2 exit 1 fi # Protect names starting with `-'. case $dst in -*) dst=./$dst ;; esac # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then dst=$dst/`basename "$src"` fi fi # This sed command emulates the dirname command. dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # Skip lots of stat calls in the usual case. if test ! -d "$dstdir"; then defaultIFS=' ' IFS="${IFS-$defaultIFS}" oIFS=$IFS # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'` IFS=$oIFS pathcomp= while test $# -ne 0 ; do pathcomp=$pathcomp$1 shift test -d "$pathcomp" || $mkdirprog "$pathcomp" pathcomp=$pathcomp/ done fi if test -n "$dir_arg"; then $doit $instcmd "$dst" \ && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \ && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \ && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \ && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; } else # If we're going to rename the final executable, determine the name now. if test -z "$transformarg"; then dstfile=`basename "$dst"` else dstfile=`basename "$dst" $transformbasename \ | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename. test -z "$dstfile" && dstfile=`basename "$dst"` # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0 trap '(exit $?); exit' 1 2 13 15 # Move or copy the file name to the temp name $doit $instcmd "$src" "$dsttmp" && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \ && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \ && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \ && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } && # Now remove or move aside any old file at destination location. We # try this two ways since rm can't unlink itself on some systems and # the destination file might be busy for other reasons. In this case, # the final cleanup might fail but the new file should still install # successfully. { if test -f "$dstdir/$dstfile"; then $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \ || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \ || { echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2 (exit 1); exit } else : fi } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dstdir/$dstfile" fi && # The final little trick to "correctly" pass the exit status to the exit trap. { (exit 0); exit } # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-end: "$" # End: network-3.1.4.0/network.cabal0000644000000000000000000001210207346545000014210 0ustar0000000000000000cabal-version: 1.18 name: network version: 3.1.4.0 license: BSD3 license-file: LICENSE maintainer: Kazu Yamamoto, Evan Borden tested-with: GHC == 9.6.1 GHC == 9.4.4 GHC == 9.2.7 GHC == 9.0.2 GHC == 8.10.7 GHC == 8.8.4 GHC == 8.6.5 GHC == 8.4.4 GHC == 8.2.2 GHC == 8.0.2 homepage: https://github.com/haskell/network bug-reports: https://github.com/haskell/network/issues synopsis: Low-level networking interface description: This package provides a low-level networking interface. . === High-Level Packages Other packages provide higher level interfaces: . * connection * hookup * network-simple . === Extended Packages @network@ seeks to provide a cross-platform core for networking. As such some APIs live in extended libraries. Packages in the @network@ ecosystem are often prefixed with @network-@. . ==== @network-bsd@ In @network-3.0.0.0@ the @Network.BSD@ module was split off into its own package, @network-bsd-3.0.0.0@. . ==== @network-uri@ In @network-2.6@ the @Network.URI@ module was split off into its own package, @network-uri-2.6@. If you're using the @Network.URI@ module you can automatically get it from the right package by adding this to your @.cabal@ file: . > library > build-depends: network-uri-flag category: Network build-type: Configure extra-doc-files: README.md CHANGELOG.md extra-source-files: examples/*.hs tests/*.hs config.guess config.sub install-sh configure.ac configure include/HsNetworkConfig.h.in include/HsNet.h include/HsNetDef.h include/afunix_compat.h cbits/asyncAccept.c cbits/initWinSock.c cbits/winSockErr.c cbits/cmsg.c extra-tmp-files: config.log config.status autom4te.cache network.buildinfo include/HsNetworkConfig.h source-repository head type: git location: https://github.com/haskell/network.git flag devel description: using tests for developers default: False library exposed-modules: Network.Socket Network.Socket.Address Network.Socket.ByteString Network.Socket.ByteString.Lazy Network.Socket.Internal build-tools: hsc2hs >=0 c-sources: cbits/HsNet.c cbits/cmsg.c other-modules: Network.Socket.Buffer Network.Socket.ByteString.IO Network.Socket.ByteString.Internal Network.Socket.Cbits Network.Socket.Fcntl Network.Socket.Flag Network.Socket.Handle Network.Socket.If Network.Socket.Imports Network.Socket.Info Network.Socket.Name Network.Socket.Options Network.Socket.ReadShow Network.Socket.Shutdown Network.Socket.SockAddr Network.Socket.Syscall Network.Socket.Types Network.Socket.Unix default-language: Haskell2010 include-dirs: include includes: HsNet.h HsNetDef.h alignment.h win32defs.h install-includes: HsNet.h HsNetDef.h alignment.h win32defs.h if os(windows) includes: afunix_compat.h install-includes: afunix_compat.h ghc-options: -Wall -fwarn-tabs build-depends: base >=4.9 && <5, bytestring >=0.10 && <0.12, deepseq, directory if !os(windows) other-modules: Network.Socket.ByteString.Lazy.Posix Network.Socket.Posix.Cmsg Network.Socket.Posix.CmsgHdr Network.Socket.Posix.IOVec Network.Socket.Posix.MsgHdr if os(solaris) cpp-options: -D__EXTENSIONS__ -D_XOPEN_SOURCE=500 cc-options: -D__EXTENSIONS__ -D_XOPEN_SOURCE=500 extra-libraries: nsl socket if os(windows) c-sources: cbits/initWinSock.c cbits/winSockErr.c cbits/asyncAccept.c other-modules: Network.Socket.ByteString.Lazy.Windows Network.Socket.Win32.Cmsg Network.Socket.Win32.CmsgHdr Network.Socket.Win32.WSABuf Network.Socket.Win32.MsgHdr extra-libraries: ws2_32 iphlpapi mswsock if impl(ghc >=7.10) cpp-options: -D_WIN32_WINNT=0x0600 cc-options: -D_WIN32_WINNT=0x0600 build-depends: temporary test-suite spec type: exitcode-stdio-1.0 main-is: Spec.hs build-tools: hspec-discover >=2.6 hs-source-dirs: tests other-modules: Network.Test.Common Network.SocketSpec Network.Socket.ByteStringSpec Network.Socket.ByteString.LazySpec default-language: Haskell2010 ghc-options: -Wall -threaded build-depends: base >=4.9 && <5, bytestring, directory, HUnit, network, temporary, hspec >=2.6, QuickCheck if flag(devel) cpp-options: -DDEVELOPMENT network-3.1.4.0/tests/0000755000000000000000000000000007346545000012701 5ustar0000000000000000network-3.1.4.0/tests/BadFileDescriptor.hs0000644000000000000000000000336007346545000016564 0ustar0000000000000000-- Test code for "threadWait: invalid argument (Bad file descriptor)" -- See https://ghc.haskell.org/trac/ghc/ticket/14621 -- See https://github.com/haskell/network/issues/287 -- -- % runghc BadFileDescriptor.hs -- BadFileDescriptor.hs: threadWait: invalid argument (Bad file descriptor) module Main where import Control.Concurrent (forkIO) import Control.Monad (void, forever) import Network.Socket hiding (recv) import Network.Socket.ByteString (recv, sendAll) main :: IO () main = do let localhost = "localhost" listenPort = "9876" connectPort = "6789" proxy localhost listenPort connectPort proxy :: HostName -> ServiceName -> ServiceName -> IO () proxy localhost listenPort connectPort = do fromClient <- serverSocket localhost listenPort toServer <- clientSocket localhost connectPort void $ forkIO $ relay toServer fromClient relay fromClient toServer relay :: Socket -> Socket -> IO () relay s1 s2 = forever $ do payload <- recv s1 4096 sendAll s2 payload serverSocket :: HostName -> ServiceName -> IO Socket serverSocket host port = do let hints = defaultHints { addrFlags = [AI_PASSIVE] , addrSocketType = Stream } addr:_ <- getAddrInfo (Just hints) (Just host) (Just port) sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) bind sock (addrAddress addr) listen sock 1 fst <$> accept sock clientSocket :: HostName -> ServiceName -> IO Socket clientSocket host port = do let hints = defaultHints { addrSocketType = Stream } addr:_ <- getAddrInfo (Just hints) (Just host) (Just port) sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) connect sock (addrAddress addr) return sock network-3.1.4.0/tests/Network/Socket/ByteString/0000755000000000000000000000000007346545000017654 5ustar0000000000000000network-3.1.4.0/tests/Network/Socket/ByteString/LazySpec.hs0000644000000000000000000000537607346545000021755 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} module Network.Socket.ByteString.LazySpec (main, spec) where import Prelude hiding (getContents) import qualified Data.ByteString.Lazy as L import Network.Socket import Network.Socket.ByteString.Lazy import Network.Test.Common import Control.Monad import Test.Hspec main :: IO () main = hspec spec spec :: Spec spec = do describe "send" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` lazyTestMsg client sock = send sock lazyTestMsg tcpTest client server it "throws when closed" $ do let server _ = return () client sock = do close sock send sock lazyTestMsg `shouldThrow` anyException tcpTest client server describe "sendAll" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` lazyTestMsg client sock = sendAll sock lazyTestMsg tcpTest client server it "throws when closed" $ do let server _ = return () client sock = do close sock sendAll sock lazyTestMsg `shouldThrow` anyException tcpTest client server describe "getContents" $ do it "works well" $ do let server sock = getContents sock `shouldReturn` lazyTestMsg client sock = do void $ send sock lazyTestMsg shutdown sock ShutdownSend tcpTest client server it "returns empty string at EOF" $ do let client s = getContents s `shouldReturn` L.empty server s = shutdown s ShutdownSend tcpTest client server describe "recv" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` lazyTestMsg client sock = send sock lazyTestMsg tcpTest client server it "throws when closed" $ do let server sock = do close sock recv sock 1024 `shouldThrow` anyException client sock = send sock lazyTestMsg tcpTest client server it "can treat overflow" $ do let server sock = do seg1 <- recv sock (L.length lazyTestMsg - 3) seg2 <- recv sock 1024 let msg = L.append seg1 seg2 msg `shouldBe` lazyTestMsg client sock = send sock lazyTestMsg tcpTest client server it "returns empty string at EOF" $ do let client s = recv s 4096 `shouldReturn` L.empty server s = shutdown s ShutdownSend tcpTest client server network-3.1.4.0/tests/Network/Socket/0000755000000000000000000000000007346545000015562 5ustar0000000000000000network-3.1.4.0/tests/Network/Socket/ByteStringSpec.hs0000644000000000000000000002773607346545000021042 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} module Network.Socket.ByteStringSpec (main, spec) where import Control.Concurrent.MVar (newEmptyMVar, putMVar, takeMVar) import Data.Bits import Data.Maybe import Control.Monad import qualified Data.ByteString as S import qualified Data.ByteString.Char8 as C import Network.Socket import Network.Socket.ByteString import Network.Test.Common import System.Environment import Test.Hspec main :: IO () main = hspec spec spec :: Spec spec = do describe "send" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` testMsg client sock = send sock testMsg tcpTest client server it "throws when closed" $ do let server _ = return () client sock = do close sock send sock testMsg `shouldThrow` anyException tcpTest client server it "checks -1 correctly on Windows" $ do sock <- socket AF_INET Stream defaultProtocol send sock "hello world" `shouldThrow` anyException describe "sendAll" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` testMsg client sock = sendAll sock testMsg tcpTest client server it "throws when closed" $ do let server _ = return () client sock = do close sock sendAll sock testMsg `shouldThrow` anyException tcpTest client server describe "sendTo" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` testMsg client sock addr = sendTo sock testMsg addr udpTest client server it "throws when closed" $ do let server _ = return () client sock addr = do close sock sendTo sock testMsg addr `shouldThrow` anyException udpTest client server describe "sendAllTo" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` testMsg client sock addr = sendAllTo sock testMsg addr udpTest client server it "throws when closed" $ do let server _ = return () client sock addr = do close sock sendAllTo sock testMsg addr `shouldThrow` anyException udpTest client server describe "sendMany" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` S.append seg1 seg2 client sock = sendMany sock [seg1, seg2] seg1 = C.pack "This is a " seg2 = C.pack "test message." tcpTest client server it "throws when closed" $ do let server _ = return () client sock = do close sock sendMany sock [seg1, seg2] `shouldThrow` anyException seg1 = C.pack "This is a " seg2 = C.pack "test message." tcpTest client server describe "sendManyTo" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` S.append seg1 seg2 client sock addr = sendManyTo sock [seg1, seg2] addr seg1 = C.pack "This is a " seg2 = C.pack "test message." udpTest client server it "throws when closed" $ do let server _ = return () client sock addr = do close sock sendManyTo sock [seg1, seg2] addr `shouldThrow` anyException seg1 = C.pack "This is a " seg2 = C.pack "test message." udpTest client server describe "recv" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` testMsg client sock = send sock testMsg tcpTest client server it "throws when closed" $ do let server sock = do close sock recv sock 1024 `shouldThrow` anyException client sock = send sock testMsg tcpTest client server it "can treat overflow" $ do let server sock = do seg1 <- recv sock (S.length testMsg - 3) seg2 <- recv sock 1024 let msg = S.append seg1 seg2 msg `shouldBe` testMsg client sock = send sock testMsg tcpTest client server it "returns empty string at EOF" $ do let client s = recv s 4096 `shouldReturn` S.empty server s = shutdown s ShutdownSend tcpTest client server it "checks -1 correctly on Windows" $ do sock <- socket AF_INET Stream defaultProtocol recv sock 1024 `shouldThrow` anyException describe "recvFrom" $ do it "works well" $ do let server sock = do (msg, _) <- recvFrom sock 1024 testMsg `shouldBe` msg client sock = do addr <- getPeerName sock sendTo sock testMsg addr tcpTest client server it "throws when closed" $ do let server sock = do close sock recvFrom sock 1024 `shouldThrow` anyException client sock = do addr <- getPeerName sock sendTo sock testMsg addr tcpTest client server it "can treat overflow" $ do let server sock = do (seg1, _) <- recvFrom sock (S.length testMsg - 3) (seg2, _) <- recvFrom sock 1024 let msg = S.append seg1 seg2 testMsg `shouldBe` msg client sock = send sock testMsg tcpTest client server it "returns empty string at EOF" $ do let server sock = do (seg1, _) <- recvFrom sock (S.length testMsg - 3) seg1 `shouldBe` S.empty client sock = shutdown sock ShutdownSend tcpTest client server describe "sendMsg" $ do it "works well" $ do let server sock = recv sock 1024 `shouldReturn` S.append seg1 seg2 client sock addr = sendMsg sock addr [seg1, seg2] [] mempty seg1 = C.pack "This is a " seg2 = C.pack "test message." udpTest client server it "throws when closed" $ do let server _ = return () client sock addr = do close sock sendMsg sock addr [seg1, seg2] [] mempty `shouldThrow` anyException seg1 = C.pack "This is a " seg2 = C.pack "test message." udpTest client server describe "recvMsg" $ do it "works well" $ do let server sock = do (_, msg, cmsgs, flags) <- recvMsg sock 1024 0 mempty msg `shouldBe` seg cmsgs `shouldBe` [] flags `shouldBe` mempty client sock addr = sendTo sock seg addr seg = C.pack "This is a test message" udpTest client server it "receives truncated flag" $ do let server sock = do (_, _, _, flags) <- recvMsg sock (S.length seg - 2) 0 mempty flags .&. MSG_TRUNC `shouldBe` MSG_TRUNC client sock addr = sendTo sock seg addr seg = C.pack "This is a test message" udpTest client server it "peek" $ do let server sock = do (_, msgs, _, _flags) <- recvMsg sock 1024 0 MSG_PEEK -- flags .&. MSG_PEEK `shouldBe` MSG_PEEK -- Mac only (_, msgs', _, _) <- recvMsg sock 1024 0 mempty msgs `shouldBe` msgs' client sock addr = sendTo sock seg addr seg = C.pack "This is a test message" udpTest client server it "receives control messages for IPv4" $ do -- This test behaves strange on AppVeyor and I don't know why so skip -- TOS for now. isAppVeyor <- isJust <$> lookupEnv "APPVEYOR" -- Avoid race condition between the client sending the message and -- the server finishing its socket configuration. Otherwise the -- message may be received with default socket options! serverReady <- newEmptyMVar let server sock = do whenSupported RecvIPv4TTL $ setSocketOption sock RecvIPv4TTL 1 whenSupported RecvIPv4PktInfo $ setSocketOption sock RecvIPv4PktInfo 1 whenSupported RecvIPv4TOS $ setSocketOption sock RecvIPv4TOS 1 putMVar serverReady () (_, _, cmsgs, _) <- recvMsg sock 1024 128 mempty whenSupported RecvIPv4PktInfo $ ((lookupCmsg CmsgIdIPv4PktInfo cmsgs >>= decodeCmsg) :: Maybe IPv4PktInfo) `shouldNotBe` Nothing when (not isAppVeyor) $ do whenSupported RecvIPv4TTL $ ((lookupCmsg CmsgIdIPv4TTL cmsgs >>= decodeCmsg) :: Maybe IPv4TTL) `shouldNotBe` Nothing whenSupported RecvIPv4TOS $ ((lookupCmsg CmsgIdIPv4TOS cmsgs >>= decodeCmsg) :: Maybe IPv4TOS) `shouldNotBe` Nothing client sock addr = takeMVar serverReady >> sendTo sock seg addr seg = C.pack "This is a test message" udpTest client server it "receives control messages for IPv6" $ do -- Avoid race condition between the client sending the message and -- the server finishing its socket configuration. Otherwise the -- message may be received with default socket options! serverReady <- newEmptyMVar let server sock = do whenSupported RecvIPv6HopLimit $ setSocketOption sock RecvIPv6HopLimit 1 whenSupported RecvIPv6TClass $ setSocketOption sock RecvIPv6TClass 1 whenSupported RecvIPv6PktInfo $ setSocketOption sock RecvIPv6PktInfo 1 putMVar serverReady () (_, _, cmsgs, _) <- recvMsg sock 1024 128 mempty whenSupported RecvIPv6HopLimit $ ((lookupCmsg CmsgIdIPv6HopLimit cmsgs >>= decodeCmsg) :: Maybe IPv6HopLimit) `shouldNotBe` Nothing whenSupported RecvIPv6TClass $ ((lookupCmsg CmsgIdIPv6TClass cmsgs >>= decodeCmsg) :: Maybe IPv6TClass) `shouldNotBe` Nothing whenSupported RecvIPv6PktInfo $ ((lookupCmsg CmsgIdIPv6PktInfo cmsgs >>= decodeCmsg) :: Maybe IPv6PktInfo) `shouldNotBe` Nothing client sock addr = takeMVar serverReady >> sendTo sock seg addr seg = C.pack "This is a test message" udpTest6 client server it "receives truncated control messages" $ do -- Avoid race condition between the client sending the message and -- the server finishing its socket configuration. Otherwise the -- message may be received with default socket options! serverReady <- newEmptyMVar let server sock = do whenSupported RecvIPv4TTL $ setSocketOption sock RecvIPv4TTL 1 whenSupported RecvIPv4TOS $ setSocketOption sock RecvIPv4TOS 1 whenSupported RecvIPv4PktInfo $ setSocketOption sock RecvIPv4PktInfo 1 putMVar serverReady () (_, _, _, flags) <- recvMsg sock 1024 10 mempty flags .&. MSG_CTRUNC `shouldBe` MSG_CTRUNC client sock addr = takeMVar serverReady >> sendTo sock seg addr seg = C.pack "This is a test message" udpTest client server network-3.1.4.0/tests/Network/0000755000000000000000000000000007346545000014332 5ustar0000000000000000network-3.1.4.0/tests/Network/SocketSpec.hs0000644000000000000000000004572107346545000016742 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} module Network.SocketSpec (main, spec) where import Control.Concurrent (threadDelay, forkIO) import Control.Concurrent.MVar (readMVar) import Control.Monad import Data.Maybe (fromJust) import Data.List (nub) import Network.Socket import Network.Socket.ByteString import Network.Test.Common import System.Mem (performGC) import System.IO.Error (tryIOError) import System.IO.Temp (withSystemTempDirectory) import Foreign.C.Types () import Test.Hspec import Test.QuickCheck main :: IO () main = hspec spec spec :: Spec spec = do describe "connect" $ do let hints = defaultHints { addrSocketType = Stream } connect' serverPort = do addr:_ <- getAddrInfo (Just hints) (Just serverAddr) (Just $ show serverPort) sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) connect sock (addrAddress addr) return sock it "fails to connect and throws an IOException" $ do connect' (8003 :: Int) `shouldThrow` anyIOException it "successfully connects to a socket with no exception" $ do withPort $ \portVar -> test (tcp serverAddr return portVar) { clientSetup = readMVar portVar >>= connect' } describe "bind" $ do let hints = defaultHints { addrFlags = [AI_PASSIVE] , addrSocketType = Stream } it "successfully binds to an ipv4 socket" $ do addr:_ <- getAddrInfo (Just hints) (Just serverAddr) Nothing sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) bind sock $ addrAddress addr {- This does not work on Windows and Linux. it "fails to bind to unknown ipv4 socket" $ do addr:_ <- getAddrInfo (Just hints) (Just "127.0.0.3") Nothing sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) bind sock (addrAddress addr) `shouldThrow` anyIOException -} #ifdef DEVELOPMENT it "successfully binds to an ipv6 socket" $ do addr:_ <- getAddrInfo (Just hints) (Just serverAddr6) Nothing sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) bind sock $ addrAddress addr it "fails to bind to unknown ipv6 socket" $ do addr:_ <- getAddrInfo (Just hints) (Just "::6") Nothing sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) bind sock (addrAddress addr) `shouldThrow` anyIOException #endif it "successfully binds to a unix socket" $ do withSystemTempDirectory "haskell-network" $ \path -> do let sfile = path ++ "/socket-file" -- exist <- doesFileExist sfile -- when exist $ removeFile sfile -- removeFile sfile let addr = SockAddrUnix sfile when (isSupportedSockAddr addr) $ do sock0 <- socket AF_UNIX Stream defaultProtocol bind sock0 addr listen sock0 1 sock1 <- socket AF_UNIX Stream defaultProtocol tryIOError (bind sock1 addr) >>= \o -> case o of Right () -> error "bind should have failed but succeeded" _ -> return () close sock0 close sock1 describe "UserTimeout" $ do it "can be set" $ do when (isSupportedSocketOption UserTimeout) $ do sock <- socket AF_INET Stream defaultProtocol setSocketOption sock UserTimeout 1000 getSocketOption sock UserTimeout `shouldReturn` 1000 setSocketOption sock UserTimeout 2000 getSocketOption sock UserTimeout `shouldReturn` 2000 close sock describe "getAddrInfo" $ do it "works for IPv4 address" $ do let hints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_ADDRCONFIG] } AddrInfo{addrAddress = (SockAddrInet _ hostAddr)}:_ <- getAddrInfo (Just hints) (Just "127.128.129.130") Nothing hostAddressToTuple hostAddr `shouldBe` (0x7f, 0x80, 0x81, 0x82) it "works for IPv6 address" $ do let hints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_ADDRCONFIG] } host = "2001:0db8:85a3:0000:0000:8a2e:0370:7334" AddrInfo{addrAddress = (SockAddrInet6 _ _ hostAddr _)}:_ <- getAddrInfo (Just hints) (Just host) Nothing hostAddress6ToTuple hostAddr `shouldBe` (0x2001, 0x0db8, 0x85a3, 0x0000, 0x0000, 0x8a2e, 0x0370, 0x7334) it "does not cause segfault on macOS 10.8.2 due to AI_NUMERICSERV" $ do let hints = defaultHints { addrFlags = [AI_NUMERICSERV] } void $ getAddrInfo (Just hints) (Just "localhost") Nothing #if defined(mingw32_HOST_OS) let lpdevname = "loopback_0" #elif defined(darwin_HOST_OS) || defined(freebsd_HOST_OS) || defined(openbsd_HOST_OS) let lpdevname = "lo0" #else let lpdevname = "lo" #endif describe "ifNameToIndex and ifIndexToName" $ do it "convert a name to an index and back" $ do n <- ifNameToIndex lpdevname n `shouldNotBe` Nothing ifIndexToName (fromJust n) `shouldReturn` Just lpdevname describe "socket" $ do let gc = do threadDelay 100000 performGC connect' = do threadDelay 200000 sock <- socket AF_INET Stream defaultProtocol connect sock $ SockAddrInet 6000 $ tupleToHostAddress (127, 0, 0, 1) it "should not be GCed while blocking" $ do sock <- socket AF_INET Stream defaultProtocol setSocketOption sock ReuseAddr 1 bind sock $ SockAddrInet 6000 $ tupleToHostAddress (127, 0, 0, 1) listen sock 1 _ <- forkIO gc _ <- forkIO connect' (_sock', addr) <- accept sock -- check if an exception is not thrown. isSupportedSockAddr addr `shouldBe` True #if !defined(mingw32_HOST_OS) when isUnixDomainSocketAvailable $ do context "unix sockets" $ do it "basic unix sockets end-to-end" $ do let client sock = send sock testMsg server (sock, addr) = do recv sock 1024 `shouldReturn` testMsg addr `shouldBe` (SockAddrUnix "") test . setClientAction client $ unixWithUnlink unixAddr server #endif #ifdef linux_HOST_OS it "can end-to-end with an abstract socket" $ do let abstractAddress = toEnum 0:"/haskell/network/abstract" client sock = send sock testMsg server (sock, addr) = do recv sock 1024 `shouldReturn` testMsg addr `shouldBe` (SockAddrUnix "") test . setClientAction client $ unix abstractAddress (const $ return ()) $ server it "safely throws an exception" $ do when isUnixDomainSocketAvailable $ do let abstractAddress = toEnum 0:"/haskell/network/abstract-longlonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglong" sock <- socket AF_UNIX Stream defaultProtocol bind sock (SockAddrUnix abstractAddress) `shouldThrow` anyErrorCall #endif #if !defined(mingw32_HOST_OS) describe "socketPair" $ do it "can send and recieve bi-directionally" $ do (s1, s2) <- socketPair AF_UNIX Stream defaultProtocol void $ send s1 testMsg recv s2 1024 `shouldReturn` testMsg void $ send s2 testMsg recv s1 1024 `shouldReturn` testMsg describe "sendFd/recvFd" $ do it "can send and recieve a file descriptor" $ do (s1, s2) <- socketPair AF_UNIX Stream defaultProtocol (s3, s4) <- socketPair AF_UNIX Stream defaultProtocol withFdSocket s1 $ \fd1 -> void $ sendFd s3 fd1 fd1' <- recvFd s4 s1' <- mkSocket fd1' void $ send s1' testMsg recv s2 1024 `shouldReturn` testMsg -- On various BSD systems the peer credentials are exchanged during -- connect(), and this does not happen with `socketpair()`. Therefore, -- we must actually set up a listener and connect, rather than use a -- socketpair(). -- describe "getPeerCredential" $ do it "can return something" $ do -- It would be useful to check that we did not get garbage -- back, but rather the actual uid of the test program. For -- that we'd need System.Posix.User, but that is not available -- under Windows. For now, accept the risk that we did not get -- the right answer. -- let server (sock, _) = do (_, uid, _) <- getPeerCredential sock uid `shouldNotBe` Nothing client sock = do (_, uid, _) <- getPeerCredential sock uid `shouldNotBe` Nothing test . setClientAction client $ unixWithUnlink unixAddr server {- The below test fails on many *BSD systems, because the getsockopt() call that underlies getpeereid() does not have the same meaning for all address families, but the C-library was not checking that the provided sock is an AF_UNIX socket. This will fixed some day, but we should not fail on those systems in the mean-time. The upstream C-library fix is to call getsockname() and check the address family before calling `getpeereid()`. We could duplicate that in our own code, and then this test would work on those platforms that have `getpeereid()` and not the SO_PEERCRED socket option. it "return nothing for non-UNIX-domain socket" $ do when isUnixDomainSocketAvailable $ do s <- socket AF_INET Stream defaultProtocol cred1 <- getPeerCredential s cred1 `shouldBe` (Nothing,Nothing,Nothing) -} #endif describe "gracefulClose" $ do it "does not send TCP RST back" $ do let server sock = do void $ recv sock 1024 -- receiving "GOAWAY" gracefulClose sock 3000 client sock = do sendAll sock "GOAWAY" threadDelay 10000 sendAll sock "PING" threadDelay 10000 void $ recv sock 1024 tcpTest client server describe "socketToFd" $ do it "socketToFd can send using fd" $ do let server sock = do void $ recv sock 1024 client sock = do fd <- socketToFd sock s <- mkSocket fd sendAll s "HELLO WORLD" tcpTest client server describe "getNameInfo" $ do it "works for IPv4 address" $ do let addr = SockAddrInet 80 (tupleToHostAddress (127, 0, 0, 1)) (hn_m, sn_m) <- getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True addr hn_m `shouldBe` (Just "127.0.0.1") sn_m `shouldBe` (Just "80") it "works for IPv6 address" $ do let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0x2001, 0x0db8, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7)) 0 (hn_m, sn_m) <- getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True addr hn_m `shouldBe`(Just "2001:db8:2:3:4:5:6:7") sn_m `shouldBe` (Just "80") it "works for IPv6 address" $ do let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0x2001, 0x0db8, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7)) 0 (hn_m, sn_m) <- getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True addr hn_m `shouldBe`(Just "2001:db8:2:3:4:5:6:7") sn_m `shouldBe` (Just "80") it "works for global multicast IPv6 address" $ do let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0xfe01, 0x0db8, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7)) 0 (hn_m, sn_m) <- getNameInfo [NI_NUMERICHOST, NI_NUMERICSERV] True True addr hn_m `shouldBe`(Just "fe01:db8:2:3:4:5:6:7") sn_m `shouldBe` (Just "80") describe "show SocketAddr" $ do it "works for IPv4 address" $ let addr = SockAddrInet 80 (tupleToHostAddress (127, 0, 0, 1)) in show addr `shouldBe` "127.0.0.1:80" it "works for IPv6 address" $ let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0x2001, 0x0db8, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7)) 0 in show addr `shouldBe` "[2001:db8:2:3:4:5:6:7]:80" it "works for IPv6 address with zeros" $ let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0x2001, 0x0db8, 0x2, 0x3, 0x0, 0x0, 0x0, 0x7)) 0 in show addr `shouldBe` "[2001:db8:2:3::7]:80" it "works for multicast IPv6 address with reserved scope" $ do let addr = SockAddrInet6 80 0 (tupleToHostAddress6 (0xff01, 0x1234, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7)) 0 show addr `shouldBe` "[ff01:1234:2:3:4:5:6:7]:80" describe "show Family" $ do it "works for pattern synonyms" $ let fam = AF_UNSPEC in show fam `shouldBe` "AF_UNSPEC" it "works for unsupported" $ let fam = GeneralFamily (-1) in show fam `shouldBe` "UnsupportedFamily" it "works for positive values" $ let fam = GeneralFamily 300 in show fam `shouldBe` "GeneralFamily 300" it "works for negative values" $ let fam = GeneralFamily (-300) in show fam `shouldBe` "GeneralFamily (-300)" describe "show SocketType" $ do it "works for pattern synonyms" $ let socktype = NoSocketType in show socktype `shouldBe` "NoSocketType" it "works for unsupported" $ let socktype = GeneralSocketType (-1) in show socktype `shouldBe` "UnsupportedSocketType" it "works for positive values" $ let socktype = GeneralSocketType 300 in show socktype `shouldBe` "GeneralSocketType 300" it "works for negative values" $ let socktype = GeneralSocketType (-300) in show socktype `shouldBe` "GeneralSocketType (-300)" describe "show SocketOptions" $ do it "works for pattern synonyms" $ let opt = ReuseAddr in show opt `shouldBe` "ReuseAddr" it "works for unsupported" $ let opt = SockOpt (-1) (-1) in show opt `shouldBe` "UnsupportedSocketOption" it "works for positive values" $ let opt = SockOpt 300 300 in show opt `shouldBe` "SockOpt 300 300" it "works for negative values" $ let opt = SockOpt (-300) (-300) in show opt `shouldBe` "SockOpt (-300) (-300)" describe "show CmsgId" $ do it "works for pattern synonyms" $ let msgid = CmsgIdIPv6HopLimit in show msgid `shouldBe` "CmsgIdIPv6HopLimit" it "works for unsupported" $ let msgid = CmsgId (-1) (-1) in show msgid `shouldBe` "UnsupportedCmsgId" it "works for positive values" $ let msgid = CmsgId 300 300 in show msgid `shouldBe` "CmsgId 300 300" it "works for negative values" $ let msgid = CmsgId (-300) (-300) in show msgid `shouldBe` "CmsgId (-300) (-300)" describe "bijective read-show roundtrip equality" $ do it "holds for Family" $ forAll familyGen $ \x -> (read . show $ x) == (x :: Family) it "holds for SocketType" $ forAll socktypeGen $ \x -> (read . show $ x) == (x :: SocketType) it "holds for SocketOption" $ forAll sockoptGen $ \x -> (read . show $ x) == (x :: SocketOption) it "holds for CmsgId" $ forAll cmsgidGen $ \x -> (read . show $ x) == (x :: CmsgId) -- Type-specific generators with strong bias towards pattern synonyms -- Generator combinator that biases elements of a given list and otherwise -- applies a function to a given generator biasedGen :: (Gen a -> Gen b) -> [b] -> Gen a -> Gen b biasedGen f xs g = do useBias <- (arbitrary :: Gen Bool) if useBias then elements xs else f g familyGen :: Gen Family familyGen = biasedGen (fmap GeneralFamily) familyPatterns arbitrary socktypeGen :: Gen SocketType socktypeGen = biasedGen (fmap GeneralSocketType) socktypePatterns arbitrary sockoptGen :: Gen SocketOption sockoptGen = biasedGen (\g -> SockOpt <$> g <*> g) sockoptPatterns arbitrary cmsgidGen :: Gen CmsgId cmsgidGen = biasedGen (\g -> CmsgId <$> g <*> g) cmsgidPatterns arbitrary -- pruned lists of pattern synonym values for each type to generate values from familyPatterns :: [Family] familyPatterns = nub [UnsupportedFamily ,AF_UNSPEC,AF_UNIX,AF_INET,AF_INET6,AF_IMPLINK,AF_PUP,AF_CHAOS ,AF_NS,AF_NBS,AF_ECMA,AF_DATAKIT,AF_CCITT,AF_SNA,AF_DECnet ,AF_DLI,AF_LAT,AF_HYLINK,AF_APPLETALK,AF_ROUTE,AF_NETBIOS ,AF_NIT,AF_802,AF_ISO,AF_OSI,AF_NETMAN,AF_X25,AF_AX25,AF_OSINET ,AF_GOSSIP,AF_IPX,Pseudo_AF_XTP,AF_CTF,AF_WAN,AF_SDL,AF_NETWARE ,AF_NDD,AF_INTF,AF_COIP,AF_CNT,Pseudo_AF_RTIP,Pseudo_AF_PIP ,AF_SIP,AF_ISDN,Pseudo_AF_KEY,AF_NATM,AF_ARP,Pseudo_AF_HDRCMPLT ,AF_ENCAP,AF_LINK,AF_RAW,AF_RIF,AF_NETROM,AF_BRIDGE,AF_ATMPVC ,AF_ROSE,AF_NETBEUI,AF_SECURITY,AF_PACKET,AF_ASH,AF_ECONET ,AF_ATMSVC,AF_IRDA,AF_PPPOX,AF_WANPIPE,AF_BLUETOOTH,AF_CAN] socktypePatterns :: [SocketType] socktypePatterns = nub [ UnsupportedSocketType , NoSocketType , Stream , Datagram , Raw , RDM , SeqPacket ] sockoptPatterns :: [SocketOption] sockoptPatterns = nub [UnsupportedSocketOption ,Debug,ReuseAddr,SoDomain,Type,SoProtocol,SoError,DontRoute ,Broadcast,SendBuffer,RecvBuffer,KeepAlive,OOBInline,TimeToLive ,MaxSegment,NoDelay,Cork,Linger,ReusePort ,RecvLowWater,SendLowWater,RecvTimeOut,SendTimeOut ,UseLoopBack,UserTimeout,IPv6Only ,RecvIPv4TTL,RecvIPv4TOS,RecvIPv4PktInfo ,RecvIPv6HopLimit,RecvIPv6TClass,RecvIPv6PktInfo] cmsgidPatterns :: [CmsgId] cmsgidPatterns = nub [ UnsupportedCmsgId , CmsgIdIPv4TTL , CmsgIdIPv6HopLimit , CmsgIdIPv4TOS , CmsgIdIPv6TClass , CmsgIdIPv4PktInfo , CmsgIdIPv6PktInfo , CmsgIdFd ] network-3.1.4.0/tests/Network/Test/0000755000000000000000000000000007346545000015251 5ustar0000000000000000network-3.1.4.0/tests/Network/Test/Common.hs0000644000000000000000000002056307346545000017043 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} module Network.Test.Common ( -- * Client server configuration ClientServer(..) , setClientAction , setServerAction , tcp , unix , unixWithUnlink , udp , withPort -- * Run a ClientServer configuration , test , tcpTest , tcpTest6 , udpTest , udpTest6 -- * Common constants , serverAddr , serverAddr6 , unixAddr , testMsg , lazyTestMsg ) where #if __GLASGOW_HASKELL__ < 709 import Control.Applicative ((<$>)) #endif import Control.Concurrent (ThreadId, forkIO, myThreadId) import Control.Concurrent.MVar (MVar, newEmptyMVar, putMVar, takeMVar, readMVar) import qualified Control.Exception as E import Control.Monad import Data.ByteString (ByteString) import qualified Data.ByteString.Lazy as L import Network.Socket import System.Directory import System.Timeout (timeout) import Test.Hspec serverAddr :: String serverAddr = "127.0.0.1" serverAddr6 :: String serverAddr6 = "::1" testMsg :: ByteString testMsg = "This is a test message." lazyTestMsg :: L.ByteString lazyTestMsg = L.fromStrict "This is a test message." unixAddr :: String unixAddr = "/tmp/network-test" -- | Establish a connection between client and server and then run -- 'clientAct' and 'serverAct', in different threads. Both actions -- get passed a connected 'Socket', used for communicating between -- client and server. 'unixTest' makes sure that the 'Socket' is -- closed after the actions have run. unixWithUnlink :: String -> ((Socket, SockAddr) -> IO b) -> (ClientServer Socket b) unixWithUnlink address = unix address unlink where unlink file = do exist <- doesFileExist file when exist $ removeFile file unix :: String -- ^ address -> (String -> IO ()) -- ^ clean up action -> ((Socket, SockAddr) -> IO b) -- ^ server action -> (ClientServer Socket b) unix address cleanupAct serverAct = defaultClientServer { clientSetup = do sock <- socket AF_UNIX Stream defaultProtocol connect sock (SockAddrUnix address) return sock , serverSetup = do sock <- socket AF_UNIX Stream defaultProtocol cleanupAct address -- just in case bind sock (SockAddrUnix address) listen sock 1 return sock , serverAction = \sock -> E.bracket (accept sock) (killClientSock . fst) serverAct } where killClientSock sock = do shutdown sock ShutdownBoth close sock cleanupAct address -- | Establish a connection between client and server and then run -- 'clientAct' and 'serverAct', in different threads. Both actions -- get passed a connected 'Socket', used for communicating between -- client and server. 'tcpTest' makes sure that the 'Socket' is -- closed after the actions have run. tcpTest :: (Socket -> IO a) -> (Socket -> IO b) -> IO () tcpTest client server = withPort $ test . setClientAction client . tcp serverAddr server tcpTest6 :: (Socket -> IO a) -> (Socket -> IO b) -> IO () tcpTest6 client server = withPort $ test . setClientAction client . tcp serverAddr6 server tcp :: HostName -> (Socket -> IO b) -> MVar PortNumber -> ClientServer Socket () tcp serverAddress serverAct portVar = defaultClientServer { clientSetup = do serverPort <- readMVar portVar addr <- resolveClient Stream serverAddress serverPort sock <- socketWithAddrInfo addr #if !defined(mingw32_HOST_OS) withFdSocket sock $ \fd -> do getNonBlock fd `shouldReturn` True getCloseOnExec fd `shouldReturn` False #endif connect sock $ addrAddress addr return sock , serverSetup = do addr <- resolveServer Stream serverAddress sock <- socketWithAddrInfo addr withFdSocket sock $ \fd -> do #if !defined(mingw32_HOST_OS) getNonBlock fd `shouldReturn` True getCloseOnExec fd `shouldReturn` False #endif setSocketOption sock ReuseAddr 1 setCloseOnExecIfNeeded fd #if !defined(mingw32_HOST_OS) getCloseOnExec fd `shouldReturn` True #endif bind sock $ addrAddress addr listen sock 1 serverPort <- socketPort sock putMVar portVar serverPort return sock , serverAction = \sock -> do (clientSock, _) <- accept sock #if !defined(mingw32_HOST_OS) withFdSocket sock $ \fd -> do getNonBlock fd `shouldReturn` True getCloseOnExec fd `shouldReturn` True #endif _ <- serverAct clientSock close clientSock } -- | Create an unconnected 'Socket' for sending UDP and receiving -- datagrams and then run 'clientAct' and 'serverAct'. udpTest :: (Socket -> SockAddr -> IO a) -> (Socket -> IO b) -> IO () udpTest client server = withPort $ test . setServerAction server . udp serverAddr client udpTest6 :: (Socket -> SockAddr -> IO a) -> (Socket -> IO b) -> IO () udpTest6 client server = withPort $ test . setServerAction server . udp serverAddr6 client udp :: HostName -> (Socket -> SockAddr -> IO a) -> MVar PortNumber -> ClientServer a Socket udp serverAddress clientAct portVar = defaultClientServer { clientSetup = do addr <- resolveClient Datagram serverAddress 8000 -- dummy port socketWithAddrInfo addr , clientAction = \sock -> do serverPort <- readMVar portVar addr <- resolveClient Datagram serverAddress serverPort clientAct sock $ addrAddress addr , serverSetup = do addr <- resolveServer Datagram serverAddress sock <- socketWithAddrInfo addr setSocketOption sock ReuseAddr 1 bind sock $ addrAddress addr serverPort <- socketPort sock putMVar portVar serverPort return sock } data ClientServer a b = ClientServer { clientSetup :: IO Socket , clientAction :: Socket -> IO a , serverSetup :: IO Socket , serverAction :: Socket -> IO b } setClientAction :: (Socket -> IO b) -> ClientServer a c -> ClientServer b c setClientAction f c = c { clientAction = f } setServerAction :: (Socket -> IO c) -> ClientServer a b -> ClientServer a c setServerAction f c = c { serverAction = f } defaultClientServer :: ClientServer Socket Socket defaultClientServer = ClientServer { clientSetup = E.throwIO $ userError "no client setup defined" , clientAction = return , serverSetup = E.throwIO $ userError "no server setup defined" , serverAction = return } -- | Run a client/server pair and synchronize them so that the server -- is started before the client and the specified server action is -- finished before the client closes the 'Socket'. test :: ClientServer a b -> IO () test conf = do tid <- myThreadId barrier <- newEmptyMVar _ <- forkIO $ server tid barrier client tid barrier where server tid barrier = bracketWithReraise tid (serverSetup conf) close $ \sock -> do serverReady Just _ <- timeout 1000000 $ (serverAction conf) sock putMVar barrier () where -- | Signal to the client that it can proceed. serverReady = putMVar barrier () client tid barrier = do takeMVar barrier -- Transfer exceptions to the main thread. bracketWithReraise tid (clientSetup conf) close $ \res -> do Just _ <- timeout 1000000 $ (clientAction conf) res takeMVar barrier withPort :: (MVar PortNumber -> IO a) -> IO a withPort f = f =<< newEmptyMVar -- | Like 'bracket' but catches and reraises the exception in another -- thread, specified by the first argument. bracketWithReraise :: ThreadId -> IO a -> (a -> IO b) -> (a -> IO ()) -> IO () bracketWithReraise tid setup teardown thing = E.bracket setup teardown thing `E.catch` \ (e :: E.SomeException) -> E.throwTo tid e resolveClient :: SocketType -> HostName -> PortNumber -> IO AddrInfo resolveClient socketType host port = head <$> getAddrInfo (Just hints) (Just host) (Just $ show port) where hints = defaultHints { addrSocketType = socketType , addrFlags = [AI_NUMERICHOST] } resolveServer :: SocketType -> HostName -> IO AddrInfo resolveServer socketType host = head <$> getAddrInfo (Just hints) (Just host) Nothing where hints = defaultHints { addrSocketType = socketType , addrFlags = [AI_PASSIVE] } socketWithAddrInfo :: AddrInfo -> IO Socket socketWithAddrInfo addr = socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr) network-3.1.4.0/tests/Spec.hs0000644000000000000000000000005407346545000014126 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-}