DNS: Domain Name System

People: many identifiers: Domain Name System:

 SSN, name, Passport #  distributed database
Internet hosts, routers: implemented in hierarchy of
many name servers
 IP address (32 bit) -  application-layer protocol
used for addressing
host, routers, name servers to
datagrams
communicate to resolve names
 “name”, e.g., (address/name translation)
gaia.cs.umass.edu - used  note: core Internet
by humans
function implemented as
Q: map between IP application-layer protocol
addresses and name ?  complexity at network’s
“edge”

2: Application Layer 1
DNS name servers
Why not centralize DNS?  no server has all name-to-
 single point of failure IP address mappings
 traffic volume local name servers:
 each ISP, company has local
 distant centralized
(default) name server
database  host DNS query first goes
 maintenance to local name server
authoritative name server:
for a host: stores that
doesn’t scale!

host’s IP address, name
 can perform name/address
translation for that host’s
name

2: Application Layer 2
DNS: Root name servers
 contacted by local
name server that can
not resolve name
 root name server:
 contacts
authoritative name
server if name
mapping not known
 gets mapping
 returns mapping to
local name server
 ~ dozen root name
servers worldwide

2: Application Layer 3
Simple DNS example root name server

host surf.eurecom.fr
2 4
wants IP address of 3
5
gaia.cs.umass.edu
1. Contacts its local DNS
server, dns.eurecom.fr
2. dns.eurecom.fr contacts local name server authorititive name server
root name server, if dns.eurecom.fr dns.umass.edu
necessary
1 6
3. root name server contacts
authoritative name server,
dns.umass.edu, if
necessary requesting host gaia.cs.umass.edu
surf.eurecom.fr

2: Application Layer 4
DNS example root name server

Root name server: 2 6

 may not know 7 3
authoratiative name
server
 may know
intermediate name local name server intermediate name server
server: who to dns.eurecom.fr dns.umass.edu
contact to find 4 5
1 8
authoritative name
server
authoritative name server
dns.cs.umass.edu
requesting host
surf.eurecom.fr

gaia.cs.umass.edu

2: Application Layer 5
DNS: iterated queries root name server

recursive query: 2 iterated query

 puts burden of name 3
resolution on 4
contacted name
server 7
 heavy load? local name server intermediate name server
dns.eurecom.fr dns.umass.edu
iterated query: 5 6
 contacted server
1 8
replies with name of
authoritative name server
server to contact dns.cs.umass.edu
 “I don’t know this requesting host
name, but ask this surf.eurecom.fr
server” gaia.cs.umass.edu

2: Application Layer 6
DNS: caching and updating records
 once (any) name server learns mapping, it caches
mapping
 cache entries timeout (disappear) after some
time
 update/notify mechanisms under design by IETF
 RFC 2136
 http://www.ietf.org/html.charters/dnsind-charter.html

2: Application Layer 7
DNS records
DNS: distributed db storing resource records (RR)
RR format: (name, value, type,ttl)

 Type=A  Type=CNAME
 name is hostname  name is an alias name
 value is IP address for some “cannonical”
(the real) name
 Type=NS
 value is cannonical
 name is domain (e.g. foo.com)
name
 value is IP address of
authoritative name server  Type=MX
for this domain  value is hostname of
mailserver associated with
name
2: Application Layer 8
DNS protocol, messages
DNS protocol : query and repy messages, both with same message format

msg header
 identification: 16 bit # for
query, repy to query uses
same #
 flags:
 query or reply
 recursion desired
 recursion available
 reply is authoritative

2: Application Layer 9
DNS protocol, messages

Name, type fields

for a query

RRs in reponse
to query

records for
authoritative servers

additional “helpful”
info that may be used

2: Application Layer 10
Socket programming
Goal: learn how to build client/server application that
communicate using sockets

Socket API socket

 introduced in BSD4.1 UNIX,
1981 a host-local, application-
 explicitly created, used,
created/owned,
released by apps
OS-controlled interface
 client/server paradigm
(a “door”) into which
application process can
 two types of transport service
both send and
via socket API: receive messages to/from
 unreliable datagram
another (remote or
 reliable, byte stream- local) application process
oriented

2: Application Layer 11
Socket-programming using TCP
Socket: a door between application process and end-end-
transport protocol (UCP or TCP)
TCP service: reliable transfer of bytes from one process
to another

controlled by
controlled by process application
application process
developer
developer socket socket
controlled by TCP with TCP with controlled by
buffers, operating
operating buffers, internet system
system variables variables

host or host or
server server

2: Application Layer 12
Socket programming with TCP
Client must contact server  When client creates socket:
 server process must first client TCP establishes
be running connection to server TCP
 server must have created  When contacted by client,
socket (door) that server TCP creates new
welcomes client’s contact socket for server process to
communicate with client
Client contacts server by:
 allows server to talk with
 creating client-local TCP
multiple clients
socket
 specifying IP address, port
application viewpoint
number of server process
TCP provides reliable, in-order
transfer of bytes (“pipe”)
between client and server

2: Application Layer 13
 Socket programming with TCP

Example client-server app: Input stream: sequence of

 client reads line from bytes into process
standard input (inFromUser Output stream: sequence of
stream) , sends to server via bytes out of process
socket (outToServer
stream)

iinFromServer
outToServer
 server reads line from socket
 server converts line to
uppercase, sends back to
client
inFromUser
 client reads, prints modified
line from socket
(inFromServer stream) client socket

2: Application Layer 14
Client/server socket interaction: TCP
Server (running on hostid) Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()

TCP create socket,

wait for incoming
connection request connection setup connect to hostid, port=x
connectionSocket = clientSocket =
welcomeSocket.accept() Socket()

send request using

