-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Low-level networking interface
--   
--   Low-level networking interface
@package network
@version 2.3.0.11


-- | This module defines functions for handling URIs. It presents
--   substantially the same interface as the older GHC Network.URI module,
--   but is implemented using Parsec rather than a Regex library that is
--   not available with Hugs. The internal representation of URI has been
--   changed so that URI strings are more completely preserved when
--   round-tripping to a URI value and back.
--   
--   In addition, four methods are provided for parsing different kinds of
--   URI string (as noted in RFC3986): <a>parseURI</a>,
--   <a>parseURIReference</a>, <a>parseRelativeReference</a> and
--   <a>parseAbsoluteURI</a>.
--   
--   Further, four methods are provided for classifying different kinds of
--   URI string (as noted in RFC3986): <a>isURI</a>, <a>isURIReference</a>,
--   <a>isRelativeReference</a> and <a>isAbsoluteURI</a>.
--   
--   The long-standing official reference for URI handling was RFC2396 [1],
--   as updated by RFC 2732 [2], but this was replaced by a new
--   specification, RFC3986 [3] in January 2005. This latter specification
--   has been used as the primary reference for constructing the URI parser
--   implemented here, and it is intended that there is a direct
--   relationship between the syntax definition in that document and this
--   parser implementation.
--   
--   RFC 1808 [4] contains a number of test cases for relative URI
--   handling. Dan Connolly's Python module <tt>uripath.py</tt> [5] also
--   contains useful details and test cases.
--   
--   Some of the code has been copied from the previous GHC implementation,
--   but the parser is replaced with one that performs more complete syntax
--   checking of the URI itself, according to RFC3986 [3].
--   
--   References
--   
--   <ol>
--   <li><a>http://www.ietf.org/rfc/rfc2396.txt</a></li>
--   <li><a>http://www.ietf.org/rfc/rfc2732.txt</a></li>
--   <li><a>http://www.ietf.org/rfc/rfc3986.txt</a></li>
--   <li><a>http://www.ietf.org/rfc/rfc1808.txt</a></li>
--   <li><a>http://www.w3.org/2000/10/swap/uripath.py</a></li>
--   </ol>
module Network.URI

-- | Represents a general universal resource identifier using its component
--   parts.
--   
--   For example, for the URI
--   
--   <pre>
--   foo://anonymous@www.haskell.org:42/ghc?query#frag
--   </pre>
--   
--   the components are:
data URI
URI :: String -> Maybe URIAuth -> String -> String -> String -> URI

-- | <pre>
--   foo:
--   </pre>
uriScheme :: URI -> String

-- | <pre>
--   //anonymous@www.haskell.org:42
--   </pre>
uriAuthority :: URI -> Maybe URIAuth

-- | <pre>
--   /ghc
--   </pre>
uriPath :: URI -> String

-- | <pre>
--   ?query
--   </pre>
uriQuery :: URI -> String

-- | <pre>
--   #frag
--   </pre>
uriFragment :: URI -> String

-- | Type for authority value within a URI
data URIAuth
URIAuth :: String -> String -> String -> URIAuth

-- | <pre>
--   anonymous@
--   </pre>
uriUserInfo :: URIAuth -> String

-- | <pre>
--   www.haskell.org
--   </pre>
uriRegName :: URIAuth -> String

-- | <pre>
--   :42
--   </pre>
uriPort :: URIAuth -> String

-- | Blank URI
nullURI :: URI

-- | Turn a string containing a URI into a <a>URI</a>. Returns
--   <a>Nothing</a> if the string is not a valid URI; (an absolute URI with
--   optional fragment identifier).
--   
--   NOTE: this is different from the previous network.URI, whose
--   <tt>parseURI</tt> function works like <a>parseURIReference</a> in this
--   module.
parseURI :: String -> Maybe URI

-- | Parse a URI reference to a <a>URI</a> value. Returns <a>Nothing</a> if
--   the string is not a valid URI reference. (an absolute or relative URI
--   with optional fragment identifier).
parseURIReference :: String -> Maybe URI

-- | Parse a relative URI to a <a>URI</a> value. Returns <a>Nothing</a> if
--   the string is not a valid relative URI. (a relative URI with optional
--   fragment identifier).
parseRelativeReference :: String -> Maybe URI

-- | Parse an absolute URI to a <a>URI</a> value. Returns <a>Nothing</a> if
--   the string is not a valid absolute URI. (an absolute URI without a
--   fragment identifier).
parseAbsoluteURI :: String -> Maybe URI

-- | Test if string contains a valid URI (an absolute URI with optional
--   fragment identifier).
isURI :: String -> Bool

-- | Test if string contains a valid URI reference (an absolute or relative
--   URI with optional fragment identifier).
isURIReference :: String -> Bool

-- | Test if string contains a valid relative URI (a relative URI with
--   optional fragment identifier).
isRelativeReference :: String -> Bool

-- | Test if string contains a valid absolute URI (an absolute URI without
--   a fragment identifier).
isAbsoluteURI :: String -> Bool

-- | Test if string contains a valid IPv6 address
isIPv6address :: String -> Bool

-- | Test if string contains a valid IPv4 address
isIPv4address :: String -> Bool

-- | Compute an absolute <a>URI</a> for a supplied URI relative to a given
--   base.
relativeTo :: URI -> URI -> Maybe URI

