Sockets in unix

Sockets
Jerin Mathew George
S5 MCA
Roll No:201219

Socket
• Sockets allow communication between two
different processes on the same or
different machines.
• it's a way to talk to other computers using
standard Unix file descriptors.
• Sockets were first introduced in 2.1BSD
and subsequently refined into their current
form with 4.2BSD. The sockets feature is
now available with most current UNIX
system releases.

• Bidirectional.
• Socket is a end-point communication.
• Socket: An interface between an
application process and transport layer.
The application process can
send/receive messages to/from
another application process (local or
remote)via a socket.

• End point determined by two things:
– Host address: IP address in Network Layer
– Port number: is Transport Layer
• Two end-points determine a connection:
socket pair
– ex: 206.62.226.35,p21 + 198.69.10.2,p1500
– ex: 206.62.226.35,p21 + 198.69.10.2,p1499
• Create Socket
– socket(domain,type,protocol)

• Domain: method of identifing
sockets(address)
– Range of Communicatin
Process on a single host
Across a network
• Type: Stream/Datagram
• Protocol: Usually 0, which means default

Common Socket Domains
• Unix Domain (AF_UNIX)
– Communication on a single host
– Adress->file system path name
• IPv4 Domain (AF_INET)
– Communication on IPv4 network
– Address->IPv4 address (32bit)+Port No
• IPv6 Domain (AF_INET6)
– Communication on IPv6 network
– Address->IPv4 address (128bit)+Port No

Ports
• Numbers (typical, since vary by OS):
– 0-1023 “reserved”, must be root
– 1024 - 5000 “ephemeral”
– Above 5000 for general use
(50,000 is specified max)
• Well-known, reserved services (see
/etc/services in Unix):
– ftp 21/tcp
– telnet 23/tcp
– finger 79/tcp
– snmp 161/udp

Using Ports to Identify Services
10
Web server
(port 80)
Client host
Server host 128.2.194.242
Echo server
(port 7)
Service request for
128.2.194.242:80
(i.e., the Web server)
Web server
(port 80)
Echo server
(port 7)
Service request for
128.2.194.242:7
(i.e., the echo server)
OS
OS
Client
Client

Socket Types
• Two main Types are:-
– UDP: User Datagram Protocol
(SOCK_STREAM)
– TCP: Transmission Control Protocol
(SOCK_DGRAM)
• Other domain provided by UNIX system is
– Sequential Packet
(SOCK_SEQPACKET)

Stream Socket(TCP)
Byte streamr
reliable (in order, all arrive, no duplicates)
flow control
Two channels on the socket for send bytes
to each other
Connection-oriented
* Eg: like two party phone calls

Datagram Socket(UDP)
Message oriented
no acknowledgements
no retransmissions
Unreliable (out of order, duplicates)
Connection less
*Eg: Postal System

Sequential Packet Socket(SCTP)
It is not widely used protocol
Midway between stream and datagram
socket
Message oriented
Connection oriented
Reliable

Addresses and Sockets
• Structure to hold address information
• Functions pass address from user to OS
bind()
connect()
sendto()
• Functions pass address from OS to user
accept()
recvfrom()

Socket Address Structure
struct in_addr {
in_addr_t s_addr; /* 32-bit IPv4 addresses */
};
struct sockaddr_in {
unit8_t sin_len; /* length of structure */
sa_family_t sin_family; /* AF_INET *domain/
in_port_t sin_port; /* TCP/UDP Port num */
struct in_addr sin_addr; /* IPv4 address (above) */
char sin_zero[8]; /* unused */
}
• Are also “generic” and “IPv6” socket
structures

TCP Client-Server
socket()
bind()
listen()
accept()
Server
socket()
connect()
send()
recv()
Client
(Block until connection)
“Handshake”
recv()
send()
Data (request)
Data (reply)
close()
End-of-File
recv()
“well-known”
port ActiveSocket
Passive Socket

