Ticket #1212: ipv6.2.patch

New patches:

[Add IPv6 support.
Bryan O'Sullivan <bos@serpentine.com>**20070331183923
 
 The only public API changes are to Network.Socket, which has the following
 exported names added (no existing names have been removed):
 
     -- IPv6 address components
     HostAddress6
     FlowInfo
     ScopeID
 
     -- Name -> address lookup
     getAddrInfo
     AddrInfo
     AddrInfoFlags
     aI_PASSIVE
     aI_CANONNAME
     aI_NUMERICHOST
     aI_ADDRCONFIG
     defaultHints
 
     -- Address -> name lookup
     getNameInfo
     NameInfoFlags
     nI_NOFQDN
     nI_NUMERICHOST
     nI_NAMEREQD
     nI_NUMERICSERV
     nI_DGRAM
 
 The SockAddr type acquires a new branch, SockAddr6.  (This could cause
 new "non-exhaustive matches" warnings when compiling pre-existing client
 code that pattern-matches on SockAddr values.  However, it will not
 cause runtime pattern failure errors in clients using the pre-existing
 IPv4 entry points, as they will never see IPv6 addresses.)
 
 This change moves a few type names from Network.BSD to Network.Socket:
 
     HostName
     ServiceName
 
 These names are still re-exported from Network.BSD, so pre-existing code
 should not be affected.
] {
hunk ./Network/BSD.hsc 117
-type HostName     = String
hunk ./Network/BSD.hsc 118
-type ServiceName  = String
hunk ./Network/BSD.hsc 299
--- | This is the default protocol for the given service.
-defaultProtocol :: ProtocolNumber
-defaultProtocol = 0
-
hunk ./Network/Socket.hsc 54
+#if defined(IPV6_SOCKET_SUPPORT)
+    HostAddress6,
+    FlowInfo,
+    ScopeID,
+#endif
hunk ./Network/Socket.hsc 65
+    -- * Address operations
+
+#if defined(IPV6_SOCKET_SUPPORT)
+    AddrInfo(..),
+
+    AddrInfoFlags,
+    aI_PASSIVE,
+    aI_CANONNAME,
+    aI_NUMERICHOST,
+    aI_ADDRCONFIG,
+
+    HostName,
+    ServiceName,
+
+    defaultHints,           -- :: AddrInfo
+    defaultProtocol,        -- :: ProtocolNumber
+
+    getAddrInfo,            -- :: Maybe AddrInfo -> Maybe HostName -> Maybe ServiceName -> IO [AddrInfo]
+
+    NameInfoFlags,
+    nI_NOFQDN,
+    nI_NUMERICHOST,
+    nI_NAMEREQD,
+    nI_NUMERICSERV,
+    nI_DGRAM,
+
+    getNameInfo,            -- :: NameInfoFlags -> Bool -> Bool -> SockAddr -> IO (Maybe HostName, Maybe ServiceName)
+#endif
+
hunk ./Network/Socket.hsc 157
+#if defined(IPV6_SOCKET_SUPPORT)
+    iN6ADDR_ANY,       -- :: HostAddress6
+#endif
hunk ./Network/Socket.hsc 204
-import Foreign.Ptr ( Ptr, castPtr, plusPtr )
+import Foreign.Ptr ( Ptr, castPtr, nullPtr, plusPtr )
hunk ./Network/Socket.hsc 207
-import Foreign.C.String ( withCString, peekCString, peekCStringLen, castCharToCChar )
+import Foreign.C.String ( CString, withCString, peekCString, peekCStringLen, castCharToCChar )
hunk ./Network/Socket.hsc 211
-import Foreign.Marshal.Utils ( with )
+import Foreign.Marshal.Utils ( maybeWith, with )
hunk ./Network/Socket.hsc 234
+type HostName       = String
+type ServiceName    = String
+
hunk ./Network/Socket.hsc 298
+-- | This is the default protocol for a given service.
+defaultProtocol :: ProtocolNumber
+defaultProtocol = 0
+
hunk ./Network/Socket.hsc 307
+#if defined(IPV6_SOCKET_SUPPORT)
+type HostAddress6 = (Word32, Word32, Word32, Word32)
+#endif
+
hunk ./Network/Socket.hsc 381
--- families. Currently only Unix domain sockets and the Internet family
--- are supported.
+-- families. Currently only Unix domain sockets and the Internet
+-- families are supported.
+
+#if defined(IPV6_SOCKET_SUPPORT)
+type FlowInfo = Word32
+type ScopeID = Word32
+#endif
hunk ./Network/Socket.hsc 393
+#if defined(IPV6_SOCKET_SUPPORT)
+  | SockAddrInet6
+        PortNumber      -- sin6_port (network byte order)
+        FlowInfo        -- sin6_flowinfo (ditto)
+        HostAddress6    -- sin6_addr (ditto)
+        ScopeID         -- sin6_scope_id (ditto)
+#endif
hunk ./Network/Socket.hsc 424
+#if defined(IPV6_SOCKET_SUPPORT)
+  showsPrec _ addr@(SockAddrInet6 port _ _ _)
+   = showChar '['
+   . showString (unsafePerformIO $
+                 fst `liftM` getNameInfo nI_NUMERICHOST True False addr >>=
+                 maybe (fail "showsPrec: impossible internal error") return)
+   . showString "]:"
+   . shows port
+
+instance Storable HostAddress6 where
+    sizeOf _    = (#const sizeof(struct in6_addr))
+    alignment _ = alignment (undefined :: CInt)
+
+    peek p = do
+        a <- (#peek struct in6_addr, s6_addr32[0]) p
+        b <- (#peek struct in6_addr, s6_addr32[1]) p
+        c <- (#peek struct in6_addr, s6_addr32[2]) p
+        d <- (#peek struct in6_addr, s6_addr32[3]) p
+        return (a, b, c, d)
+
+    poke p (a, b, c, d) = do
+        (#poke struct in6_addr, s6_addr32[0]) p a
+        (#poke struct in6_addr, s6_addr32[1]) p b
+        (#poke struct in6_addr, s6_addr32[2]) p c
+        (#poke struct in6_addr, s6_addr32[3]) p d
+#endif
hunk ./Network/Socket.hsc 471
+#if defined(IPV6_SOCKET_SUPPORT)
+pokeSockAddr p (SockAddrInet6 (PortNum port) flow addr scope) = do
+#if defined(darwin_TARGET_OS)
+       zeroMemory p (#const sizeof(struct sockaddr_in6))
+#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 addr   
+       (#poke struct sockaddr_in6, sin6_scope_id) p scope
+#endif
+
+peekSockAddr :: Ptr SockAddr -> IO SockAddr
hunk ./Network/Socket.hsc 497
+#if defined(IPV6_SOCKET_SUPPORT)
+       (#const AF_INET6) -> do
+               port <- (#peek struct sockaddr_in6, sin6_port) p
+               flow <- (#peek struct sockaddr_in6, sin6_flowinfo) p
+               addr <- (#peek struct sockaddr_in6, sin6_addr) p
+               scope <- (#peek struct sockaddr_in6, sin6_scope_id) p
+               return (SockAddrInet6 (PortNum port) flow addr scope)
+#endif
hunk ./Network/Socket.hsc 522
+#if defined(IPV6_SOCKET_SUPPORT)
+sizeOfSockAddr (SockAddrInet6 _ _ _ _) = #const sizeof(struct sockaddr_in6)
+#endif
hunk ./Network/Socket.hsc 908
+#if defined(IPV6_SOCKET_SUPPORT)
+socketPort sock@(MkSocket _ AF_INET6 _ _ _) = do
+    (SockAddrInet6 port _ _ _) <- getSocketName sock
+    return port
+#endif
hunk ./Network/Socket.hsc 1250
+unpackSocketType:: CInt -> SocketType
hunk ./Network/Socket.hsc 1893
+unpackSocketType t = case t of
+       0 -> NoSocketType
+#ifdef SOCK_STREAM
+       (#const SOCK_STREAM) -> Stream
+#endif
+#ifdef SOCK_DGRAM
+       (#const SOCK_DGRAM) -> Datagram
+#endif
+#ifdef SOCK_RAW
+       (#const SOCK_RAW) -> Raw
+#endif
+#ifdef SOCK_RDM
+       (#const SOCK_RDM) -> RDM
+#endif
+#ifdef SOCK_SEQPACKET
+       (#const SOCK_SEQPACKET) -> SeqPacket
+#endif
+
hunk ./Network/Socket.hsc 1920
+#if defined(IPV6_SOCKET_SUPPORT)
+iN6ADDR_ANY :: HostAddress6
+iN6ADDR_ANY = (0, 0, 0, 0)
+#endif
+
hunk ./Network/Socket.hsc 2050
+
+
+-----------------------------------------------------------------------------
+-- Address and service lookups
+
+#if defined(IPV6_SOCKET_SUPPORT)
+
+-- | Flags that control the querying behaviour of 'getAddrInfo'.
+type AddrInfoFlags = CInt
+
+-- Portable flags.
+
+aI_PASSIVE :: AddrInfoFlags
+aI_PASSIVE                  = (#const AI_PASSIVE)
+aI_CANONNAME :: AddrInfoFlags
+aI_CANONNAME                = (#const AI_CANONNAME)
+aI_NUMERICHOST :: AddrInfoFlags
+aI_NUMERICHOST              = (#const AI_NUMERICHOST)
+aI_ADDRCONFIG :: AddrInfoFlags
+aI_ADDRCONFIG               = (#const AI_ADDRCONFIG)
+
+data AddrInfo =
+    AddrInfo {
+        addrFlags :: AddrInfoFlags,
+        addrFamily :: Family,
+        addrSocketType :: SocketType,
+        addrProtocol :: ProtocolNumber,
+        addrAddress :: SockAddr,
+        addrCanonName :: Maybe String
+        }
+    deriving (Show)
+
+INSTANCE_TYPEABLE0(AddrInfo,addrInfoTc,"AddrInfo")
+
+instance Storable AddrInfo where
+    sizeOf    _ = #const sizeof(struct addrinfo)
+    alignment _ = alignment (undefined :: 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 liftM Just $ peekCString ai_canonname_ptr
+                             
+        return (AddrInfo
+                {
+                 addrFlags = ai_flags,
+                 addrFamily = unpackFamily ai_family,
+                 addrSocketType = unpackSocketType ai_socktype,
+                 addrProtocol = ai_protocol,
+                 addrAddress = ai_addr,
+                 addrCanonName = ai_canonname
+                })
+
+    poke p (AddrInfo flags family socketType protocol _ _) = do
+        (#poke struct addrinfo, ai_flags) p flags
+        (#poke struct addrinfo, ai_family) p (packFamily family)
+        (#poke struct addrinfo, ai_socktype) p (packSocketType socketType)
+        (#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
+
+type NameInfoFlags = CInt
+
+nI_NOFQDN :: NameInfoFlags
+nI_NOFQDN = (#const NI_NOFQDN)
+nI_NUMERICHOST :: NameInfoFlags
+nI_NUMERICHOST = (#const NI_NUMERICHOST)
+nI_NAMEREQD :: NameInfoFlags
+nI_NAMEREQD = (#const NI_NAMEREQD)
+nI_NUMERICSERV :: NameInfoFlags
+nI_NUMERICSERV = (#const NI_NUMERICSERV)
+nI_DGRAM :: NameInfoFlags
+nI_DGRAM = (#const NI_DGRAM)
+
+-- | Default hints for address lookup with 'getAddrInfo'.  The values
+-- of the 'addrAddress' and 'addrCanonName' fields are 'undefined',
+-- and are never inspected by 'getAddrInfo'.
+
+defaultHints :: AddrInfo
+
+defaultHints = AddrInfo {
+                         addrFlags = 0,
+                         addrFamily = AF_UNSPEC,
+                         addrSocketType = NoSocketType,
+                         addrProtocol = defaultProtocol,
+                         addrAddress = undefined,
+                         addrCanonName = undefined
+                        }
+
+-- | Resolve a host or service name query to one or more addresses.
+-- The 'AddrInfo' values that this function returns contain 'SockAddr'
+-- values that you can pass directly to 'connect' or
+-- 'bindSocket'.
+--
+-- 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:
+--
+-- @
+--   myHints = defaultHints { addrFlags = aI_ADDRCONFIG + aI_CANONNAME }
+-- @
+--
+-- Values for 'addrFlags' can be /or/ed together, and control query
+-- behaviour.  The portable values are as follows:
+--
+--   [@aI_PASSIVE@] If no 'HostName' value is provided, the network
+--     address in each 'SockAddr'
+--     will be left as a "wild card", i.e. as either 'iNADDR_ANY'
+--     or 'iN6ADDR_ANY'.  This is useful for server applications that
+--     will accept connections from any client.
+--
+--   [@aI_CANONNAME@] The 'addrCanonName' field of the first returned
+--     'AddrInfo' will contain the "canonical name" of the host.
+--
+--   [@aI_NUMERICHOST@] The 'HostName' argument /must/ be a numeric
+--     address in string form, and network name lookups will not be
+--      attempted.
+--
+--   [@aI_ADDRCONFIG@] 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.
+--
+-- A number of non-portable values for 'addrFlags' may also be
+-- available, depending on your platform.
+--
+-- You must provide a real value for at least one of the 'HostName' or
+-- 'ServiceName' arguments.  'HostName' can be either a numeric
+-- network address (dotted quad for IPv4, 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.
+--
+-- Example:
+-- @
+--   let hints = defaultHints { addrFlags = aI_ADDRCONFIG + aI_CANONNAME }
+--   addrs <- getAddrInfo (Just hints) (Just "www.haskell.org") (Just "http")
+--   let addr = head addrs
+--   sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
+--   connect sock (addrAddress addr)
+-- @
+
+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 =
+  maybeWith withCString node $ \c_node ->
+    maybeWith withCString service $ \c_service ->
+      maybeWith with hints $ \c_hints ->
+        alloca $ \ptr_ptr_addrs -> do
+          ret <- c_getaddrinfo c_node c_service c_hints ptr_ptr_addrs
+          case ret of
+            0 -> do ptr_addrs <- peek ptr_ptr_addrs
+                    ais <- followAddrInfo ptr_addrs
+                    c_freeaddrinfo ptr_addrs
+                    return ais
+            _ -> do err <- gai_strerror ret
+                    ioError (IOError Nothing NoSuchThing "getAddrInfo" err
+                             Nothing)
+
+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 "getaddrinfo"
+    c_getaddrinfo :: CString -> CString -> Ptr AddrInfo -> Ptr (Ptr AddrInfo)
+                  -> IO CInt
+
+foreign import ccall safe "freeaddrinfo"
+    c_freeaddrinfo :: Ptr AddrInfo -> IO ()
+
+gai_strerror :: CInt -> IO String
+
+gai_strerror n = c_gai_strerror n >>= peekCString
+
+foreign import ccall safe "gai_strerror"
+    c_gai_strerror :: CInt -> IO CString
+
+withCStringIf :: Bool -> Int -> (CSize -> CString -> IO a) -> IO a
+withCStringIf False _ f = f 0 nullPtr
+withCStringIf True n f = allocaBytes n (f (fromIntegral n))
+                    
+getNameInfo :: NameInfoFlags
+            -> Bool
+            -> Bool
+            -> SockAddr
+            -> IO (Maybe HostName, Maybe ServiceName)
+
+getNameInfo flags doHost doService addr =
+  withCStringIf doHost (#const NI_MAXHOST) $ \c_hostlen c_host ->
+    withCStringIf doService (#const NI_MAXSERV) $ \c_servlen c_serv -> do
+      withSockAddr addr $ \ptr_addr sz -> do
+        ret <- c_getnameinfo ptr_addr (fromIntegral sz) c_host c_hostlen
+                             c_serv c_servlen flags
+        case ret of
+          0 -> do
+            let peekIf doIf c_val = if doIf
+                                     then liftM Just $ peekCString c_val
+                                     else return Nothing
+            host <- peekIf doHost c_host
+            serv <- peekIf doService c_serv
+            return (host, serv)
+          _ -> do err <- gai_strerror ret
+                  ioError (IOError Nothing NoSuchThing "getNameInfo" err
+                           Nothing)
+
+foreign import ccall safe "getnameinfo"
+    c_getnameinfo :: Ptr SockAddr -> CInt{-CSockLen???-} -> CString -> CSize -> CString
+                  -> CSize -> NameInfoFlags -> IO CInt
+#endif
hunk ./configure.ac 37
+dnl --------------------------------------------------
+dnl * test for in6_addr as proxy for IPv6 support
+dnl --------------------------------------------------
+AC_MSG_CHECKING(for in6_addr in netinet/in.h)
+AC_EGREP_HEADER(in6_addr, netinet/in.h,
+ [ AC_DEFINE([HAVE_IN6_ADDR], [1], [Define to 1 if in6_addr is available.]) AC_MSG_RESULT(yes) ],
+ AC_MSG_RESULT(no))
+
hunk ./include/HsNet.h 28
+
+#ifdef HAVE_IN6_ADDR
+# define IPV6_SOCKET_SUPPORT 1
+#else
+# undef IPV6_SOCKET_SUPPORT
+#endif
hunk ./network.cabal 2
-version:       2.0
+version:       2.0.1
}

Context:

[apply changes from patch "make this test deterministic on a multiprocessor" in testsuite
Simon Marlow <simonmar@microsoft.com>**20070221142822] 
[tests for use with GHC's test framework, moved from the testsuite
Simon Marlow <simonmar@microsoft.com>**20070221142258] 
[README about building from darcs
Ross Paterson <ross@soi.city.ac.uk>**20070218110201] 
[don't install Typeable.h, fixes #1106
Simon Marlow <simonmar@microsoft.com>**20070201125821] 
[network doesn't really need the html package
Ian Lynagh <igloo@earth.li>**20070111122348] 
[includes -> install-includes
Ross Paterson <ross@soi.city.ac.uk>**20060829123744] 
[change title to Haskell Hierarchical Libraries
Ross Paterson <ross@soi.city.ac.uk>**20060827131348] 
[exclude Setup.hs from build
Ross Paterson <ross@soi.city.ac.uk>**20060824183533] 
[add boilerplate Setup.hs
Ross Paterson <ross@soi.city.ac.uk>**20060824115019] 
[Update Network.BSD header to not mention symlinks.
Ian Lynagh <igloo@earth.li>**20060823184314] 
[Removed Network.CGI from the network package. A backwards-compatible new Network.CGI is available in the cgi package.
bringert@cs.chalmers.se**20060814095652] 
[remove deprecated Network.BSD.{readlink,symlink}
Simon Marlow <simonmar@microsoft.com>**20060811153755] 
[bump version to 2.0
Simon Marlow <simonmar@microsoft.com>**20060811152554] 
[depend on html (for the time being)
Simon Marlow <simonmar@microsoft.com>**20060810121424] 
[initWinSock(): have defn match proto
sof@galois.com**20060613224903] 
[only GHC has rtsSupportsBoundThreads
Ross Paterson <ross@soi.city.ac.uk>**20060531200123] 
[add files used by configure
Ross Paterson <ross@soi.city.ac.uk>**20060518174356] 
[Import unsafePerformIO
Sven Panne <sven.panne@aedion.de>**20060507171832] 
[Import MVar type
Sven Panne <sven.panne@aedion.de>**20060507170308] 
[Add various address families
Simon Marlow <simonmar@microsoft.com>**20060503081915] 
[Fix for #265, build problem on AIX
Simon Marlow <simonmar@microsoft.com>**20060316143337
 Not the fix from the ticket, but this one at least doesn't require
 modifying the configure script.
] 
[workaround for non-thread-safety of some functions in Network.BSD
Simon Marlow <simonmar@microsoft.com>**20060126153014
 Various functions in Network.BSD are non-thread-safe,
 eg. getHostByName, because the underlying gethostbyname() provided by
 the C library uses static storage.  The workaround here is to use a
 giant lock around these functions.
 
 In some cases, even the API we provide is itself unsafe, relying on
 implicit state (eg. getHostEntry), but this commit makes no attempt to
 fix that.  We should deprecate this library in favour of a complete
 replacement at some point (before 6.6 would be nice).
 
 Thanks to Einar Kartunnen for the patch.
] 
[Fix Ticket 647, Socket bug on Mac OS X
wolfgang.thaller@gmx.net**20060121050509
 Patch kindly provided by Greg Wright
] 
[TAG Initial conversion from CVS complete
John Goerzen <jgoerzen@complete.org>**20060112154134] 
Patch bundle hash:
673d24fc3164ee9f96aa2f3a25829d32fc731d28