Introduction to Computer Networks

1
Introduction to Computer Networks
Sockets

• Ilam University
• By Dr. Mozafar Bag Mohammadi

2
Outline

• What is a socket?
• Types of sockets
• Uses of sockets
• Socket function
• Byte order
• Dealing with blocking
• Some useful function

3
Socket programming

• Goal- Communication between two processes
• They use interface/services from the transport
  layer. The interface is called Application
  Programming Interface, API.

Server process
Client process
TCP/UDP
TCP/UDP
Socket API
IP
IP
Ethernet Adaptor
Ethernet Adaptor
4
What is a socket?

• An API between application and network
• Define an end- point for communication
• The application creates a socket
• The socket type dictates the style of
  communication
• reliable vs. best effort
• connection-oriented vs. connectionless
• Initiate and accept a connection
• Once configured the application can
• pass data to the socket for network transmission
• receive data from the socket (transmitted through
  the network by some other host)
• Terminate a connection gracefully
• Berkeley Sockets are the most common (from BSD
  Unix)

5
Two essential types of sockets

• SOCK_STREAM
• a.k.a. TCP
• reliable delivery
• in-order guaranteed
• connection-oriented
• bidirectional

• SOCK_DGRAM
• a.k.a. UDP
• unreliable delivery
• no order guarantees
• no notion of connection app indicates dest.
  for each packet
• can send or receive

Q why have type SOCK_DGRAM?
6
Client- Server communication (UDP)
server
recvfrom () sendto()
bind() to a receiving port
socket() to create socket
client
socket() to create scoket
recvfrom () sendto ()
bind() to any port
7
Client- Server communication (TCP)
server
bind() to a receiving port
Accept() connection
socket()
listen () to socket
send() recv()
client
bind() to any port
send() recv()
socket()
connect () to server
8
Example

• A generic server (FTP) Wait for connections on a
  port
• When a client connection comes in,
• loop
• Read in the clients request
• Read data from a file
• Send the data to the client
• Disconnect when we have reached EOF
• A generic client, high level Connect to a given
  server
• loop
• Send a request to the server
• Read servers response
• Read servers data
• Disconnect when we have reached EOF

9
Socket Creation in C socket

• int s socket(domain, type, protocol)
• s socket descriptor, an integer (like a
  file-handle)
• domain integer, communication domain
• e.g., PF_INET (IPv4 protocol) typically used,
  PF_UNIX
• type communication type
• SOCK_STREAM reliable, 2-way, connection-based
  service
• SOCK_DGRAM unreliable, connectionless,
• other values need root permission, rarely used,
  or obsolete
• protocol specifies protocol (see file
  /etc/protocols for a list of options) - usually
  set to 0
• NOTE socket call does not specify where data
  will be coming from, nor where it will be going
  to it just creates the interface!

10
A Socket-eye view of the Internet
medellin.cs.columbia.edu (128.59.21.14)
newworld.cs.umass.edu (128.119.245.93)
cluster.cs.columbia.edu (128.59.21.14,
128.59.16.7, 128.59.16.5, 128.59.16.4)

• Each host machine has an IP address
• When a packet arrives at a host

11
Ports

• Each host has 65,536 ports
• Some ports are reserved for specific apps
• 20,21 FTP
• 23 Telnet
• 80 HTTP
• see RFC 1700 (about 2000 ports are reserved)

Port 0
Port 1
Port 65535

• A socket provides an interface to send data
  to/from the network through a port

12
Well-known ports
13
Addresses, Ports and Sockets

• Like apartments and mailboxes
• You are the application
• Your apartment building address is the address
• Your mailbox is the port
• The post-office is the network
• The socket is the key that gives you access to
  the right mailbox (one difference assume
  outgoing mail is placed by you in your mailbox!)

14
The bind function

• associates and (can exclusively) reserves a port
  for use by the socket
• int status bind(sockid, addrport, size)
• status error status, -1 if bind failed
• sockid integer, socket descriptor
• addrport struct sockaddr,
• struct sockaddr_in
• u_char sin_family / Address Family /
• u_short sin_port / Port number /
• struct in_addr sin_addr / IP address /
• char sin_zero8 / unused /
• size the size (in bytes) of the addrport
  structure

15
Skipping the bind

• SOCK_DGRAM
• if only sending, no need to bind. The OS finds a
  port each time the socket sends a pkt
• if receiving, need to bind
• SOCK_STREAM
• destination determined during conn. setup
• dont need to know port sending from (during
  connection setup, receiving end is informed of
  port)

16
Connection Setup (SOCK_STREAM)

• Recall no connection setup for SOCK_DGRAM
• A connection occurs between two kinds of
  participants