read request from clientSocket
connectionSocket

write reply to
connectionSocket read reply from
clientSocket
close
connectionSocket close
clientSocket
2: Application Layer 15
 Example: Java client (TCP)
import java.io.*;
import java.net.*;
class TCPClient {

public static void main(String argv[]) throws Exception

{
String sentence;
String modifiedSentence;
Create
input stream BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
Create
client socket, Socket clientSocket = new Socket("hostname", 6789);
connect to server
Create DataOutputStream outToServer =
output stream new DataOutputStream(clientSocket.getOutputStream());
attached to socket
2: Application Layer 16
 Example: Java client (TCP), cont.

Create BufferedReader inFromServer =

input stream new BufferedReader(new
attached to socket InputStreamReader(clientSocket.getInputStream()));

sentence = inFromUser.readLine();
Send line
to server outToServer.writeBytes(sentence + '\n');

Read line modifiedSentence = inFromServer.readLine();

from server
System.out.println("FROM SERVER: " + modifiedSentence);

clientSocket.close();

}
}
2: Application Layer 17
 Example: Java server (TCP)
import java.io.*;
import java.net.*;

class TCPServer {

public static void main(String argv[]) throws Exception

{
String clientSentence;
Create String capitalizedSentence;
welcoming socket
ServerSocket welcomeSocket = new ServerSocket(6789);
at port 6789
while(true) {
Wait, on welcoming
socket for contact Socket connectionSocket = welcomeSocket.accept();
by client
BufferedReader inFromClient =
Create input new BufferedReader(new
stream, attached InputStreamReader(connectionSocket.getInputStream()));
to socket

2: Application Layer 18
 Example: Java server (TCP), cont

Create output
stream, attached DataOutputStream outToClient =
to socket new DataOutputStream(connectionSocket.getOutputStream());
Read in line
from socket clientSentence = inFromClient.readLine();

capitalizedSentence = clientSentence.toUpperCase() + '\n';

Write out line
outToClient.writeBytes(capitalizedSentence);
to socket
}
}
} End of while loop,
loop back and wait for
another client connection

2: Application Layer 19
Socket programming with UDP

UDP: no “connection” between

client and server
 no handshaking
 sender explicitly attaches application viewpoint
IP address and port of
destination
UDP provides unreliable transfer
of groups of bytes (“datagrams”)
 server must extract IP
between client and server
address, port of sender
from received datagram
UDP: transmitted data may be
received out of order, or
lost

2: Application Layer 20
Client/server socket interaction: UDP
Server (running on hostid) Client

create socket,
port=x, for create socket,
clientSocket =
incoming request: DatagramSocket()
serverSocket =
DatagramSocket()
Create, address (hostid, port=x,
send datagram request
using clientSocket
read request from
serverSocket

write reply to
serverSocket
specifying client read reply from
host address, clientSocket
port umber close
clientSocket

2: Application Layer 21
 Example: Java client (UDP)
import java.io.*;
import java.net.*;

class UDPClient {
public static void main(String args[]) throws Exception
{
Create
input stream BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
Create
client socket DatagramSocket clientSocket = new DatagramSocket();
Translate
InetAddress IPAddress = InetAddress.getByName("hostname");
hostname to IP
address using DNS byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];

String sentence = inFromUser.readLine();

sendData = sentence.getBytes();
2: Application Layer 22
 Example: Java client (UDP), cont.
Create datagram
with data-to-send, DatagramPacket sendPacket =
length, IP addr, port new DatagramPacket(sendData, sendData.length, IPAddress, 9876);

Send datagram clientSocket.send(sendPacket);

to server
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
Read datagram
clientSocket.receive(receivePacket);
from server
String modifiedSentence =
new String(receivePacket.getData());

System.out.println("FROM SERVER:" + modifiedSentence);

clientSocket.close();
}
}

2: Application Layer 23
 Example: Java server (UDP)
import java.io.*;
import java.net.*;

class UDPServer {
public static void main(String args[]) throws Exception
Create {
datagram socket
DatagramSocket serverSocket = new DatagramSocket(9876);
at port 9876
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];

while(true)
{
Create space for
DatagramPacket receivePacket =
received datagram
new DatagramPacket(receiveData, receiveData.length);
Receive serverSocket.receive(receivePacket);
datagram
2: Application Layer 24
 Example: Java server (UDP), cont
String sentence = new String(receivePacket.getData());
Get IP addr
InetAddress IPAddress = receivePacket.getAddress();
port #, of
sender int port = receivePacket.getPort();

String capitalizedSentence = sentence.toUpperCase();

sendData = capitalizedSentence.getBytes();
Create datagram
DatagramPacket sendPacket =
to send to client new DatagramPacket(sendData, sendData.length, IPAddress,
port);
Write out
datagram serverSocket.send(sendPacket);
to socket }
}
} End of while loop,
loop back and wait for
another datagram
2: Application Layer 25
Chapter 2: Summary
Our study of network apps now complete!
 application service
 specific protocols:
requirements:  http
 reliability, bandwidth,
 ftp
delay
 smtp, pop3
 client-server paradigm
 dns
 Internet transport
service model  socket programming
 connection-oriented,  client/server
reliable: TCP implementation
 unreliable, datagrams: UDP  using tcp, udp sockets

2: Application Layer 26
Chapter 2: Summary
Most importantly: learned about protocols
 typical request/reply
 control vs. data msgs
message exchange:
 client requests info or
 in-based, out-of-band
service  centralized vs. decentralized
 server responds with data,  stateless vs. stateful
status code  reliable vs. unreliable msg
 message formats: transfer
 headers: fields giving info  “complexity at network
about data edge”
 data: info being
 security: authentication
communicated

2: Application Layer 27