Subversion Repositories openrisc

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.