    NAME
           recvfrom - receive a message from a socket

    SYNOPSIS
           #include <network.h>

           int recvfrom(int s, void *buf, int len, unsigned int flags
           struct sockaddr *from, int *fromlen);

    DESCRIPTION
           The  recvfrom call is used to receive messages from a socket,
           and may be used to receive data on a socket whether or not it
           is connection-oriented.

           If from is not NULL, and the socket is not connection-ori
           ented, the source address of the  message  is  filled  in.
           Fromlen  is  a  value-result parameter, initialized to the
           size of the buffer associated with from, and  modified  on
           return  to  indicate the actual size of the address stored
           there.

           The routine  returns  the length of the message on
           successful completion.  If a message is too long to fit in
           the supplied buffer, excess bytes may be discarded depend
           ing on the type of socket the  message  is  received  from
           (see socket(2)).

           If  no  messages  are available at the socket, the receive
           calls wait for a message to arrive, unless the  socket  is
           nonblocking  (see  fcntl(2)) in which case the value -1 is
           returned and the external variable errno  set  to  EAGAIN.
           The  receive  calls normally return any data available, up
           to the requested amount, rather than waiting  for  receipt
           of the full amount requested.

           The  select(2)  call may be used to determine
           when more data arrives.

           The flags argument to a recvfrom call is formed by OR'ing  one
           or more of the following values:

           MSG_OOB
                  This flag requests receipt of out-of-band data that
                  would not be received in the  normal  data  stream.
                  Some  protocols place expedited data at the head of
                  the normal data queue, and thus this flag cannot be
                  used with such protocols.

           MSG_PEEK
                  This  flag  causes  the receive operation to return
                  data from the beginning of the receive queue  with
                  out  removing  that  data  from the queue.  Thus, a
                  subsequent receive call will return the same  data.

           MSG_WAITALL
                  This  flag  requests that the operation block until
                  the full request is satisfied.  However,  the  call
                  may still return less data than requested if a sig
                  nal is caught, an error or  disconnect  occurs,  or
                  the next data to be received is of a different type
                  than that returned.

           MSG_ERRQUEUE
                  Receive packet from the error queue

           MSG_NOSIGNAL
                  This flag turns off raising of  SIGPIPE  on  stream
                  sockets when the other end disappears.

           MSG_ERRQUEUE
                  This  flag  specifies  that queued errors should be
                  received from the socket error queue.  The error is
                  passed  in  a ancilliary message with a type depen
                  dent on the  protocol  (for  IP  IP_RECVERR).   The
                  error  is  supplied in a sock_extended_error struc
                  ture:

                  #define SO_EE_ORIGIN_NONE       0
                  #define SO_EE_ORIGIN_LOCAL      1
                  #define SO_EE_ORIGIN_ICMP       2
                  #define SO_EE_ORIGIN_ICMP6      3

                  struct sock_extended_err
                  {
                      __u32           ee_errno;   /* error number */
                      __u8            ee_origin;  /* where the error originated */
                      __u8            ee_type;    /* type */
                      __u8            ee_code;    /* code */
                      __u8            ee_pad;
                      __u32           ee_info;    /* additional information */
                      __u32           ee_data;    /* other data */
                  };

                  struct sockaddr *SOCK_EE_OFFENDER(struct sock_extended_err *);

                  ee_errno contains the errno number  of  the  queued
                  error.   ee_origin  is the origin code of where the
                  error originated.  The other  fields  are  protocol
                  specific.   SOCK_EE_OFFENDER  returns  a pointer to
                  the address of the network object where  the  error
                  originated  from. If this address is not known, the
                  sa_family member of the sockaddr contains AF_UNSPEC
                  and the other fields of the sockaddr are undefined.
                  The payload of the packet that caused the error  is
                  passed as normal data.

                  For local errors, no address is passed (this can be
                  checked with the cmsg_len member of  the  cmsghdr).
                  For  error receives, the MSG_ERRQUEUE is set in the
                  msghdr.  After a error has been passed, the pending
                  socket  error  is  regenerated  based  on  the next
                  queued error and will be passed on the next  socket
                  operation.

           The msg_flags field is set on return according to the mes
           sage  received.  MSG_EOR indicates end-of-record; the data
           returned completed a record (generally used  with  sockets
           of  type  SOCK_SEQPACKET).   MSG_TRUNC  indicates that the
           trailing portion of a datagram was discarded  because  the
           datagram  was larger than the buffer supplied.  MSG_CTRUNC
           indicates that some control data  were  discarded  due  to
           lack  of  space in the buffer for ancillary data.  MSG_OOB
           is returned to indicate that expedited or out-of-band data
           were  received.   MSG_ERRQUEUE  indicates that no data was
           received but an  extended  error  from  the  socket  error
           queue.

    RETURN VALUES
           These  calls return the number of bytes received, or -1 if
           an error occurred.

    ERRORS
           These are some standard errors  generated  by  the  socket
           layer.  Additional  errors  may  be generated and returned
           from the underlying protocol  modules;  see  their  manual
           pages.

           EBADF   The argument s is an invalid descriptor.

           ENOTSOCK
                   The argument s does not refer to a socket.

           EAGAIN  The  socket is marked non-blocking and the receive
                   operation would block, or a  receive  timeout  had
                   been  set  and the timeout expired before data was
                   received.

           EINTR   The receive was interrupted by delivery of a  sig
                   nal before any data were available.

           EINVAL  Invalid argument passed.