• passive waits for an active participant to
  request connection
• active initiates connection request to passive
  side
• Once connection is established, passive and
  active participants are similar
• both can send receive data
• either can terminate the connection

17
Connection setup contd

• Passive participant
• step 1 listen (for incoming requests)
• step 3 accept (a request)
• step 4 data transfer
• The accepted connection is on a new socket
• The old socket continues to listen for other
  active participants
• Why?

• Active participant
• step 2 request establish connection
• step 4 data transfer

Passive Participant
Active 1
Active 2
18
Connection setup listen accept

• Called by passive participant
• int status listen(sock, queuelen)
• status 0 if listening, -1 if error
• sock integer, socket descriptor
• queuelen integer, of active participants that
  can wait for a connection
• listen is non-blocking returns immediately
• int s accept(sock, name, namelen)
• s integer, the new socket (used for
  data-transfer)
• sock integer, the original socket (being
  listened on)
• name struct sockaddr, address of the active
  participant
• namelen sizeof(name) value/result parameter
• must be set appropriately before call
• adjusted by OS upon return
• accept is blocking waits for connection before
  returning

19
connect call

• int status connect(sock, name, namelen)
• status 0 if successful connect, -1 otherwise
• sock integer, socket to be used in connection
• name struct sockaddr address of passive
  participant
• namelen integer, sizeof(name)
• connect is blocking

20
Sending / Receiving Data

• With a connection (SOCK_STREAM)
• int count send(sock, buf, len, flags)
• count bytes transmitted (-1 if error)
• buf char, buffer to be transmitted
• len integer, length of buffer (in bytes) to
  transmit
• flags integer, special options, usually just 0
• int count recv(sock, buf, len, flags)
• count bytes received (-1 if error)
• buf void, stores received bytes
• len bytes received
• flags integer, special options, usually just 0
• Calls are blocking returns only after data is
  sent (to socket buf) / received

21
Sending / Receiving Data (contd)

• Without a connection (SOCK_DGRAM)
• int count sendto(sock, buf, len, flags, addr,
  addrlen)
• count, sock, buf, len, flags same as send
• addr struct sockaddr, address of the destination
• addrlen sizeof(addr)
• int count recvfrom(sock, buf, len, flags,
  addr,
• addrlen)
• count, sock, buf, len, flags same as recv
• name struct sockaddr, address of the source
• namelen sizeof(name) value/result parameter
• Calls are blocking returns only after data is
  sent (to socket buf) / received

22
close

• When finished using a socket, the socket should
  be closed
• status close(s)
• status 0 if successful, -1 if error
• s the file descriptor (socket being closed)
• Closing a socket
• closes a connection (for SOCK_STREAM)
• frees up the port used by the socket

23
Example TCP Server program

• Make a socket
• include ltsys/ types. hgt
• include ltsys/ socket. hgt
• int fd, newfd, nbytes, nbytes2
• char buf512, response512
• struct sockaddr_in srv
• fd socket(AF_INET, SOCK_STREAM, 0)

24
Example TCP Server program

• The socket was created now bind it to a port and
  host.
• srv.sin_family AF_INET
• srv.sin_port htons(80)
• srv.sin_addr.s_addr inet_addr(128.2.15.9'')
• / or srv.sin_addr.s_addr htonl(IN_ADDR_ANY)
• bind(fd, (struct sockaddr) srv, sizeof(srv))
• Now sit and listen
• listen(fd, 5)
• Now, accept any connection. First, clear the
  structure.
• struct sockaddr_in cli
• int cli_len
• bzero((char)cli, sizeof( cli))
• newfd accept(fd, (struct sockaddr) cli,
  cli_len)

25
Example TCP Server program

• Now it can read from socket, newfd, and write to
  socket, newfd.
• int BUF_ SIZE 1024, bytesrecv 0
• char buf BUF_ SIZE
• / receives up to BUF_ SIZE bytes from sock and
  stores them in buf. /
• bytesrecv recv( newfd, buf, BUF_ SIZE, 0)
• / send up BUF_ SIZE bytes /
• bytesrecv send( newfd, buf, BUF_ SIZE, 0)
• At the end, we need to close both sockets by
  close command.
• close( newfd) / closes the socket newfd /
• close( fd) / closes the socket fd /

26
Example TCP client program

• int fd, newfd, nbytes, nbytes2
• char buf512, response512
• struct sockaddr_in srv
• fd socket(AF_INET, SOCK_STREAM, 0)
• The same as server. Now, it needs to connect to
  server.