socket()
int socket(int family, int type, int protocol);
Create a socket, giving access to transport layer
service.
• family is one of
– AF_INET (IPv4), AF_INET6 (IPv6), AF_LOCAL (local Unix),
– AF_ROUTE (access to routing tables), AF_KEY (new, for
encryption)
• type is one of
– SOCK_STREAM (TCP), SOCK_DGRAM (UDP)
– SOCK_RAW (for special IP packets, PING, etc. Must be root)
setuid bit (-rws--x--x root 1997 /sbin/ping*)
• protocol is 0 (used for some raw socket
options)
• upon success returns socket descriptor
– Integer, like file descriptor
– Return -1 if failure

bind()
• sockfd is socket descriptor from socket()
• myaddr is a pointer to address struct with:
– port number and IP address
– if port is 0, then host will pick ephemeral port
not usually for server (exception RPC port-map)
– IP address != INADDR_ANY (unless multiple nics)
• addrlen is length of structure
• returns 0 if ok, -1 on error
– EADDRINUSE (“Address already in use”)
int bind(int sockfd, const struct sockaddr *myaddr,
socklen_t addrlen);
Assign a local protocol address (“name”) to a socket.

listen()
• backlog is maximum number of incomplete
connections
– historically 5
– rarely above 15 on a even moderate Web server!
• Sockets default to active (for a client)
– change to passive so OS will accept connection
int listen(int sockfd, int backlog);
Change socket state for TCP server.

accept()
• cliaddr and addrlen return protocol address from
client
• returns brand new descriptor, created by OS
• note, if create new process or thread, can create
concurrent server
int accept(int sockfd, struct sockaddr
cliaddr, socklen_t *addrlen);
Return next completed connection.

close()
• closes socket for reading/writing
– returns (doesn’t block)
– attempts to send any unsent data
– socket option SO_LINGER
block until data sent
or discard any remaining data
– returns -1 if error
int close(int sockfd);
Close socket for use.

TCP Client-Server
socket()
bind()
listen()
accept()
Server
socket()
connect()
send()
recv()
Client
(Block until connection)
“Handshake”
recv()
send()
Data (request)
Data (reply)
close()
End-of-File
recv()
“well-known”
port

connect()
• servaddr is a pointer to a structure with:
– port number and IP address
– must be specified (unlike bind())
• addrlen is length of structure
• client doesn’t need bind()
– OS will pick ephemeral port
• returns socket descriptor if ok, -1 on error
int connect(int sockfd, const struct sockaddr
*servaddr, socklen_t addrlen);
Connect to server.

Sending and Receiving
int recv(int sockfd, void *buff, size_t
mbytes, int flags);
int send(int sockfd, void *buff, size_t
mbytes, int flags);
• Same as read() and write() but for flags
– MSG_DONTWAIT (this send non-blocking)
– MSG_OOB (out of band data, 1 byte sent ahead)
– MSG_PEEK (look, but don’t remove)
– MSG_WAITALL (don’t give me less than max)
– MSG_DONTROUTE (bypass routing table)

UDP Client-Server
socket()
bind()
recvfrom()
Server
socket()
sendto()
recvfrom()
Client
(Block until receive datagram)
sendto()
Data (request)
Data (reply)
close()
“well-known”
port
- No “handshake”
- No simultaneous close
- No fork()/spawn() for concurrent servers!

Sending and Receiving
int recvfrom(int sockfd, void *buff, size_t mbytes,
int flags, struct sockaddr *from, socklen_t
*addrlen);
int sendto(int sockfd, void *buff, size_t mbytes, int
flags, const struct sockaddr *to, socklen_t
addrlen);
• Same as recv() and send() but for addr
– recvfrom fills in address of where packet
came from
– sendto requires address of where sending
packet to

Sockets in unix

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Sockets in unix (20)

Recently uploaded (20)

Sockets in unix

Editor's Notes