Port = distinct uint16

Domain = enum
  AF_UNSPEC = 0, ## unspecified domain (can be detected automatically by
                  ## some procedures, such as getaddrinfo)
  AF_UNIX = 1,              ## for local socket (using a file). Unsupported on Windows.
  AF_INET = 2,              ## for network protocol IPv4 or
  AF_INET6 = 23

SockType = enum
  SOCK_STREAM = 1,          ## reliable stream-oriented service or Stream Sockets
  SOCK_DGRAM = 2,           ## datagram service or Datagram Sockets
  SOCK_RAW = 3,             ## raw protocols atop the network layer.
  SOCK_SEQPACKET = 5         ## reliable sequenced packet service

Protocol = enum
  IPPROTO_TCP = 6,          ## Transmission control protocol.
  IPPROTO_UDP = 17,         ## User datagram protocol.
  IPPROTO_IP,               ## Internet protocol.
  IPPROTO_IPV6,             ## Internet Protocol Version 6.
  IPPROTO_RAW,              ## Raw IP Packets Protocol. Unsupported on Windows.
  IPPROTO_ICMP,             ## Internet Control message protocol.
  IPPROTO_ICMPV6             ## Internet Control message protocol for IPv6.

Servent = object
  name*: string
  aliases*: seq[string]
  port*: Port
  proto*: string

Hostent = object
  name*: string
  aliases*: seq[string]
  addrtype*: Domain
  length*: int
  addrList*: seq[string]

osInvalidSocket = INVALID_SOCKET

IOCPARM_MASK = 127

IOC_IN = -2147483648

FIONBIO = -2147195266'i32

proc ioctlsocket(s: SocketHandle; cmd: clong; argptr: ptr clong): cint {...}{.
    stdcall, importc: "ioctlsocket", dynlib: "ws2_32.dll".}

proc `==`(a, b: Port): bool {...}{.borrow.}

proc `$`(p: Port): string {...}{.borrow.}

proc toInt(domain: Domain): cint {...}{.raises: [], tags: [].}

proc toKnownDomain(family: cint): Option[Domain] {...}{.raises: [], tags: [].}

proc toInt(typ: SockType): cint {...}{.raises: [], tags: [].}

proc toInt(p: Protocol): cint {...}{.raises: [], tags: [].}

proc toSockType(protocol: Protocol): SockType {...}{.raises: [], tags: [].}

proc getProtoByName(name: string): int {...}{.raises: [OSError], tags: [].}

proc close(socket: SocketHandle) {...}{.raises: [], tags: [].}

proc setInheritable(s: SocketHandle; inheritable: bool): bool {...}{.inline,
    raises: [], tags: [].}

proc createNativeSocket(domain: cint; sockType: cint; protocol: cint;
                        inheritable: bool = defined(nimInheritHandles)): SocketHandle {...}{.
    raises: [], tags: [].}

proc createNativeSocket(domain: Domain = AF_INET;
                        sockType: SockType = SOCK_STREAM;
                        protocol: Protocol = IPPROTO_TCP;
                        inheritable: bool = defined(nimInheritHandles)): SocketHandle {...}{.
    raises: [], tags: [].}

proc bindAddr(socket: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint {...}{.
    raises: [], tags: [].}

proc listen(socket: SocketHandle; backlog = SOMAXCONN): cint {...}{.
    tags: [ReadIOEffect], raises: [].}

proc getAddrInfo(address: string; port: Port; domain: Domain = AF_INET;
                 sockType: SockType = SOCK_STREAM;
                 protocol: Protocol = IPPROTO_TCP): ptr AddrInfo {...}{.
    raises: [OSError], tags: [].}

proc ntohl(x: uint32): uint32 {...}{.raises: [], tags: [].}

proc ntohs(x: uint16): uint16 {...}{.raises: [], tags: [].}

proc getServByName(name, proto: string): Servent {...}{.tags: [ReadIOEffect],
    raises: [OSError].}

proc getServByPort(port: Port; proto: string): Servent {...}{.tags: [ReadIOEffect],
    raises: [OSError].}

proc getHostByAddr(ip: string): Hostent {...}{.tags: [ReadIOEffect],
    raises: [OSError].}

proc getHostByName(name: string): Hostent {...}{.tags: [ReadIOEffect],
    raises: [OSError].}

proc getHostname(): string {...}{.tags: [ReadIOEffect], raises: [OSError].}

proc getSockDomain(socket: SocketHandle): Domain {...}{.raises: [OSError, IOError],
    tags: [].}

proc getAddrString(sockAddr: ptr SockAddr): string {...}{.
    raises: [Exception, OSError, IOError], tags: [].}

proc getAddrString(sockAddr: ptr SockAddr; strAddress: var string) {...}{.
    raises: [Exception, OSError, IOError], tags: [].}

proc getSockName(socket: SocketHandle): Port {...}{.raises: [OSError], tags: [].}

proc getLocalAddr(socket: SocketHandle; domain: Domain): (string, Port) {...}{.
    raises: [OSError, Exception], tags: [].}

proc getPeerAddr(socket: SocketHandle; domain: Domain): (string, Port) {...}{.
    raises: [OSError, Exception], tags: [].}

proc getSockOptInt(socket: SocketHandle; level, optname: int): int {...}{.
    tags: [ReadIOEffect], raises: [OSError].}

proc setSockOptInt(socket: SocketHandle; level, optname, optval: int) {...}{.
    tags: [WriteIOEffect], raises: [OSError].}

proc setBlocking(s: SocketHandle; blocking: bool) {...}{.raises: [OSError], tags: [].}

proc selectRead(readfds: var seq[SocketHandle]; timeout = 500): int {...}{.
    raises: [], tags: [].}

proc selectWrite(writefds: var seq[SocketHandle]; timeout = 500): int {...}{.
    tags: [ReadIOEffect], raises: [].}

proc accept(fd: SocketHandle; inheritable = defined(nimInheritHandles)): (
    SocketHandle, string) {...}{.raises: [], tags: [].}

template htonl(x: uint32): untyped

template htons(x: uint16): untyped