• srv.sin_family AF_INET
• srv.sin_port htons(80)
• srv.sin_addr.s_addr inet_addr(128.2.15.9'')
• /or srv.sin_addr.s_addr inet_addr(argv1)
• /or inet_aton( argv1, srv.sin_addr)
• /or inet_pton(AF_INET, argv1, srv.sin_addr)
• connect(fd, (struct sockaddr) srv,
  sizeof(srv))
• Connect is blocking and send a SYN signal and is
  blocked until receive SYNACK, (three way
  handshaking)
• It can start now reading and writing
• sprintf(request, Here's my request'')
• nbytes2 write(fd, request, strlen(request))
• close(fd)

27
Address and port byte-ordering

• Address and port are stored as integers
• u_short sin_port (16 bit)
• in_addr sin_addr (32 bit)

struct in_addr u_long s_addr

• Problem
• different machines / OSs use different word
  orderings
• little-endian lower bytes first
• big-endian higher bytes first
• these machines may communicate with one another
  over the network

Big-Endian machine
Little-Endian machine
12.40.119.128
128.119.40.12
WRONG!!!
28
Solution Network Byte-Ordering

• Defs
• Host Byte-Ordering the byte ordering used by a
  host (big or little)
• Network Byte-Ordering the byte ordering used by
  the network always big-endian
• Any words sent through the network should be
  converted to Network Byte-Order prior to
  transmission (and back to Host Byte-Order once
  received)
• Q should the socket perform the conversion
  automatically?

• Q Given big-endian machines dont need
  conversion routines and little-endian machines
  do, how do we avoid writing two versions of code?

29
UNIXs byte-ordering funcs

• u_long htonl(u_long x)
• u_short htons(u_short x)

• u_long ntohl(u_long x)
• u_short ntohs(u_short x)

• On big-endian machines, these routines do nothing
• On little-endian machines, they reverse the byte
  order
• Same code would have worked regardless of
  endian-ness of the two machines

Big-Endian machine
Little-Endian machine
128.119.40.12
128.119.40.12
30
Dealing with blocking calls

• Many of the functions we saw block until a
  certain event
• accept until a connection comes in
• connect until the connection is established
• recv, recvfrom until a packet (of data) is
  received
• send, sendto until data is pushed into sockets
  buffer
• Q why not until received?
• For simple programs, blocking is convenient
• What about more complex programs?
• multiple connections
• simultaneous sends and receives
• simultaneously doing non-networking processing

31
Dealing with blocking (contd)

• Options
• create multi-process or multi-threaded code
• turn off the blocking feature (e.g., using the
  fcntl file-descriptor control function)
• use the select function call.
• What does select do?
• can be permanent blocking, time-limited blocking
  or non-blocking
• input a set of file-descriptors
• output info on the file-descriptors status
• i.e., can identify sockets that are ready for
  use calls involving that socket will return
  immediately

32
select function call

• int status select(nfds, readfds, writefds,
  exceptfds, timeout)
• status of ready objects, -1 if error
• nfds 1 largest file descriptor to check
• readfds list of descriptors to check if
  read-ready
• writefds list of descriptors to check if
  write-ready
• exceptfds list of descriptors to check if an
  exception is registered
• timeout time after which select returns, even if
  nothing ready - can be 0 or ?
• (point timeout parameter to NULL for ?)

33
To be used with select

• Recall select uses a structure, struct fd_set
• it is just a bit-vector
• if bit i is set in readfds, writefds,
  exceptfds, select will check if file descriptor
  (i.e. socket) i is ready for reading, writing,
  exception
• Before calling select
• FD_ZERO(fdvar) clears the structure
• FD_SET(i, fdvar) to check file desc. i
• After calling select
• int FD_ISSET(i, fdvar) boolean returns TRUE iff
  i is ready

34
Other useful functions

• bzero(char c, int n) 0s n bytes starting at c
• in_addr_t inet_addr(const char cp) converts
  dotted-decimal char-string to long integer
• char inet_ntoa(const struct in_addr in)
  converts long to dotted-decimal notation
• int inet_aton(const char cp, const struct
  in_addr in)
• gethostname(char name, int len) gets the name
  of the current host
• gethostbyaddr(char addr, int len, int type)
  converts IP hostname to structure containing long
  integer
• Warning check function assumptions about
  byte-ordering (host or network). Often, they
  assume parameters / return solutions in network
  byte-order

35
Release of ports

• Sometimes, a rough exit from a program (e.g.,
  ctrl-c) does not properly free up a port
• Eventually (after a few minutes), the port will
  be freed
• To reduce the likelihood of this problem, include
  the following code
• include ltsignal.hgt
• void cleanExit()exit(0)
• in socket code
• signal(SIGTERM, cleanExit)
• signal(SIGINT, cleanExit)