Minix Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
IP(4)                      Kernel Interfaces Manual                      IP(4)

       ip,  eth,  psip,  udp,  tcp  -  Internet  Protocol  server  devices and

       The ip*, eth*, psip*,  tcp*,  and  udp*  devices  give  access  to  the
       Internet  Protocol  (IP)  services  in  MINIX 3.  There can be up to 16
       different networks, with 4 network devices each (a network  has  either
       an  eth*  or a psip* device, not both.)  The * in the device names is a
       decimal number, so one may see names  from  ip0  to  ip15.   A  program
       scanning  all  networks must try all 16, and not stop if one in between
       is missing.  One network is  the  default  network.   Its  devices  are
       linked to names without numbers.

       The eth* and psip* devices give direct access to the network packets at
       the lowest level.  The ip*, tcp*, and udp* devices give access  to  IP,
       TCP, or UDP services.

       Most programs that use TCP/IP use code like the following to access the
       proper devices:

              if ((tcp_device= getenv("TCP_DEVICE")) == NULL)
                   tcp_device= "/dev/tcp";

       The low level networking programs such as ifconfig(8) also have options
       to select the device they are working with.  The convention is:

              -E device
                     Device  to  use  as  raw  ethernet  device instead of the
                     default /dev/eth.

              -P device
                     Pseudo IP device to use instead of /dev/psip.

              -I device
                     IP device to use instead of /dev/ip.

              -T device
                     TCP device to use instead of /dev/tcp.

              -U device
                     UDP device to use instead of /dev/udp.

       Access to the IP services is provided using filedescriptors to open  IP
       devices.  These open IP channels can be configured with ioctl(2) calls,
       and data can be transferred by calls to read(2), and write(2).

   Types (general)
              Defines u8_t, u16_t, u32_t and i32_t (and U8_t, U16_t, U32_t and
              I32_t for use in prototypes).

   Types (eth)
              Defines  struct  ether_addr  (ether_addr_t) and ether_type_t and
              Ether_type_t for use in prototypes.

              Defines   struct   nwio_ethopt   (nwio_ethopt_t)   and    struct
              nwio_ethstat (nwio_ethstat_t)

              Defines struct eth_hdr (eth_hdr_t)

   Types (psip)
              [[[No description available yet.]]]

              [[[No description available yet.]]]

   Types (ip)
              Defines ipaddr_t, ipproto_t and struct ip_hdropt (ip_hdropt_t).

              Defines struct nwio_ipconf (nwio_ipconf_t) and struct nwio_ipopt

              Defines struct ip_hdr (ip_hdr_t)

              Defines struct nwio_route (nwio_route_t)

   Types (tcp)
              Defines tcpport_t and Tcpport_t for use in prototypes.

              Defines struct nwio_tcpconf (nwio_tcpconf_t), struct  nwio_tcpcl
              (nwio_tcpcl_t),  struct  nwio_tcpatt  (nwio_tcpatt_t) and struct
              nwio_tcpopt (nwio_tcpopt_t).

              Defines  struct  tcp_hdr  (tcp_hdr_t)  and   struct   tcp_hdropt

   Types (udp)
              Defines udpport_t and Udpport_t for use in prototypes.

              Defines struct nwio_udpopt (nwio_udpopt_t).

              Defines   struct   udp_hdr  (udp_hdr_t)  and  struct  udp_io_hdr

   Byte Order Conversion
       All 16-bit and 32-bit quantities in IP headers must be in network  byte
       order.   The  macros  described in hton(3) can be used to convert these
       values to and from the byte order used by the host machine.

   The Internet Checksum
       The oneC_sum function (see oneC_sum(3)) is used to calculate the  one's
       complement checksum needed for IP network packets.

   General Functions
       fd = open(tcpip_device, O_RDWR)

       This  is  how  one  normally  obtains a filedescriptor for a new TCP/IP
       channel.  tcpip_device names one of the TCP/IP  devices.   The  channel
       may be used both to send or to receive data.

       n = read(fd, buf, size)

       Receives  one  packet  (low  level  devices)  or a number of bytes (TCP
       stream).  Returns the the number of bytes placed into buf,  or  returns
       -1 with an error code placed into errno.

       n = write(fd, buf, size)

       Sends one packet (low level devices) or a number of bytes (TCP stream).
       Returns size or -1 with the error code placed into errno.   The  TCP/IP
       read  and write functions behave like reads and writes on pipes when it
       comes to signals.

   ETH Functions
       ioctl(fd, NWIOGETHSTAT, &struct nwio_ethstat)

       The NWIOGETHSTAT ioctl returns the Ethernet address and some statistics
       of  the  Ethernet  server of the channel fd.  The result is returned in
       the nwio_ethstat structure.  The  struct  nwio_ethstat  is  defined  in

              typedef struct nwio_ethstat
                      ether_addr_t nwes_addr;
                      eth_stat_t nwes_stat;
              } nwio_ethstat_t;

              typedef struct eth_stat
                  unsigned long ets_recvErr,  /* # receive errors */
                   ets_sendErr,            /* # send error */
                   ets_OVW,                /* # buffer overwrite warnings,
                                                 (packets arrive faster than
                                                  can be processed) */
                   ets_CRCerr,             /* # crc errors of read */
                   ets_frameAll,           /* # frames not aligned (# bits
                                                 not a multiple of 8) */
                   ets_missedP,            /* # packets missed due to too
                                                 slow packet processing */
                   ets_packetR,            /* # packets received */
                   ets_packetT,            /* # packets transmitted */
                   ets_transDef,           /* # transmission deferred (there
                                                 was a transmission of an
                                                 other station in progress */
                   ets_collision,          /* # collisions */
                   ets_transAb,            /* # transmissions aborted due
                                                 to excessive collisions */
                   ets_carrSense,          /* # carrier sense lost */
                   ets_fifoUnder,          /* # fifo underruns (processor
                                                 is too busy) */
                   ets_fifoOver,           /* # fifo overruns (processor is
                                                 too busy) */
                   ets_CDheartbeat,        /* # times unable to transmit
                                                 collision signal */
                   ets_OWC;                /* # times out of window
                                                 collision */
              } eth_stat_t;

       ioctl(fd, NWIOSETHOPT, &struct nwio_ethopt)

       Before  an  Ethernet  channel  can  be used to send or receive Ethernet
       packets, it has to be configured  using  the  NWIOSETHOPT  ioctl.   The
       structure nwio_ethopt is defined in <net/gen/eth_io.h>:

              typedef struct nwio_ethopt
                   u32_t nweo_flags;
                   ether_addr_t nweo_multi, nweo_rem;
                   ether_type_t nweo_type;
              } nwio_ethopt_t;

              #define NWEO_NOFLAGS    0x0000L
              #define NWEO_ACC_MASK   0x0003L
              #       define NWEO_EXCL        0x00000001L
              #       define NWEO_SHARED      0x00000002L
              #       define NWEO_COPY        0x00000003L
              #define NWEO_LOC_MASK   0x0010L
              #       define NWEO_EN_LOC      0x00000010L
              #       define NWEO_DI_LOC      0x00100000L
              #define NWEO_BROAD_MASK 0x0020L
              #       define NWEO_EN_BROAD    0x00000020L
              #       define NWEO_DI_BROAD    0x00200000L
              #define NWEO_MULTI_MASK 0x0040L
              #       define NWEO_EN_MULTI    0x00000040L
              #       define NWEO_DI_MULTI    0x00400000L
              #define NWEO_PROMISC_MASK 0x0080L
              #       define NWEO_EN_PROMISC  0x00000080L
              #       define NWEO_DI_PROMISC  0x00800000L
              #define NWEO_REM_MASK   0x0100L
              #       define NWEO_REMSPEC     0x00000100L
              #       define NWEO_REMANY      0x01000000L
              #define NWEO_TYPE_MASK  0x0200L
              #       define NWEO_TYPESPEC    0x00000200L
              #       define NWEO_TYPEANY     0x02000000L
              #define NWEO_RW_MASK    0x1000L
              #       define NWEO_RWDATONLY   0x00001000L
              #       define NWEO_RWDATALL    0x10000000L

       The  configuration  is  divided  in a number of section (covered by the
       xx_MASK macros).  Options can be set  in  the  nweo_flags  field.   The
       first section (NWEO_ACC_MASK) controls the access to a certain Ethernet
       packet type.  If NWEO_EXCL is selected then this is  the  only  channel
       that  can  send  or  receive Ethernet packets of the selected type.  If
       NWEO_SHARED is selected then  multiple  channels  (which  all  have  to
       select  NWEO_SHARED)  can use the same Ethernet type, they all can send
       packets but incoming packets will be delivered to at most one of  them.
       If NWEO_COPY is selected then multiple channels have access to the same
       Ethernet type and all receive a copy of an incoming packet.

       The  NWEO_LOC_MASK  flags  control  the  delivery  of  packets  with  a
       destination  address  equal to the Ethernet address of the machine.  If
       NWEO_EN_LOC is selected then these packets will be delivered  and  with
       NWEO_DI_LOC they will be discarded.

       broadcast packets, multicast packets and promiscuous  mode  packets  as
       NWEO_LOC_MASK   does  for  local  packets.   Except  that  the  precise
       multicast address is taken from the nweo_multi field.

       The NWEO_REM_MASK flags control whether communication is restricted  to
       single   destination   or  not.   NWEO_REMSPEC  restricts  sending  and
       receiving of packets to the single remote  computer  specified  in  the
       nweo_rem  field.   NWEO_REMANY allows sending to and receiving from any
       remote computer.

       NWEO_TYPESPEC restricts sending and receiving of packets  to  the  type
       specified  in  nweo_type.   The  type  has  to be in network byte order
       (using hton(3)).  NWEO_TYPEANY allows any type.

       If the Ethernet header is completely specified by the nweo_flags  i.e.,
       NWEO_REMSPEC and NWEO_TYPESPEC are specified, then  NWEO_RWDATONLY  can
       be  used  to send and receive only the data part of an Ethernet packet.
       If NWEO_RWDATALL is specified then both Ethernet header  and  data  are

   PSIP Functions
       [[[No description available yet.]]]

   IP Functions
       ioctl(fd, NWIOGIPCONF, &struct nwio_ipconf)

       The  NWIOGIPCONF  ioctl  reports  the Internet Address and the netmask.
       For the nwio_ipconf structure see the NWIOSIPCONF ioctl below.

       ioctl(fd, NWIOGIPOROUTE, &struct nwio_route)

       The NWIOGIPOROUTE ioctl can be used to query an  IP  server  about  its
       structure nwio_route is defined in <net/gen/route.h>:

              typedef struct nwio_route
                      u32_t nwr_ent_no;
                      u32_t nwr_ent_count;
                      ipaddr_t nwr_dest;
                      ipaddr_t nwr_netmask;
                      ipaddr_t nwr_gateway;
                      u32_t nwr_dist;
                      u32_t nwr_flags;
                      u32_t nwr_pref;
              } nwio_route_t;

              #define NWRF_EMPTY      0
              #define NWRF_INUSE      1
              #define NWRF_FIXED      2

       The requested entry is taken from nwr_ent_no.  Entries are counted from
       0,  so  the  value 0 can be used for an initial query.  The size of the
       routing table is returned in nwr_ent_count.  The nwr_flags indicates if
       the entry is in use (NWRF_INUSE) and if the entry was inserted manually
       (using NWIOSIPOROUTE) or generated by the IP server itself.  The  route
       is  described  by  nwr_dest,  nwr_netmask,  nwr_gateway,  nwr_dist, and
       nwr_pref.  Nwr_dest and nwr_netmask select the  destination  addresses.
       A  value  of (0x0) in both nwr_dest and nwr_netmask means every
       host.  A value of (0xffffffff) in nwr_netmask  means  a
       single  host.  Other values of nwr_netmask are netmasks for the network
       specified by nwr_dest.  Nwr_gateway is gateway  that  should  be  used.
       Nwr_dist  is  a  minimal distance.  Packets with a time to live smaller
       than nwr_dist will not reach the destination.  If two routes have equal
       netmask  and  distance  fields  but different gateways then the gateway
       with highest value in nwr_pref is used.

       ioctl(fd, NWIOSIPCONF, &struct nwio_ipconf)

       The NWIOSIPCONF ioctl can be used to inform the  IP  server  about  its
       Internet  Address  and/or  its  netmask.   Normally  an  IP server will
       discover its Internet Address using the RARP protocol.  NWIOSIPCONF can
       be  used  in  the  case  that the RARP failed, or the netmask has to be
       changed.  Note that higher level protocols (TCP and  UDP)  assume  that
       the Internet Address of an IP device does not change, therefore TCP and
       UDP stop functioning if the Internet Address is changed.

       The structure nwio_ipconf is defined in <net/gen/ip_io.h>:

              typedef struct nwio_ipconf
                   u32_t   nwic_flags;
                   ipaddr_t nwic_ipaddr;
                   ipaddr_t nwic_netmask;
              } nwio_ipconf_t;

              #define NWIC_NOFLAGS            0x0
              #define NWIC_FLAGS              0x3
              #       define NWIC_IPADDR_SET          0x1
              #       define NWIC_NETMASK_SET         0x2

       The function of nwio_ipconf depends on the  value  of  nwic_flags.   If
       NWIC_IPADDR_SET  is  set  then  the  Internet  Address  will  be set to
       nwic_ipaddr.  If NWIC_NETMASK_SET is set then the Internet Address will
       be set to nwic_netmask.

       ioctl(fd, NWIOSIPOPT, &struct nwio_ipopt)

       Before  an  IP  channel  can be used, it has to be configured using the
       NWIOSIPOPT   ioctl.    The   structure   nwio_ipopt   is   defined   in

              typedef struct nwio_ipopt
                      u32_t nwio_flags;
                      ipaddr_t nwio_rem;
                      ip_hdropt_t nwio_hdropt;
                      u8_t nwio_tos;
                      u8_t nwio_ttl;
                      u8_t nwio_df;
                      ipproto_t nwio_proto;
              } nwio_ipopt_t;

              #define NWIO_NOFLAGS    0x0000L
              #define NWIO_ACC_MASK   0x0003L
              #       define NWIO_EXCL        0x00000001L
              #       define NWIO_SHARED      0x00000002L
              #       define NWIO_COPY        0x00000003L
              #define NWIO_LOC_MASK   0x0010L
              #       define NWIO_EN_LOC      0x00000010L
              #       define NWIO_DI_LOC      0x00100000L
              #define NWIO_BROAD_MASK 0x0020L
              #       define NWIO_EN_BROAD    0x00000020L
              #       define NWIO_DI_BROAD    0x00200000L
              #define NWIO_REM_MASK   0x0100L
              #       define NWIO_REMSPEC     0x00000100L
              #       define NWIO_REMANY      0x01000000L
              #define NWIO_PROTO_MASK 0x0200L
              #       define NWIO_PROTOSPEC   0x00000200L
              #       define NWIO_PROTOANY    0x02000000L
              #define NWIO_HDR_O_MASK 0x0400L
              #       define NWIO_HDR_O_SPEC  0x00000400L
              #       define NWIO_HDR_O_ANY   0x04000000L
              #define NWIO_RW_MASK    0x1000L
              #       define NWIO_RWDATONLY   0x00001000L
              #       define NWIO_RWDATALL    0x10000000L

       The   options   are   divided  in  several  categories:  NWIO_ACC_MASK,
       NWIO_HDR_O_MASK  and  NWIO_RW_MASK.   A  channel is configured when one
       option of each category is set.

       The options covered by NWIO_ACC_MASK control  the  number  of  channels
       that can use one IP protocol.  If NWIO_EXCL is specified then only that
       channel can use a certain IP protocol.  If  NWIO_SHARED  then  multiple
       channels  that  all  have  to  specify  NWIO_SHARED can use the same IP
       protocol, but incoming packets will be delivered to a most one channel.
       NWIO_COPY  does not impose any restrictions.  Every channel gets a copy
       of an incoming packet.

       NWIO_LOC_MASK and NWIO_BROAD_MASK control the delivery of packets.   If
       NWIO_EN_LOC  is  specified then packets that are explicitly send to the
       IP server are delivered.  If NWIO_EN_BROAD is specified then  broadcast
       packets are delivered.  Either one or both of them can be disabled with

       NWIO_REMSPEC can be used to restrict communication to one remote  host.
       This  host  is taken from the nwio_rem field.  If any remote host is to
       be allowed then NWIO_REMANY can be used.

       NWIO_PROTOSPEC restricts communication to one IP protocol, specified in
       nwio_proto.  NWIO_PROTOANY allows any protocol to be sent or received.

       NWIO_HDR_O_SPEC specifies all IP header options in advance.  The values
       are  taken  from  nwio_hdropt,   nwio_tos,   nwio_ttl,   and   nwio_df.
       Nwio_hdropt  specifies  the  IP  options  that  should be present in an
       outgoing packet.  Ip_hdropt_t is defined in <net/gen/in.h>:

              typedef struct ip_hdropt
                      u8_t iho_opt_siz;
                      u8_t iho_data[IP_MAX_HDR_SIZE-IP_MIN_HDR_SIZE];
              } ip_hdropt_t;

       The bytes of size iho_opt_siz  in  iho_data  are  appended  to  the  IP
       header.   Nwio_tos specifies the value of the ``type of service'' bits,
       nwio_ttl gives the value of the ``time  to  live''  field  and  nwio_df
       specifies  whether  fragmentation is disallowed or not.  NWIO_HDR_O_ANY
       specifies that the header options should be  specified  at  each  write

       NWIO_RWDATONLY specifies that the header should be omitted from a write
       request.  This option can only be  used  when  all  header  fields  are
       specified    in    previous    options:   NWIO_EN_LOC,   NWIO_DI_BROAD,
       NWIO_REMSPEC, NWIO_PROTOSPEC and  NWIO_HDR_O_SPEC.   A  read  operation
       will also only return the data part, so the IP options will be lost.

       ioctl(fd, NWIOSIPOROUTE, &struct nwio_route)

       The  NWIOSIPOROUTE  ioctl  adds  a  route  to  the  routing table.  See
       NWIOGIPOROUTE above for a description of the nwio_route structure.  The
       fields nwr_ent_no and nwr_ent_count are ignored.

   TCP Functions
       ioctl(fd, NWIOTCPCONN, &struct nwio_tcpcl)

       The  NWIOTCPCONN ioctl tries to setup a connection with a remote TCP/IP
       server.  The channel must be fully configured  (see  NWIOSTCPCONF)  and
       values  for the local port, the remote port and the remote address have
       be  specified  using  NWTC_LP_SET  or  NWTC_LP_SEL,   NWTC_SET_RA   and
       NWTC_SET_RP.   The  struct  nwio_tcpcl is defined in <net/gen/tcp_io.h>

              typedef struct nwio_tcpcl
                   long nwtcl_flags;
                   long nwtcl_ttl;
              } nwio_tcpcl_t;

       Set the nwtcl_flags field to zero before the connect  or  listen  call.
       [[[Further explanation of nwio_tcpcl?]]]

       ioctl(fd, NWIOGTCPCONF, &struct nwio_tcpconf)

       This  call  reports  the  current  configuration of a TCP channel.  The
       nwtc_flags field shows the status of the access, locport,  remaddr  and
       remport  fields.   Nwtc_locaddr  contains  the  Internet address of the
       TCP/IP server.  Remaddr contains the Internet  address  of  the  remote
       TCP/IP  server  when set with NWTC_SET_RA or after a successful connect
       or listen (see NWIOTCPCONN or  NWIOTCPLISTEN).   Nwio_locport  contains
       the  local  TCP/IP  port  set with NWTC_LP_SET or the selected port set
       with NWTC_LP_SEL.  Nwtc_remport contains the TCP  port  of  the  remote
       TCP/IP  server as set with NWIO_SET_RP or after a successful connect or

       A value of 0 (zero)  is  reported  for  nwtc_remaddr,  nwtc_locport  or
       nwtc_remport when no value is set either explicitly or implicitly.

       ioctl(fd, NWIOTCPLISTEN, &struct nwio_tcpcl)

       The  NWIOTCPLISTEN  ioctl  waits  until a remote TCP/IP server tries to
       connect to this  channel.   The  channel  has  to  be  configured  (see
       NWIOSTCPCONF).   An  additional restriction is that the local port must
       be set (with NWTC_LP_SET)  or  selected  (with  NWTC_LP_SEL).   When  a
       remote  address is set only connections for that host are accepted, and
       when a remote port is set only connections from that port are accepted.
       After a successful listen NWIOGTCPCONF can be used to find out what the
       address and port of the other side are.

       ioctl(fd, NWIOSTCPCONF, &struct nwio_tcpconf)

       Before a  TCP  channel  can  be  used  it  must  configured  using  the
       NWIOSTCPCONF  ioctl.   The  parameters  to NWIOSTCPCONF are the channel
       file   descriptor   and   a   struct   nwio_tcpconf   as   defined   in

              typedef struct nwio_tcpconf
                   u32_t nwtc_flags;
                   ipaddr_t nwtc_locaddr;
                   ipaddr_t nwtc_remaddr;
                   tcpport_t nwtc_locport;
                   tcpport_t nwtc_remport;
              } nwio_tcpconf_t;

              #define NWTC_NOFLAGS    0x0000L
              #define NWTC_ACC_MASK   0x0003L
              #       define NWTC_EXCL        0x00000001L
              #       define NWTC_SHARED      0x00000002L
              #       define NWTC_COPY        0x00000003L
              #define NWTC_LOCPORT_MASK       0x0030L
              #       define NWTC_LP_UNSET    0x00000010L
              #       define NWTC_LP_SET      0x00000020L
              #       define NWTC_LP_SEL      0x00000030L
              #define NWTC_REMADDR_MASK       0x0100L
              #       define NWTC_SET_RA      0x00000100L
              #       define NWTC_UNSET_RA    0x01000000L
              #define NWTC_REMPORT_MASK       0x0200L
              #       define NWTC_SET_RP      0x00000200L
              #       define NWTC_UNSET_RP    0x02000000L

       A  tcp  channel is considered configured when one flag in each category
       has been selected.  Thus one of NWTC_EXCL,  NWTC_SHARED  or  NWTC_COPY,
       one of NWTC_LP_UNSET, NWTC_LP_SET or NWTC_LP_SEL, one of NWTC_SET_RA or
       NWTC_UNSET_RA, and one of NWTC_SET_RP or NWTC_UNSET_RP.

       The acc flags control the access to  a  certain  TCP  port.   NWTC_EXCL
       means  exclusive  access.   An  attempt  to configure a channel will be
       denied if the same  port  is  specified  as  that  of  a  channel  that
       requested   exclusive   access.   NWTC_SHARED  indicates  that  several
       channels use the same port  but  cooperate.   If  the  shared  mode  is
       specified for one channel than all other channel that use the same port
       should also be configured with  the  NWTC_SHARED  flag.   NWTC_COPY  is
       specified when the programmer does not care about other channels.  This
       is the default.

       The locport flags control which TCP port  is  used  for  communication.
       NWTC_LP_UNSET  indicates  the  absence  of  a  local port.  This is the
       default.  NWTC_LP_SET means that the nwtc_locport  field  contains  the
       local port to be used by TCP.  This value must be in network byte order
       (see hton(3).)  NWTC_LP_SEL requests the TCP server  to  pick  a  port.
       This port will be in the range from 32768 to 65535 and will be unique.

       The  remaddr  flags specify which hosts are acceptable for connections.
       NWTC_SET_RA indicates that only connection to  the  host  specified  in
       nwtc_remaddr  are  acceptable.   Nwtc_remaddr should be in network byte
       order (see hton(3).)  NWTC_UNSET_RA allows every host on the other side
       of a connection.  This is the default.

       The  remport  flags  specify  which  remote  ports  are  acceptable for
       connections.  NWTC_SET_RP indicates that only  the  port  specified  in
       nwtc_remport  is  acceptable.   NWTC_UNSET_RP  allows every port on the
       other side of a connection.  This is the default.

       ioctl(fd, NWIOTCPSHUTDOWN)

       The NWIOTCPSHUTDOWN tells the TCP/IP server that no more data  will  be
       sent over the channel specified by fd.  This command can be issued when
       the channel is connected to a remote TCP/IP server.  The TCP/IP  server
       will  tell the remote TCP/IP server and the client of the remote TCP/IP
       server will receive an end-of-file indication.

       ioctl(fd, NWIOGTCPOPT, &struct nwio_tcpopt)
       ioctl(fd, NWIOSTCPOPT, &struct nwio_tcpopt)

       The behaviour of a TCP channel may be changed by setting  a  number  of
       options.   The  TCP  options can be obtained with the NWIOGTCPOPT ioctl
       and set with the NWIOSTCPOPT ioctl.  The options are passed in a struct
       nwio_tcpopt as defined in <net/gen/tcp_io.h>:

              typedef struct nwio_tcpopt
                   u32_t nwto_flags;
              } nwio_tcpopt_t;

              #define NWTO_NOFLAG     0x0000L
              #define NWTO_SND_URG_MASK       0x0001L
              #       define NWTO_SND_URG     0x00000001L
              #       define NWTO_SND_NOTURG  0x00010000L
              #define NWTO_RCV_URG_MASK       0x0002L
              #       define NWTO_RCV_URG     0x00000002L
              #       define NWTO_RCV_NOTURG  0x00020000L
              #define NWTO_BSD_URG_MASK       0x0004L
              #       define NWTO_BSD_URG     0x00000004L
              #define NWTO_DEL_RST_MASK       0x0008L
              #       define NWTO_DEL_RST     0x00000008L

       The  NWTO_SND_URG option causes bytes written to the channel to be send
       out as urgent data.  On receiving an EURG error the NWTO_RCV_URG option
       must  be  set  to  switch over to reading urgent data.  When all urgent
       data has been read an ENOURG error will  follow,  indicating  that  the
       option   must   be   cleared   with   NWTO_RCV_NOTURG.   Alas  the  BSD
       implementation of urgent data disagrees with the RFC's, so  to  be  BSD
       compatible one must set the NWTO_BSD_URG option beforehand on a channel
       that  is  to  send  or  receive  urgent  data.   Given  that  the   BSD
       implementation is the regarded as the TCP/IP standard one should always
       use the BSD style.  The NWTO_DEL_RST option delays a  failure  response
       on  a connect to the same port as the current open connection.  Without
       this option a connect would fail if a  server  is  not  yet  listening.
       With  this  option  a  connect  will  linger on until the server starts
       listening.  This option is useful for a server that opens a connection,
       tells  the  remote end the local port number and then listens (FTP), or
       for a program that forks off servers for incoming connections (TELNET).
       A  new connection may come in before a new listen can be started, so it
       is nice if the new connect doesn't fail.  Use this option only when  it
       is clearly needed.

   UDP Functions
       ioctl(fd, NWIOGUDPOPT, &struct nwio_udpopt)

       The  NWIOGUDPOPT ioctl returns the current options that result from the
       default options and the options set with NWIOSUDPOPT.  When NWUO_LP_SEL
       or  NWUO_LP_SET is selected the local port is returned in nwuo_locport.
       When  NWUO_RP_SET  is  selected  the  remote  port   is   returned   in
       nwuo_remport.   The  local  address is always returned in nwuo_locaddr,
       and when NWUO_RA_SET is selected the  remote  address  is  returned  in

       ioctl(fd, NWIOSUDPOPT, &struct nwio_udpopt)

       A UDP channel must be configured using the NWIOSUDPOPT ioctl before any
       data can be read or written.  NWIOSUDPOPT takes two parameters, a  file
       descriptor to an open UDP device and pointer to a nwio_udpopt structure
       that describes the requested configuration.  The nwio_udpopt  structure
       is defined in <net/gen/udp_io.h> as:

              typedef struct nwio_udpopt
                   unsigned long nwuo_flags;
                   udpport_t nwuo_locport;
                   udpport_t nwuo_remport;
                   ipaddr_t nwuo_locaddr;
                   ipaddr_t nwuo_remaddr;
              } nwio_udpopt_t;

              #define NWUO_NOFLAGS            0x0000L
              #define NWUO_ACC_MASK           0x0003L
              #define         NWUO_EXCL               0x00000001L
              #define         NWUO_SHARED             0x00000002L
              #define         NWUO_COPY               0x00000003L
              #define NWUO_LOCPORT_MASK       0x000CL
              #define         NWUO_LP_SEL             0x00000004L
              #define         NWUO_LP_SET             0x00000008L
              #define         NWUO_LP_ANY             0x0000000CL
              #define NWUO_LOCADDR_MASK       0x0010L
              #define         NWUO_EN_LOC             0x00000010L
              #define         NWUO_DI_LOC             0x00100000L
              #define NWUO_BROAD_MASK         0x0020L
              #define         NWUO_EN_BROAD           0x00000020L
              #define         NWUO_DI_BROAD           0x00200000L
              #define NWUO_REMPORT_MASK       0x0100L
              #define         NWUO_RP_SET             0x00000100L
              #define         NWUO_RP_ANY             0x01000000L
              #define NWUO_REMADDR_MASK       0x0200L
              #define         NWUO_RA_SET             0x00000200L
              #define         NWUO_RA_ANY             0x02000000L
              #define NWUO_RW_MASK            0x1000L
              #define         NWUO_RWDATONLY          0x00001000L
              #define         NWUO_RWDATALL           0x10000000L
              #define NWUO_IPOPT_MASK         0x2000L
              #define         NWUO_EN_IPOPT           0x00002000L
              #define         NWUO_DI_IPOPT           0x20000000L

       A  UDP  channel is considered configured when one flag in each category
       has been selected.  Thus one of NWUO_EXCL,  NWUO_SHARED  or  NWUO_COPY,
       one  of  NWUO_LP_SEL, NWUO_LP_SET or NWUO_LP_ANY, one of NWUO_EN_LOC or
       NWUO_DI_LOC,  one  of   NWUO_EN_BROAD,   or   NWUO_DI_BROAD,   one   of
       NWUO_RP_SET, or NWUO_RP_ANY, one of NWUO_RA_SET, or NWUO_RA_ANY, one of
       NWUO_RWDATONLY,  or  NWUO_RWDATALL,  and  one  of   NWUO_EN_IPOPT,   or
       NWUO_DI_IPOPT.  The acc flags control the access to a certain UDP port.
       NWUO_EXCL means exclusive access: no other channel can use  this  port.
       NWUO_SHARED  means  shared  access:  only  channels that specify shared
       access can use this port and all packets that are received  are  handed
       to  at  most  one channel.  NWUO_COPY imposes no access restriction and
       all channels get a copy of every received packet for that port.

       The locport flags control the  selection  of  the  UDP  port  for  this
       channel.   NWUO_LP_SEL  requests  the server to pick a port.  This port
       will be in the range from  32768  to  65535  and  it  will  be  unique.
       NWUO_LP_SET sets the local port to the value of the nwuo_locport field.
       NWUO_LP_ANY does not select a port.  Reception of data is therefore not
       possible but it is possible to send data.

       The  locaddr  flags  control  the  reception  of  packets.  NWUO_EN_LOC
       enables  the  reception  of  packets  with  the  local  IP  address  as
       destination.   NWUO_DI_LOC  disables  the  reception  of packet for the
       local IP address.

       The  broad  flags  control  the   reception   of   broadcast   packets.
       NWUO_EN_BROAD   enables   the   reception   of  broadcast  packets  and
       NWUO_DI_BROAD disables the reception of broadcast packets.

       The remport flags let the client to specify  one  specific  remote  UDP
       port or to allow any remote port.  NWUO_RP_SET sets the remote UDP port
       to the value of nwuo_remport.  Only packets with a matching remote port
       will  be  delivered  and  all  packets  will  be  sent  to  that  port.
       NWUO_RP_ANY  allows  reception  of  packets  form  any  port  and  when
       transmitting packets the remote port has to be specified.

       The  remaddr flags control the remote IP address.  NWUO_RA_SET sets the
       remote IP address the value of nwuo_remaddr.  Only  packets  from  that
       address will be delivered and all packets will be sent to that address.
       NWUO_RA_ANY  allows  reception  of  packets  from  any  host  and  when
       transmitting packets the remote host has to be specified.

       The  rw  flags  control  the format of the data to be sent or received.
       With NWUO_RWDATONLY only the data part of a UDP packet is sent  to  the
       server  and  only  the  data  part  is  received  from the server.  The
       NWUO_RWDATALL mode presents the data part of a UDP packet with a header
       that  contains  the  source  and  destination  IP  address,  source and
       destination UDP ports, the IP options, etc.  The server expects such  a
       header in front of the data to be transmitted.

       The  ipopt  flags  control the delivery and transmission of IP options.
       When NWUO_EN_IPOPT is set IP, options will be delivered and sent.  When
       NWUO_DI_IPOPT  is  set IP option will be stripped from received packets
       and no IP options will be sent.

       /dev/eth*    Raw  ethernet.   The  numbers  in  the  device  names  are
                    decimal, so one may see names from eth0 to eth15.

       /dev/psip*   First and second Pseudo IP network.

       /dev/ip*     IP devices for two ethernets and two Pseudo IP networks.

       /dev/tcp*    TCP devices for same four networks.

       /dev/udp*    UDP devices.

       /dev/eth, /dev/psip, /dev/ip, /dev/tcp, /dev/udp
                    Devices  for  the  default  network,  links to the devices
                    above.  Eth is only present if ethernet  is  the  default,
                    psip only for pseudo IP.

       hton(3), oneC_sum(3), inet(8), boot(8).

       Several errors may be returned by the TCP/IP server.  The error code is
       found in the errno variable if the read, write, or ioctl  call  returns
       -1.  The TCP/IP error codes defined in <errno.h> are, among others:

       EPACKSIZE           This  indicates  an attempt to read or write with a
                           buffer that is too large or too small.

       ENOBUFS             The  TCP/IP  server  has  insufficient  memory   to
                           execute the request.

       ENOTTY              This  indicates an attempt to execute a command the
                           particular  server  does   not   understand.    For
                           example, a NWIOGTCPCONF on an ETH channel.

       EBADMODE            The  request  is refused because the channel is not
                           fully  configured,  in  the  wrong  state  or   the
                           parameters are invalid.

       ENETUNREACH         The destination network is not reachable.

       EHOSTUNREACH        The destination host is not reachable.

       EISCONN             The  channel  is  already  connected  so  a  second
                           request is refused.

       EADDRINUSE          This address is in use.

       ECONNREFUSED        The connection is refused by the other side.

       ECONNRESET          The connection is reset (non-gracefully terminated)
                           by the other side.

       ETIMEDOUT           The  connection  is  terminated  due  to an expired

       EURG                Urgent data is present and the current receive mode
                           does not allow urgent data to be transferred.

       ENOURG              No  urgent  data  is present and a request came for
                           urgent data.

       ENOTCONN            The request requires a connected  channel  and  the
                           channel is not connected.

       ESHUTDOWN           The   connection   is   shut   down.   That  is,  a
                           NWIOTCPSHUTDOWN has been executed so no  more  data
                           can be transmitted.

       ENOCONN             The connection does not exist.

       EGENERIC            A generic error code for extremely weird cases.

       Philip Homburg (