What is a socket?
A socket can be thought of as an endpoint in a two-way communication channel. Socket routines create the communication channel, and the channel is used to send data between application programs either locally or over networks. Each socket within the network has a unique name associated with it called a socket descriptor—a fullword integer that designates a socket and allows application programs to refer to it when needed.
Using an electrical analogy, you can think of the communication channel as the electrical wire with its plug and think of the port, or socket, as the electrical socket or outlet, as shown in Figure 1.
This figure shows many application programs running on a client and many application programs on a server. When the client starts a socket call, a socket connection is made between an application on the client and an application on the server.
Another analogy used to describe socket communication is a telephone
conversation. Dialing a phone number from your telephone is similar
to starting a socket call. The telephone switching unit knows where
to logically make the correct switch to complete the call at the remote
location. During your telephone conversation, this connection is present
and information is exchanged. After you hang up, the connection is
broken and you must start it again. The client uses the socket()
function
call to start the logical switch mechanism to connect to the server.
As with file access, user processes ask the operating system to
create a socket when one is needed. The system returns an integer,
the socket descriptor (sd), that the application uses every time it
wants to refer to that socket. The main difference between sockets
and files is that the operating system binds file descriptors to a
file or device when the open()
call creates the file
descriptor. With sockets, application programs can choose to either
specify the destination each time they use the socket—for example,
when sending datagrams—or to bind the destination address to the socket.
Sockets behave in some respects like UNIX files or devices, so they can be used with such traditional operations as read()
or write()
.
For example, after two application programs create sockets and open
a connection between them, one program can use write()
to
send a stream of data, and the other can use read()
to
receive it. Because each file or socket has a unique descriptor, the
system knows exactly where to send and to receive the data.
aio_read()
- Asynchronous read from a socketaio_write()
- Asynchronous write to a socketaio_cancel()
- Cancel an asynchronous I/O requestaio_suspend()
- Wait for an asynchronous I/O requestaio_error()
- Retrieve error status for an asynchronous I/O operationaio_return()
- Retrieve return status for an asynchronous I/O operation