send(), sendto()

`send()`, `sendto()`

Send data out over a socket

Prototypes

#include <sys/types.h>
#include <sys/socket.h>

ssize_t send(int s, const void *buf, size_t len,
int flags);

ssize_t sendto(int s, const void *buf, size_t len,
int flags, const struct sockaddr *to,
socklen_t tolen);

Description

These functions send data to a socket. Generally speaking, send() is used for TCP SOCK_STREAM connected sockets, and sendto() is used for UDP SOCK_DGRAM unconnected datagram sockets. With the unconnected sockets, you must specify the destination of a packet each time you send one, and that's why the last parameters of sendto() define where the packet is going.

With both send() and sendto(), the parameter s is the socket, buf is a pointer to the data you want to send, len is the number of bytes you want to send, and flags allows you to specify more information about how the data is to be sent. Set flags to zero if you want it to be "normal" data. Here are some of the commonly used flags, but check your local send() man pages for more details:

MSG_OOB

Send as "out of band" data. TCP supports this, and it's a way to tell the receiving system that this data has a higher priority than the normal data. The receiver will recieve the signal SIGURG and it can then recieve this data without first recieving all the rest of the normal data in the queue.

MSG_DONTROUTE

Don't send this data over a router, just keep it local.

MSG_DONTWAIT

If send() would block because outbound traffic is clogged, have it return EAGAIN. This is like a "enable non-blocking just for this send." See the section on blocking for more details.

MSG_NOSIGNAL

If you send() to a remote host which is no longer recv()ing, you'll typically get the signal SIGPIPE. Adding this flag prevents that signal from being raised.

Return Value

Returns the number of bytes actually sent, or -1 on error (and errno will be set accordingly.) Note that the number of bytes actually sent might be less than the number you asked it to send! See the section on handling partial send()s for a helper function to get around this.

Also, if the socket has been closed by either side, the process calling send() will get the signal SIGPIPE. (Unless send() was called with the MSG_NOSIGNAL flag.)

Example

int spatula_count = 3490; char *secret_message = "The Cheese is in The Toaster"; int stream_socket, dgram_socket; struct sockaddr_in dest; int temp; // first with TCP stream sockets: stream_socket = socket(PF_INET, SOCK_STREAM, 0); . . . // convert to network byte order temp = htonl(spatula_count); // send data normally: send(stream_socket, &temp, sizeof(temp), 0); // send secret message out of band: send(stream_socket, secret_message, strlen(secret_message)+1, MSG_OOB); // now with UDP datagram sockets: dgram_socket = socket(PF_INET, SOCK_DGRAM, 0); . . . // build destination dest.sin_family = AF_INET; inet_aton("10.0.0.1", &dest.sin_addr); dest.sin_port = htons(2223); // send secret message normally: sendto(dgram_socket, secret_message, strlen(secret_message)+1, 0, (struct sockaddr*)&dest, sizeof(dest));

See Also: recv(), recvfrom()

Contents

`MSG_OOB`	Send as "out of band" data. TCP supports this, and it's a way to tell the receiving system that this data has a higher priority than the normal data. The receiver will recieve the signal `SIGURG` and it can then recieve this data without first recieving all the rest of the normal data in the queue.
`MSG_DONTROUTE`	Don't send this data over a router, just keep it local.
`MSG_DONTWAIT`	If `send()` would block because outbound traffic is clogged, have it return `EAGAIN`. This is like a "enable non-blocking just for this send." See the section on blocking for more details.
`MSG_NOSIGNAL`	If you `send()` to a remote host which is no longer `recv()`ing, you'll typically get the signal `SIGPIPE`. Adding this flag prevents that signal from being raised.