-- | Returns a new <a>URI</a> which represents the value of the first
--   <a>URI</a> interpreted as relative to the second <a>URI</a>. For
--   example:
--   
--   <pre>
--   "foo" `relativeTo` "http://bar.org/" = "http://bar.org/foo"
--   "http:foo" `nonStrictRelativeTo` "http://bar.org/" = "http://bar.org/foo"
--   </pre>
--   
--   Algorithm from RFC3986 [3], section 5.2.2
nonStrictRelativeTo :: URI -> URI -> Maybe URI

-- | Returns a new <a>URI</a> which represents the relative location of the
--   first <a>URI</a> with respect to the second <a>URI</a>. Thus, the
--   values supplied are expected to be absolute URIs, and the result
--   returned may be a relative URI.
--   
--   Example:
--   
--   <pre>
--   "http://example.com/Root/sub1/name2#frag"
--     `relativeFrom` "http://example.com/Root/sub2/name2#frag"
--     == "../sub1/name2#frag"
--   </pre>
--   
--   There is no single correct implementation of this function, but any
--   acceptable implementation must satisfy the following:
--   
--   <pre>
--   (uabs `relativeFrom` ubase) `relativeTo` ubase == uabs
--   </pre>
--   
--   For any valid absolute URI. (cf.
--   <a>http://lists.w3.org/Archives/Public/uri/2003Jan/0008.html</a>
--   <a>http://lists.w3.org/Archives/Public/uri/2003Jan/0005.html</a>)
relativeFrom :: URI -> URI -> URI

-- | Turn a <a>URI</a> into a string.
--   
--   Uses a supplied function to map the userinfo part of the URI.
--   
--   The Show instance for URI uses a mapping that hides any password that
--   may be present in the URI. Use this function with argument <tt>id</tt>
--   to preserve the password in the formatted output.
uriToString :: (String -> String) -> URI -> ShowS

-- | Returns <a>True</a> if the character is a "reserved" character in a
--   URI. To include a literal instance of one of these characters in a
--   component of a URI, it must be escaped.
isReserved :: Char -> Bool

-- | Returns <a>True</a> if the character is an "unreserved" character in a
--   URI. These characters do not need to be escaped in a URI. The only
--   characters allowed in a URI are either "reserved", "unreserved", or an
--   escape sequence (<tt>%</tt> followed by two hex digits).
isUnreserved :: Char -> Bool

-- | Returns <a>True</a> if the character is allowed in a URI.
isAllowedInURI :: Char -> Bool

-- | Returns <a>True</a> if the character is allowed unescaped in a URI.
isUnescapedInURI :: Char -> Bool

-- | Escape character if supplied predicate is not satisfied, otherwise
--   return character as singleton string.
escapeURIChar :: (Char -> Bool) -> Char -> String

-- | Can be used to make a string valid for use in a URI.
escapeURIString :: (Char -> Bool) -> String -> String

-- | Turns all instances of escaped characters in the string back into
--   literal characters.
unEscapeString :: String -> String

-- | Case normalization; cf. RFC3986 section 6.2.2.1 NOTE: authority case
--   normalization is not performed
normalizeCase :: String -> String

-- | Encoding normalization; cf. RFC3986 section 6.2.2.2
normalizeEscape :: String -> String

-- | Path segment normalization; cf. RFC3986 section 6.2.2.4
normalizePathSegments :: String -> String
parseabsoluteURI :: String -> Maybe URI
escapeString :: String -> (Char -> Bool) -> String
reserved :: Char -> Bool
unreserved :: Char -> Bool
scheme :: URI -> String
authority :: URI -> String
path :: URI -> String
query :: URI -> String
fragment :: URI -> String
instance Typeable URIAuth
instance Typeable URI
instance Eq URIAuth
instance Data URIAuth
instance Eq URI
instance Data URI
instance Show URI


-- | A module containing semi-public <a>Socket</a> internals. Modules which
--   extend the <a>Socket</a> 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

-- | Network byte order.
type HostAddress = Word32

-- | Host byte order.
type HostAddress6 = (Word32, Word32, Word32, Word32)
type FlowInfo = Word32
type ScopeID = Word32
newtype PortNumber
PortNum :: Word16 -> PortNumber
data SockAddr
SockAddrInet :: PortNumber -> HostAddress -> SockAddr
SockAddrInet6 :: PortNumber -> FlowInfo -> HostAddress6 -> ScopeID -> SockAddr
SockAddrUnix :: String -> SockAddr

-- | Read a <a>SockAddr</a> from the given memory location.
peekSockAddr :: Ptr SockAddr -> IO SockAddr

-- | Write the given <a>SockAddr</a> to the given memory location.
pokeSockAddr :: Ptr a -> SockAddr -> IO ()

-- | Computes the storage requirements (in bytes) of the given
--   <a>SockAddr</a>. This function differs from <a>sizeOf</a> in that the
--   value of the argument <i>is</i> used.
sizeOfSockAddr :: SockAddr -> Int

-- | Computes the storage requirements (in bytes) required for a
--   <a>SockAddr</a> with the given <a>Family</a>.
sizeOfSockAddrByFamily :: Family -> Int

-- | Use a <a>SockAddr</a> with a function requiring a pointer to a
--   <a>SockAddr</a> and the length of that <a>SockAddr</a>.
withSockAddr :: SockAddr -> (Ptr SockAddr -> Int -> IO a) -> IO a

-- | Create a new <a>SockAddr</a> for use with a function requiring a
--   pointer to a <a>SockAddr</a> and the length of that <a>SockAddr</a>.
withNewSockAddr :: Family -> (Ptr SockAddr -> Int -> IO a) -> IO a

-- | This data type might have different constructors depending on what is
--   supported by the operating system.
data Family
AF_UNSPEC :: Family
AF_UNIX :: Family
AF_INET :: Family
AF_INET6 :: Family
AF_SNA :: Family
AF_DECnet :: Family
AF_APPLETALK :: Family
AF_ROUTE :: Family
AF_X25 :: Family
AF_AX25 :: Family
AF_IPX :: Family
AF_ISDN :: Family
AF_NETROM :: Family
AF_BRIDGE :: Family
AF_ATMPVC :: Family
AF_ROSE :: Family
AF_NETBEUI :: Family
AF_SECURITY :: Family
AF_PACKET :: Family
AF_ASH :: Family
AF_ECONET :: Family
AF_ATMSVC :: Family
AF_IRDA :: Family
AF_PPPOX :: Family
AF_WANPIPE :: Family
AF_BLUETOOTH :: Family

-- | Throw an <a>IOError</a> corresponding to the current socket error.
throwSocketError :: String -> IO a

-- | Throw an <a>IOError</a> corresponding to the current socket error if
--   the IO action returns a result of <tt>-1</tt>. Discards the result of
--   the IO action after error handling.
throwSocketErrorIfMinus1_ :: (Eq a, Num a) => String -> IO a -> IO ()

-- | Throw an <a>IOError</a> corresponding to the current socket error if
--   the IO action returns a result of <tt>-1</tt>, but retries in case of
--   an interrupted operation.
throwSocketErrorIfMinus1Retry :: (Eq a, Num a) => String -> IO a -> IO a

-- | Throw an <a>IOError</a> corresponding to the current socket error if
--   the IO action returns a result of <tt>-1</tt>, 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 -> IO b -> IO a -> IO a

-- | On Windows operating systems, the networking subsystem has to be
--   initialised using <a>withSocketsDo</a> before any networking
--   operations can be used. eg.
--   
--   <pre>
--   main = withSocketsDo $ do {...}
--   </pre>
--   
--   Although this is only strictly necessary on Windows platforms, it is
--   harmless on other platforms, so for portability it is good practice to
--   use it all the time.
withSocketsDo :: IO a -> IO a

-- | Zero a structure.
zeroMemory :: Ptr a -> CSize -> IO ()
instance Typeable PortNumber
instance Typeable SockAddr
instance Eq PortNumber
instance Ord PortNumber
instance Eq SockAddr
instance Eq Family
instance Ord Family
instance Read Family
instance Show Family
instance Storable HostAddress6


-- | The <a>Network.Socket</a> module is for when you want full control
--   over sockets. Essentially the entire C socket API is exposed through
--   this module; in general the operations follow the behaviour of the C
--   functions of the same name (consult your favourite Unix networking
--   book).
--   
--   A higher level interface to networking operations is provided through
--   the module <a>Network</a>.
module Network.Socket
data Socket
MkSocket :: CInt -> Family -> SocketType -> ProtocolNumber -> (MVar SocketStatus) -> Socket

-- | This data type might have different constructors depending on what is
--   supported by the operating system.
data Family
AF_UNSPEC :: Family
AF_UNIX :: Family
AF_INET :: Family
AF_INET6 :: Family
AF_SNA :: Family
AF_DECnet :: Family
AF_APPLETALK :: Family
AF_ROUTE :: Family
AF_X25 :: Family
AF_AX25 :: Family
AF_IPX :: Family
AF_ISDN :: Family
AF_NETROM :: Family
AF_BRIDGE :: Family
AF_ATMPVC :: Family
AF_ROSE :: Family
AF_NETBEUI :: Family
AF_SECURITY :: Family
AF_PACKET :: Family
AF_ASH :: Family
AF_ECONET :: Family
AF_ATMSVC :: Family
AF_IRDA :: Family
AF_PPPOX :: Family
AF_WANPIPE :: Family
AF_BLUETOOTH :: Family

-- | Socket Types.
--   
--   This data type might have different constructors depending on what is
--   supported by the operating system.
data SocketType
NoSocketType :: SocketType
Stream :: SocketType
Datagram :: SocketType
Raw :: SocketType
RDM :: SocketType
SeqPacket :: SocketType
data SockAddr
SockAddrInet :: PortNumber -> HostAddress -> SockAddr
SockAddrInet6 :: PortNumber -> FlowInfo -> HostAddress6 -> ScopeID -> SockAddr
SockAddrUnix :: String -> SockAddr
data SocketStatus
NotConnected :: SocketStatus
Bound :: SocketStatus
Listening :: SocketStatus
Connected :: SocketStatus
ConvertedToHandle :: SocketStatus
Closed :: SocketStatus

-- | Network byte order.
type HostAddress = Word32

-- | Host byte order.
type HostAddress6 = (Word32, Word32, Word32, Word32)
type FlowInfo = Word32
type ScopeID = Word32
data ShutdownCmd
ShutdownReceive :: ShutdownCmd
ShutdownSend :: ShutdownCmd
ShutdownBoth :: ShutdownCmd
type ProtocolNumber = CInt

-- | This is the default protocol for a given service.
defaultProtocol :: ProtocolNumber
newtype PortNumber
PortNum :: Word16 -> PortNumber

-- | Either a host name e.g., <tt>"haskell.org"</tt> or a numeric host
--   address string consisting of a dotted decimal IPv4 address or an IPv6
--   address e.g., <tt>"192.168.0.1"</tt>.
type HostName = String
type ServiceName = String
data AddrInfo
AddrInfo :: [AddrInfoFlag] -> Family -> SocketType -> ProtocolNumber -> SockAddr -> Maybe String -> AddrInfo
addrFlags :: AddrInfo -> [AddrInfoFlag]
addrFamily :: AddrInfo -> Family
addrSocketType :: AddrInfo -> SocketType
addrProtocol :: AddrInfo -> ProtocolNumber
addrAddress :: AddrInfo -> SockAddr
addrCanonName :: AddrInfo -> Maybe String

-- | Flags that control the querying behaviour of <a>getAddrInfo</a>.
data AddrInfoFlag
AI_ADDRCONFIG :: AddrInfoFlag
AI_ALL :: AddrInfoFlag
AI_CANONNAME :: AddrInfoFlag
AI_NUMERICHOST :: AddrInfoFlag
AI_NUMERICSERV :: AddrInfoFlag
AI_PASSIVE :: AddrInfoFlag
AI_V4MAPPED :: AddrInfoFlag

-- | Indicate whether the given <a>AddrInfoFlag</a> will have any effect on
--   this system.
addrInfoFlagImplemented :: AddrInfoFlag -> Bool

-- | Default hints for address lookup with <a>getAddrInfo</a>. The values
--   of the <a>addrAddress</a> and <a>addrCanonName</a> fields are
--   <a>undefined</a>, and are never inspected by <a>getAddrInfo</a>.
defaultHints :: AddrInfo

-- | Resolve a host or service name to one or more addresses. The
--   <a>AddrInfo</a> values that this function returns contain
--   <a>SockAddr</a> values that you can pass directly to <a>connect</a> or
--   <a>bindSocket</a>.
--   
--   This function is protocol independent. It can return both IPv4 and
--   IPv6 address information.
--   
--   The <a>AddrInfo</a> argument specifies the preferred query behaviour,
--   socket options, or protocol. You can override these conveniently using
--   Haskell's record update syntax on <a>defaultHints</a>, for example as
--   follows:
--   
--   <pre>
--   myHints = defaultHints { addrFlags = [AI_ADDRCONFIG, AI_CANONNAME] }
--   </pre>
--   
--   Values for <a>addrFlags</a> control query behaviour. The supported
--   flags are as follows:
--   
--   <ul>
--   <li><i><tt>AI_PASSIVE</tt></i> If no <a>HostName</a> value is
--   provided, the network address in each <a>SockAddr</a> will be left as
--   a <a>wild card</a>, i.e. as either <a>iNADDR_ANY</a> or
--   <a>iN6ADDR_ANY</a>. This is useful for server applications that will
--   accept connections from any client.</li>
--   <li><i><tt>AI_CANONNAME</tt></i> The <a>addrCanonName</a> field of the
--   first returned <a>AddrInfo</a> will contain the <a>canonical name</a>
--   of the host.</li>
--   <li><i><tt>AI_NUMERICHOST</tt></i> The <a>HostName</a> argument
--   <i>must</i> be a numeric address in string form, and network name
--   lookups will not be attempted.</li>
--   </ul>
--   
--   <i>Note</i>: Although the following flags are required by RFC 3493,
--   they may not have an effect on all platforms, because the underlying
--   network stack may not support them. To see whether a flag from the
--   list below will have any effect, call <a>addrInfoFlagImplemented</a>.
--   
--   <ul>
--   <li><i><tt>AI_NUMERICSERV</tt></i> The <a>ServiceName</a> argument
--   <i>must</i> be a port number in string form, and service name lookups
--   will not be attempted.</li>
--   <li><i><tt>AI_ADDRCONFIG</tt></i> The list of returned <a>AddrInfo</a>
--   values will only contain IPv4 addresses if the local system has at
--   least one IPv4 interface configured, and likewise for IPv6.</li>
--   <li><i><tt>AI_V4MAPPED</tt></i> If an IPv6 lookup is performed, and no
--   IPv6 addresses are found, IPv6-mapped IPv4 addresses will be
--   returned.</li>
--   <li><i><tt>AI_ALL</tt></i> If <a>AI_ALL</a> is specified, return all
--   matching IPv6 and IPv4 addresses. Otherwise, this flag has no
--   effect.</li>
--   </ul>
--   
--   You must provide a <a>Just</a> value for at least one of the
--   <a>HostName</a> or <a>ServiceName</a> arguments. <a>HostName</a> 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 <a>AI_NUMERICHOST</a> is specified
--   as a hint. If you do not provide a <a>HostName</a> value <i>and</i> do
--   not set <a>AI_PASSIVE</a> 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
--   <a>AddrInfo</a> 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
--   <tt>getaddrinfo</tt> in RFC 2553. The <a>AddrInfo</a> parameter comes
--   first to make partial application easier.
--   
--   Example: <tt> let hints = defaultHints { addrFlags = [AI_ADDRCONFIG,
--   AI_CANONNAME] } addrs &lt;- getAddrInfo (Just hints) (Just
--   <a>www.haskell.org</a>) (Just <a>http</a>) let addr = head addrs sock
--   &lt;- socket (addrFamily addr) (addrSocketType addr) (addrProtocol
--   addr) connect sock (addrAddress addr) </tt>
getAddrInfo :: Maybe AddrInfo -> Maybe HostName -> Maybe ServiceName -> IO [AddrInfo]
data NameInfoFlag
NI_DGRAM :: NameInfoFlag
NI_NAMEREQD :: NameInfoFlag
NI_NOFQDN :: NameInfoFlag
NI_NUMERICHOST :: NameInfoFlag
NI_NUMERICSERV :: NameInfoFlag

-- | Resolve an address to a host or service name. This function is
--   protocol independent.
--   
--   The list of <a>NameInfoFlag</a> values controls query behaviour. The
--   supported flags are as follows:
--   
--   <ul>
--   <li><i><tt>NI_NOFQDN</tt></i> If a host is local, return only the
--   hostname part of the FQDN.</li>
--   <li><i><tt>NI_NUMERICHOST</tt></i> 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.</li>
--   <li><i><tt>NI_NUMERICSERV</tt></i> The name of the service is not
--   looked up. Instead, a numeric representation of the service is
--   returned.</li>
--   <li><i><tt>NI_NAMEREQD</tt></i> If the hostname cannot be looked up,
--   an IO error is thrown.</li>
--   <li><i><tt>NI_DGRAM</tt></i> 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.</li>
--   </ul>
--   
--   Hostname and service name lookups can be expensive. You can specify
--   which lookups to perform via the two <a>Bool</a> arguments. If one of
--   these is <a>False</a>, the corresponding value in the returned tuple
--   will be <a>Nothing</a>, and no lookup will be performed.
--   
--   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.
--   
--   Example: <tt> (hostName, _) &lt;- getNameInfo [] True False myAddress
--   </tt>
getNameInfo :: [NameInfoFlag] -> Bool -> Bool -> SockAddr -> IO (Maybe HostName, Maybe ServiceName)

-- | Create a new socket using the given address family, socket type and
--   protocol number. The address family is usually <a>AF_INET</a>,
--   <a>AF_INET6</a>, or <a>AF_UNIX</a>. The socket type is usually
--   <a>Stream</a> or <a>Datagram</a>. The protocol number is usually
--   <a>defaultProtocol</a>. If <a>AF_INET6</a> is used, the
--   <a>IPv6Only</a> socket option is set to 0 so that both IPv4 and IPv6
--   can be handled with one socket.
socket :: Family -> SocketType -> ProtocolNumber -> IO Socket

-- | Build a pair of connected socket objects using the given address
--   family, socket type, and protocol number. Address family, socket type,
--   and protocol number are as for the <a>socket</a> function above.
--   Availability: Unix.
socketPair :: Family -> SocketType -> ProtocolNumber -> IO (Socket, Socket)

-- | Connect to a remote socket at address.
connect :: Socket -> SockAddr -> IO ()

-- | Bind the socket to an address. The socket must not already be bound.
--   The <a>Family</a> passed to <tt>bindSocket</tt> must be the same as
--   that passed to <a>socket</a>. If the special port number
--   <a>aNY_PORT</a> is passed then the system assigns the next available
--   use port.
bindSocket :: Socket -> SockAddr -> IO ()

-- | 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 ()

-- | Accept a connection. The socket must be bound to an address and
--   listening for connections. The return value is a pair <tt>(conn,
--   address)</tt> where <tt>conn</tt> is a new socket object usable to
--   send and receive data on the connection, and <tt>address</tt> is the
--   address bound to the socket on the other end of the connection.
accept :: Socket -> IO (Socket, SockAddr)
getPeerName :: Socket -> IO SockAddr
getSocketName :: Socket -> IO SockAddr

-- | Returns the processID, userID and groupID of the socket's peer.
--   
--   Only available on platforms that support SO_PEERCRED on domain
--   sockets.
getPeerCred :: Socket -> IO (CUInt, CUInt, CUInt)
socketPort :: Socket -> IO PortNumber

-- | Turns a Socket into an <a>Handle</a>. By default, the new handle is
--   unbuffered. Use <a>hSetBuffering</a> to change the buffering.
--   
--   Note that since a <a>Handle</a> is automatically closed by a finalizer
--   when it is no longer referenced, you should avoid doing any more
--   operations on the <a>Socket</a> after calling <a>socketToHandle</a>.
--   To close the <a>Socket</a> after <a>socketToHandle</a>, call
--   <a>hClose</a> on the <a>Handle</a>.
socketToHandle :: Socket -> IOMode -> IO Handle

-- | 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.
--   
--   NOTE: blocking on Windows unless you compile with -threaded (see GHC
--   ticket #1129)
sendTo :: Socket -> String -> SockAddr -> IO Int

-- | 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

-- | Receive data from the socket. The socket need not be in a connected
--   state. Returns <tt>(bytes, nbytes, address)</tt> where <tt>bytes</tt>
--   is a <tt>String</tt> of length <tt>nbytes</tt> representing the data
--   received and <tt>address</tt> is a <a>SockAddr</a> representing the
--   address of the sending socket.
--   
--   NOTE: blocking on Windows unless you compile with -threaded (see GHC
--   ticket #1129)
recvFrom :: Socket -> Int -> IO (String, Int, SockAddr)

-- | 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 <tt>(nbytes, address)</tt> where <tt>nbytes</tt> is the number
--   of bytes received and <tt>address</tt> is a <a>SockAddr</a>
--   representing the address of the sending socket.
--   
--   NOTE: blocking on Windows unless you compile with -threaded (see GHC
--   ticket #1129)
recvBufFrom :: Socket -> Ptr a -> Int -> IO (Int, SockAddr)

-- | 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 -> String -> IO Int

-- | 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.
recv :: Socket -> Int -> IO String
recvLen :: Socket -> Int -> IO (String, Int)
inet_addr :: String -> IO HostAddress
inet_ntoa :: HostAddress -> IO String

-- | Shut down one or both halves of the connection, depending on the
--   second argument to the function. If the second argument is
--   <a>ShutdownReceive</a>, further receives are disallowed. If it is
--   <a>ShutdownSend</a>, further sends are disallowed. If it is
--   <a>ShutdownBoth</a>, further sends and receives are disallowed.
shutdown :: Socket -> ShutdownCmd -> IO ()

-- | Close the socket. All future operations on the socket object will
--   fail. The remote end will receive no more data (after queued data is
--   flushed).
sClose :: Socket -> IO ()
sIsConnected :: Socket -> IO Bool
sIsBound :: Socket -> IO Bool
sIsListening :: Socket -> IO Bool
sIsReadable :: Socket -> IO Bool
sIsWritable :: Socket -> IO Bool
data SocketOption
DummySocketOption__ :: SocketOption
Debug :: SocketOption
ReuseAddr :: SocketOption
Type :: SocketOption
SoError :: SocketOption
DontRoute :: SocketOption
Broadcast :: SocketOption
SendBuffer :: SocketOption
RecvBuffer :: SocketOption
KeepAlive :: SocketOption
OOBInline :: SocketOption
TimeToLive :: SocketOption
MaxSegment :: SocketOption
NoDelay :: SocketOption
Linger :: SocketOption
RecvLowWater :: SocketOption
SendLowWater :: SocketOption
RecvTimeOut :: SocketOption
SendTimeOut :: SocketOption
IPv6Only :: SocketOption
getSocketOption :: Socket -> SocketOption -> IO Int
setSocketOption :: Socket -> SocketOption -> Int -> IO ()
sendFd :: Socket -> CInt -> IO ()
recvFd :: Socket -> IO CInt
sendAncillary :: Socket -> Int -> Int -> Int -> Ptr a -> Int -> IO ()
recvAncillary :: Socket -> Int -> Int -> IO (Int, Int, Ptr a, Int)
aNY_PORT :: PortNumber

-- | The IPv4 wild card address.
iNADDR_ANY :: HostAddress

-- | The IPv6 wild card address.
iN6ADDR_ANY :: HostAddress6
sOMAXCONN :: Int
sOL_SOCKET :: Int
sCM_RIGHTS :: Int
maxListenQueue :: Int

-- | On Windows operating systems, the networking subsystem has to be
--   initialised using <a>withSocketsDo</a> before any networking
--   operations can be used. eg.
--   
--   <pre>
--   main = withSocketsDo $ do {...}
--   </pre>
--   
--   Although this is only strictly necessary on Windows platforms, it is
--   harmless on other platforms, so for portability it is good practice to
--   use it all the time.
withSocketsDo :: IO a -> IO a
fdSocket :: Socket -> CInt
mkSocket :: CInt -> Family -> SocketType -> ProtocolNumber -> SocketStatus -> IO Socket
packFamily :: Family -> CInt
unpackFamily :: CInt -> Family
packSocketType :: SocketType -> CInt

-- | Throw an <a>IOError</a> corresponding to the current socket error if
--   the IO action returns a result of <tt>-1</tt>. Discards the result of
--   the IO action after error handling.
throwSocketErrorIfMinus1_ :: (Eq a, Num a) => String -> IO a -> IO ()
instance Typeable SocketStatus
instance Typeable SocketOption
instance Typeable SocketType
instance Typeable Socket
instance Typeable ShutdownCmd
instance Typeable AddrInfoFlag
instance Typeable AddrInfo
instance Typeable NameInfoFlag
instance Eq SocketStatus
instance Show SocketStatus
instance Eq SocketType
instance Ord SocketType
instance Read SocketType
instance Show SocketType
instance Eq AddrInfoFlag
instance Read AddrInfoFlag
instance Show AddrInfoFlag
instance Eq AddrInfo
instance Show AddrInfo
instance Eq NameInfoFlag
instance Read NameInfoFlag
instance Show NameInfoFlag
instance Storable AddrInfo
instance Show SockAddr
instance Storable PortNumber
instance Integral PortNumber
instance Real PortNumber
instance Num PortNumber
instance Enum PortNumber
instance Show PortNumber
instance Show Socket
instance Eq Socket


-- | This module provides access to the BSD <i>socket</i> interface. This
--   module is generally more efficient than the <a>String</a> based
--   network functions in <a>Socket</a>. For detailed documentation,
--   consult your favorite POSIX socket reference. All functions
--   communicate failures by converting the error number to <a>IOError</a>.
--   
--   This module is made to be imported with <a>Socket</a> like so:
--   
--   <pre>
--   import Network.Socket hiding (send, sendTo, recv, recvFrom)
--   import Network.Socket.ByteString
--   </pre>
module Network.Socket.ByteString

-- | 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 -> ByteString -> IO Int

-- | Send data to the socket. The socket must be connected to a remote
--   socket. Unlike <a>send</a>, 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 -> ByteString -> IO ()

-- | 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

-- | Send data to the socket. The recipient can be specified explicitly, so
--   the socket need not be in a connected state. Unlike <a>sendTo</a>,
--   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 ()

-- | 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 -> [ByteString] -> IO ()

-- | 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 -> [ByteString] -> SockAddr -> IO ()

-- | 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.
recv :: Socket -> Int -> IO ByteString

-- | Receive data from the socket. The socket need not be in a connected
--   state. Returns <tt>(bytes, address)</tt> where <tt>bytes</tt> is a
--   <a>ByteString</a> representing the data received and <tt>address</tt>
--   is a <a>SockAddr</a> representing the address of the sending socket.
recvFrom :: Socket -> Int -> IO (ByteString, SockAddr)


-- | This module provides access to the BSD <i>socket</i> interface. This
--   module is generally more efficient than the <a>String</a> based
--   network functions in <a>Socket</a>. For detailed documentation,
--   consult your favorite POSIX socket reference. All functions
--   communicate failures by converting the error number to <a>IOError</a>.
--   
--   This module is made to be imported with <a>Socket</a> like so:
--   
--   <pre>
--   import Network.Socket hiding (send, sendTo, recv, recvFrom)
--   import Network.Socket.ByteString.Lazy
--   import Prelude hiding (getContents)
--   </pre>
module Network.Socket.ByteString.Lazy

-- | Send data to the socket. The socket must be in a connected state.
--   Returns the number of bytes sent. Applications are responsible for
--   ensuring that all data has been sent.
--   
--   Because a lazily generated <a>ByteString</a> may be arbitrarily long,
--   this function caps the amount it will attempt to send at 4MB. This
--   number is large (so it should not penalize performance on fast
--   networks), but not outrageously so (to avoid demanding lazily computed
--   data unnecessarily early). Before being sent, the lazy
--   <a>ByteString</a> will be converted to a list of strict
--   <a>ByteString</a>s with <a>toChunks</a>; at most 1024 chunks will be
--   sent. <i>Unix only</i>.
send :: Socket -> ByteString -> IO Int64

-- | Send data to the socket. The socket must be in a connected state. This
--   function continues to send data until either all data has been sent or
--   an error occurs. If there is an error, an exception is raised, and
--   there is no way to determine how much data was sent. <i>Unix only</i>.
sendAll :: Socket -> ByteString -> IO ()

-- | 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 <a>recv</a> 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 -> IO ByteString

-- | 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
--   <a>ByteString</a>.
recv :: Socket -> Int64 -> IO ByteString


-- | The <a>Network.BSD</a> module defines Haskell bindings to network
--   programming functionality provided by BSD Unix derivatives.
module Network.BSD

-- | Either a host name e.g., <tt>"haskell.org"</tt> or a numeric host
--   address string consisting of a dotted decimal IPv4 address or an IPv6
--   address e.g., <tt>"192.168.0.1"</tt>.
type HostName = String

-- | Calling getHostName returns the standard host name for the current
--   processor, as set at boot time.
getHostName :: IO HostName
data HostEntry
HostEntry :: HostName -> [HostName] -> Family -> [HostAddress] -> HostEntry
hostName :: HostEntry -> HostName
hostAliases :: HostEntry -> [HostName]
hostFamily :: HostEntry -> Family
hostAddresses :: HostEntry -> [HostAddress]

-- | Resolve a <a>HostName</a> to IPv4 address.
getHostByName :: HostName -> IO HostEntry

-- | Get a <a>HostEntry</a> corresponding to the given address and family.
--   Note that only IPv4 is currently supported.
getHostByAddr :: Family -> HostAddress -> IO HostEntry
hostAddress :: HostEntry -> HostAddress
getHostEntries :: Bool -> IO [HostEntry]
setHostEntry :: Bool -> IO ()
getHostEntry :: IO HostEntry
endHostEntry :: IO ()
data ServiceEntry
ServiceEntry :: ServiceName -> [ServiceName] -> PortNumber -> ProtocolName -> ServiceEntry
serviceName :: ServiceEntry -> ServiceName
serviceAliases :: ServiceEntry -> [ServiceName]
servicePort :: ServiceEntry -> PortNumber
serviceProtocol :: ServiceEntry -> ProtocolName
type ServiceName = String

-- | Get service by name.
getServiceByName :: ServiceName -> ProtocolName -> IO ServiceEntry

-- | Get the service given a <a>PortNumber</a> and <a>ProtocolName</a>.
getServiceByPort :: PortNumber -> ProtocolName -> IO ServiceEntry

-- | Get the <a>PortNumber</a> corresponding to the <a>ServiceName</a>.
getServicePortNumber :: ServiceName -> IO PortNumber
getServiceEntries :: Bool -> IO [ServiceEntry]
getServiceEntry :: IO ServiceEntry
setServiceEntry :: Bool -> IO ()
endServiceEntry :: IO ()
type ProtocolName = String
type ProtocolNumber = CInt
data ProtocolEntry
ProtocolEntry :: ProtocolName -> [ProtocolName] -> ProtocolNumber -> ProtocolEntry
protoName :: ProtocolEntry -> ProtocolName
protoAliases :: ProtocolEntry -> [ProtocolName]
protoNumber :: ProtocolEntry -> ProtocolNumber
getProtocolByName :: ProtocolName -> IO ProtocolEntry
getProtocolByNumber :: ProtocolNumber -> IO ProtocolEntry
getProtocolNumber :: ProtocolName -> IO ProtocolNumber

-- | This is the default protocol for a given service.
defaultProtocol :: ProtocolNumber
getProtocolEntries :: Bool -> IO [ProtocolEntry]
setProtocolEntry :: Bool -> IO ()
getProtocolEntry :: IO ProtocolEntry
endProtocolEntry :: IO ()
data PortNumber
type NetworkName = String
type NetworkAddr = CULong
data NetworkEntry
NetworkEntry :: NetworkName -> [NetworkName] -> Family -> NetworkAddr -> NetworkEntry
networkName :: NetworkEntry -> NetworkName
networkAliases :: NetworkEntry -> [NetworkName]
networkFamily :: NetworkEntry -> Family
networkAddress :: NetworkEntry -> NetworkAddr
getNetworkByName :: NetworkName -> IO NetworkEntry
getNetworkByAddr :: NetworkAddr -> Family -> IO NetworkEntry

-- | Get the list of network entries.
getNetworkEntries :: Bool -> IO [NetworkEntry]

-- | Open the network name database. The parameter specifies whether a
--   connection is maintained open between various networkEntry calls
setNetworkEntry :: Bool -> IO ()
getNetworkEntry :: IO NetworkEntry

-- | Close the connection to the network name database.
endNetworkEntry :: IO ()
instance Typeable ServiceEntry
instance Typeable ProtocolEntry
instance Typeable HostEntry
instance Typeable NetworkEntry
instance Show ServiceEntry
instance Read ProtocolEntry
instance Show ProtocolEntry
instance Read HostEntry
instance Show HostEntry
instance Read NetworkEntry
instance Show NetworkEntry
instance Storable NetworkEntry
instance Storable HostEntry
instance Storable ProtocolEntry
instance Storable ServiceEntry


-- | The <a>Network</a> interface is a "higher-level" interface to
--   networking facilities, and it is recommended unless you need the
--   lower-level interface in <a>Network.Socket</a>.
module Network
data Socket
data PortID
Service :: String -> PortID
PortNumber :: PortNumber -> PortID
UnixSocket :: String -> PortID

-- | Either a host name e.g., <tt>"haskell.org"</tt> or a numeric host
--   address string consisting of a dotted decimal IPv4 address or an IPv6
--   address e.g., <tt>"192.168.0.1"</tt>.
type HostName = String
data PortNumber

-- | On Windows operating systems, the networking subsystem has to be
--   initialised using <a>withSocketsDo</a> before any networking
--   operations can be used. eg.
--   
--   <pre>
--   main = withSocketsDo $ do {...}
--   </pre>
--   
--   Although this is only strictly necessary on Windows platforms, it is
--   harmless on other platforms, so for portability it is good practice to
--   use it all the time.
withSocketsDo :: IO a -> IO a

-- | Creates the server side socket which has been bound to the specified
--   port.
--   
--   NOTE: To avoid the "Address already in use" problems popped up several
--   times on the GHC-Users mailing list we set the <a>ReuseAddr</a> socket
--   option on the listening socket. If you don't want this behaviour,
--   please use the lower level <a>listen</a> instead.
--   
--   If available, the <a>IPv6Only</a> socket option is set to 0 so that
--   both IPv4 and IPv6 can be accepted with this socket.
listenOn :: PortID -> IO Socket

-- | Accept a connection on a socket created by <a>listenOn</a>. Normal I/O
--   operations (see <a>System.IO</a>) can be used on the <a>Handle</a>
--   returned to communicate with the client. Notice that although you can
--   pass any Socket to Network.accept, only sockets of either AF_UNIX,
--   AF_INET, or AF_INET6 will work (this shouldn't be a problem, though).
--   When using AF_UNIX, HostName will be set to the path of the socket and
--   PortNumber to -1.
accept :: Socket -> IO (Handle, HostName, PortNumber)

-- | Close the socket. All future operations on the socket object will
--   fail. The remote end will receive no more data (after queued data is
--   flushed).
sClose :: Socket -> IO ()

-- | Calling <a>connectTo</a> creates a client side socket which is
--   connected to the given host and port. The Protocol and socket type is
--   derived from the given port identifier. If a port number is given then
--   the result is always an internet family <a>Stream</a> socket.
connectTo :: HostName -> PortID -> IO Handle
sendTo :: HostName -> PortID -> String -> IO ()
recvFrom :: HostName -> PortID -> IO String

-- | Returns the <a>PortID</a> associated with a given socket.
socketPort :: Socket -> IO PortID