PEMROGRAMAN SISTEM

JARINGAN
PERTEMUAN 11 – 5 DESEMBER 2020
Socket programming
goal: learn how to build client/server applications that
communicate using sockets
socket: dropbox between application process and end-
end-transport protocol

application application
socket controlled by
process process app developer

transport transport
network network controlled
link
by OS
link Internet
physical physical

Application Layer2-2
 Socket programming
Two socket types for two transport services:
 UDP: unreliable datagram
 TCP: reliable, byte stream-oriented

Application Example:
1. Client reads a line of characters (data) from its
keyboard and sends the data to the server.
2. The server receives the data and converts
characters to uppercase.
3. The server sends the modified data to the client.
4. The client receives the modified data and displays
the line on its screen.
Application Layer2-3
Socket programming with UDP
UDP: no “connection” between client & server
 no handshaking before sending data
 sender explicitly attaches IP destination address and
port # to each packet
 rcvr extracts sender IP address and port# from
received packet
UDP: transmitted data may be lost or received
out-of-order
Application viewpoint:
 UDP provides unreliable transfer of groups of bytes
(“datagrams”) between client and server

Application Layer2-4
Client/server socket interaction: UDP

server (running on serverIP) client

create socket:
create socket, port= x: clientSocket =
serverSocket = DatagramSocket()
DatagramSocket(x)
Create datagram with server IP and
port=x; send datagram via
read datagram from clientSocket
serverSocket

write reply to
serverSocket read datagram from
specifying clientSocket
client address,
port number close
clientSocket

Application 2-5
 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
hostname to IP InetAddress IPAddress = InetAddress.getByName("hostname");
addr using DNS
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];

String sentence = inFromUser.readLine();

sendData = sentence.getBytes();

Application Layer2-6
 Example: Java client (UDP)
create datagram with
DatagramPacket sendPacket =
data-to-send,
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();
}
}

Application Layer2-7
 Example: Java server (UDP)
import java.io.*;
import java.net.*;

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

byte[] receiveData = new byte[1024];

byte[] sendData = new byte[1024];

while(true)
{
create space for
received datagram DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
receive serverSocket.receive(receivePacket);
datagram
Application Layer2-8
 Example: Java server (UDP)
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
to send to client DatagramPacket sendPacket =
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
Application Layer2-9
 Example app: UDP client
Python UDPClient
include Python’s socket
library import socket
serverName = ‘hostname’
serverPort = 12000
create UDP socket for clientSocket = socket.socket(socket.AF_INET,
server

get user keyboard

socket.SOCK_DGRAM)
input message = raw_input(’Input lowercase sentence:’)
Attach server name, port to
message; send into socket clientSocket.sendto(message,(serverName, serverPort))
read reply characters from modifiedMessage, serverAddress =
socket into string
clientSocket.recvfrom(2048)
print out received string print modifiedMessage
and close socket
clientSocket.close()

Application Layer2-10
 Example app: UDP server
Python UDPServer
from socket import *
serverPort = 12000
create UDP socket serverSocket = socket(AF_INET, SOCK_DGRAM)
bind socket to local port
number 12000
serverSocket.bind(('', serverPort))
print “The server is ready to receive”
loop forever while 1:
Read from UDP socket into message, clientAddress = serverSocket.recvfrom(2048)
message, getting client’s
address (client IP and port) modifiedMessage = message.upper()
send upper case string serverSocket.sendto(modifiedMessage, clientAddress)
back to this client

Application Layer2-11
Socket programming with TCP
client must contact server  server accepts connect by:
 server must be first running  creating new connection-
 server must have created specific socket
socket (dropbox) that  allows server to talk with
welcomes client’s contact multiple clients
client connects to server by:
 creating TCP socket,
specifying IP address, port
number of server process application viewpoint:
 client socket is now bound to TCP provides reliable, in-order
that specific server byte-stream transfer (“pipe”)
between client and server

Application Layer2-12
Client/server socket interaction: TCP
server (running on hostid) client
create socket,
port=x, for incoming
request:
serverSocket =
ServerSocket()

wait for incoming create socket,

connection request
TCP connect to hostid, port=x
connectionSocket = connection setup clientSocket = socket()
serverSocket.accept()

send request using

read request from clientSocket
connectionSocket

write reply to
connectionSocket read reply from
clientSocket
close
connectionSocket close
clientSocket

Application Layer2-13
 Example: Java client (TCP)
import java.io.*; this package defines Socket()
import java.net.*; and ServerSocket() classes
class TCPClient {

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

{
server name,
String sentence; e.g., www.umass.edu
String modifiedSentence;
server port #
create
input stream BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
create
clientSocket object
of type Socket, Socket clientSocket = new Socket("hostname", 6789);
connect to server
create DataOutputStream outToServer =
output stream new DataOutputStream(clientSocket.getOutputStream());
attached to socket

Application Layer2-14
 Example: Java client (TCP)
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);

close socket clientSocket.close();

(clean up behind yourself!)

}
}

Application Layer2-15
 Example: Java server (TCP)
import java.io.*;
import java.net.*;

class TCPServer {

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

{
String clientSentence;
String capitalizedSentence;
create
welcoming socket
at port 6789 ServerSocket welcomeSocket = new ServerSocket(6789);

wait, on welcoming while(true) {

socket accept() method
for client contact create, Socket connectionSocket = welcomeSocket.accept();
new socket on return
BufferedReader inFromClient =
create input new BufferedReader(new
stream, attached InputStreamReader(connectionSocket.getInputStream()));
to socket

Application Layer2-16
 Example: Java server (TCP)
create output
stream, attached
to socket DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());
read in line
from socket clientSentence = inFromClient.readLine();

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

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

Application Layer2-17
 Example app: TCP client
Python TCPClient
import socket
serverName = ‘servername’
create TCP socket for serverPort = 12000
server, remote port 12000
clientSocket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
clientSocket.connect((serverName,serverPort))
No need to attach server sentence = raw_input(‘Input lowercase sentence:’)
name, port
clientSocket.send(sentence)
modifiedSentence = clientSocket.recv(1024)
print ‘From Server:’, modifiedSentence
clientSocket.close()

Application Layer2-18
 Example app: TCP server
Python TCPServer
from socket import *
create TCP welcoming
serverPort = 12000
socket serverSocket = socket(AF_INET,SOCK_STREAM)
serverSocket.bind((‘’,serverPort))
server begins listening for
incoming TCP requests
serverSocket.listen(1)
print ‘The server is ready to receive’
loop forever while 1:
server waits on accept() connectionSocket, addr = serverSocket.accept()
for incoming requests, new
socket created on return
sentence = connectionSocket.recv(1024)
read bytes from socket (but
not address as in UDP) capitalizedSentence = sentence.upper()
close connection to this
connectionSocket.send(capitalizedSentence)
client (but not welcoming connectionSocket.close()
socket)
Application Layer2-19