Pemrograman Jaringan oleh Ahmad Ashari

1. Pemrograman Jaringan
Ahmad Ashari – 2008

2. Java Program

Java source di buat
− pakai text editor dan disimpan dengan nama sesuai
nama class (Case Sensitive) dan ekstensi .java

Di compile menghasilkan Byte code dengan
nama sesuai nama class (Case Sensitive) dan
ekstensi .class
− Memerlukan java compiler yang tersedia di JDK

Byte code di jalankan menggunakan JVM
− JVM diperoleh dalam paket JRE atau JDK

3. Client – Server

Bentuk komunikasi menggunakan model client
server

Program yang dibuat harus terdiri dari client
dan server

Server bersifat pasif, program yang menunggu

Client bersifat aktif, program yang
menghubungi server

P2P juga mempunyai client dan server

4. Komunikasi Antar Aplikasi

IPC = Komunikasi antar proses
− Shared memory
− Message Passing di jaringan

Socket

RPC/RMI

Socket dibuat berdasarkan pasangan alamat IP
dan port yang dipakai/dipilih

Alamat IP sering digantikan oleh nama host

port adalah bilangan 1 – 65535 untuk tcp/udp

5. Socket

Socket adalah representasi dari gerbang
komunikasi di jaringan

Socket bekerja layaknya layanan I/O Unix
seperti akses file, pipe dan FIFO.
− fd = fopen --> fd adalah file descriptor

Socket berfungsi untuk:
− Meng establish koneksi, dan
− Menentukan alamat untuk gerbang komunikasi

6. Port

Socket dibuat menggunakan pasangan port
dan ip address

Port untuk transport layer (untuk 1 aplikasi
diperjanjikan 1 port tententu)
− 16 bit --> nilainya 1 – 65535

Ip address network layer

7. Sockets dan Ports
message
agreed port
any port
socketsocket
Internet address = 138.37.88.249Internet address = 138.37.94.248
other ports
client server
Client
creates socket
sends to addr/port
Server
creates socket
binds to port
advertises addr/port

8. Multiplex-demultiplex di jaringan
Aplikasi 2Aplikasi 1 Aplikasi 4Aplikasi 3
TCP/UDP Lainnya
IP
...
Ethernet
Lainnya...
Netbios
RPC

9. Java net API

Socket di Java dibedakan dalam 3 macam:
− Socket client untuk TCP (stream)

java.net.Socket
− Socket server untuk TCP (stream)

java.net.ServerSocket
− Socket datagram untuk UDP

java.net.DatagramSocket

10. Client socket

public Socket(String host, int port) throws
UnknownHostException, IOException

Contoh:
try {
Socket toOReilly = new Socket("www.oreilly.com", 80);
// send and receive data...
}
catch (UnknownHostException ex) {
System.err.println(ex);
}
catch (IOException ex) {
System.err.println(ex);

11. Class SocketAddress dan connect
package java.net.*;
public abstract class SocketAddress {
public SocketAddress( ) {}
}
public SocketAddress getRemoteSocketAddress( )
public SocketAddress getLocalSocketAddress( )
A SocketAddress is necessary to connect an unconnected
socket via the connect( ) method:
public void connect(SocketAddress endpoint) throws IOException

12. Server socket

public ServerSocket(int port) throws
BindException, IOException

public ServerSocket(int port, int queueLength)
throws BindException, IOException

public ServerSocket(int port, int queueLength,
InetAddress bindAddress)
throws IOException

public ServerSocket( ) throws IOException //
Java 1.4

13. Step utk Program Client TCP

Create a Socket object.
− Socket client = new Socket("hostname", portNumber);

Create an output stream that can be used to send information to the Socket.
− PrintWriter out = new PrintWriter(client.getOutputStream(), true);

Create an input stream to read the response from the server.
− InputStreamReader in = new
InputStreamReader(client.getInputStream());

Do I/O with input and output streams.

Close the Socket when done.
− client.close();

14. Program Client untuk TCP
import java.net.*;
import java.io.*;
public class DaytimeClient {
public static void main(String[] args) {
String hostname;
if (args.length > 0) {
hostname = args[0];
}
else {
hostname = "tock.usno.navy.mil";
}
try {
Socket theSocket = new Socket(hostname, 13);
InputStream timeStream = theSocket.getInputStream();
StringBuffer time = new StringBuffer();

15. Program Client untuk TCP
int c;
while ((c = timeStream.read()) != -1) time.append((char) c);
String timeString = time.toString().trim();
System.out.println("It is " + timeString + " at " + hostname);
} // end try
catch (UnknownHostException e) {
System.err.println(e);
}
catch (IOException e) {
System.err.println(e);
}
} // end main
} // end DaytimeClient

16. Step utk Program Server TCP

Create a ServerSocket object.
− ServerSocket listenSocket =
new ServerSocket(portNumber);

Create a Socket object from the ServerSocket
(accept connection)
− Socket server = listenSocket.accept();

Create an input stream to read input from the client
− BufferedReader in = new BufferedReader
(new InputStreamReader(server.getInputStream()));

Create an output stream that can be used to
send information back to the client
− PrintWriter out = new PrintWriter(server.getOutputStream());

Do I/O with input and output streams.

Close the Socket when done.
− server.close();

17. Program Server untuk TCP
import java.net.*;
import java.io.*;
import java.util.Date;
public class DaytimeServer {
public final static int DEFAULT_PORT = 13;
public static void main(String[] args) {
int port = DEFAULT_PORT;
if (args.length > 0) {
try {
port = Integer.parseInt(args[0]);
if (port < 1 || port > 65535) {
System.out.println("Port must between 1 and 65535");
return;
}
}

18. Program Server untuk TCP
catch (NumberFormatException ex) {
// use default port }
}
try {
ServerSocket server = new ServerSocket(port);
Socket connection = null;
while (true) {
try {
connection = server.accept();
Writer out = new
OutputStreamWriter(connection.getOutputStream());
Date now = new Date();
out.write(now.toString() +"rn");
out.flush();
connection.close();
}

19. Program Server untuk TCP
catch (IOException ex) {}
finally {
try {
if (connection != null) connection.close();
}
catch (IOException ex) {}
}
} // end while
} // end try
catch (IOException ex) {
System.err.println(ex);
} // end catch
} // end main
} // end DaytimeServer

20. Client UDP
import java.net.*;
import java.io.*;
public class UDPDiscardClient {
public final static int DEFAULT_PORT = 9;
public static void main(String[] args) {
String hostname;
int port = DEFAULT_PORT;
if (args.length > 0) {
hostname = args[0];
try {
port = Integer.parseInt(args[1]);
}
catch (Exception ex) {
// use default port
}
}
else {
hostname = "localhost";
}

21. Client UDP
try {
InetAddress server = InetAddress.getByName(hostname);
BufferedReader userInput = new BufferedReader(new
InputStreamReader(System.in));
DatagramSocket theSocket = new DatagramSocket();
while (true) {
String theLine = userInput.readLine();
if (theLine.equals(".")) break;
byte[] data = theLine.getBytes();
DatagramPacket theOutput = new DatagramPacket(data,
data.length, server, port);
theSocket.send(theOutput);
} // end while
} catch (UnknownHostException uhex) {
System.err.println(uhex);
} catch (SocketException sex) {
System.err.println(sex);
} catch (IOException ioex) {
System.err.println(ioex); }
} // end main
}

22. Server UDP
import java.net.*;
import java.io.*;
public class UDPDiscardServer {
public final static int DEFAULT_PORT = 9;
public final static int MAX_PACKET_SIZE =
65507;
public static void main(String[] args) {
int port = DEFAULT_PORT;
byte[] buffer = new byte[MAX_PACKET_SIZE];
try {
port = Integer.parseInt(args[0]);
}
catch (Exception ex) {
// use default port
}

23. Server UDP
try {
DatagramSocket server = new DatagramSocket(port);
DatagramPacket packet = new DatagramPacket(buffer,
buffer.length);
while (true) {
try {
server.receive(packet);
String s = new String(packet.getData(), 0,
packet.getLength());
System.out.println(packet.getAddress() + " at
port " + packet.getPort() + " says " + s);
// reset the length for the next packet
packet.setLength(buffer.length);
} catch (IOException ex) {
System.err.println(ex);
}
} // end while
} catch (SocketException ex) {
System.err.println(ex); } // end catch
} // end main
}

24. 15 July 2002 © John H. Hine 2002 24
UDP Socket Structure
Client
process
Server
process
server
socket
client
socketresponse
request
host name
port number

25. 15 July 2002 © John H. Hine 2002 25
UDP Steps
Server (on hostId)
Create socket with port = x
Publish “hostId, port=x”
Read request from socket
Write reply to socket
Close socket
Client
Create socket
Create address (hostId, port=x)
Send request on client socket
Read reply from client socket
Close client socket

26. 15 July 2002 © John H. Hine 2002 26
C Client - create a socket
#define DATA "The sea is calm tonight, the tide is full . . .”
main(argc, argv)
int argc;
char *argv[ ];
{
int sock;
struct sockaddr_in name;
struct hostent *hp, *gethostbyname();
/* Create socket on which to send. */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) { perror("opening datagram socket"); exit(1); }
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
Internet socket
UDP (datagram)

27. 15 July 2002 © John H. Hine 2002 27
C Client - Send The Message
hp = gethostbyname(argv[1]);
if (hp == 0) {
fprintf(stderr, "%s: unknown hostn", argv[1]); exit(2);
}
bcopy(hp->h_addr, &name.sin_addr, hp->h_length);
name.sin_family = AF_INET;
name.sin_port = htons(atoi(argv[2]));
/* Send message. */
if (sendto(sock, DATA, sizeof(DATA), 0, &name,
sizeof(name)) < 0)
perror("sending datagram message");
close(sock);
}
server domain name
port number

28. 15 July 2002 © John H. Hine 2002 28
C UDP Server - create socket
main()
{
int sock, length;
struct sockaddr_in name;
char buf[1024];
/* Create socket from which to read. */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
perror("opening datagram socket");
exit(1);
}
Internet socket
UDP (datagram)

29. 15 July 2002 © John H. Hine 2002 29
C UDP Server - bind to port
/* Create name with wildcards. */
name.sin_family = AF_INET;
name.sin_addr.s_addr = INADDR_ANY;
name.sin_port = 0;
if (bind(sock, &name, sizeof(name))) {
perror("binding datagram socket");
exit(1);
}
accept
connections
from
assign
default
port number

30. 15 July 2002 © John H. Hine 2002 30
C UDP Server - Read the data
/* Find assigned port value and print it out. */
length = sizeof(name);
if (getsockname(sock, &name, &length)) {
perror("getting socket name");
exit(1);
}
printf("Socket has port #%den", ntohs(name.sin_port));
/* Read from the socket */
if (read(sock, buf, 1024) < 0)
perror("receiving datagram packet");
printf("-->%sen", buf);
close(sock);
}

31. 17 July 2002 © John H. Hine 2002 31
RPC
interface definition
IDL compiler
client
stub
header
server
stub
client
source
server
source
C compilerC compiler
server stub
object
server
object
C compiler C compiler
client
object
client stub
object
ravg.c avg_proc.c
avg.x
avg_clnt.c
avg.h
avg_svc.c
avg_xdr.c
ravg avg_svc

32. 17 July 2002 © John H. Hine 2002 32
Passing Value Parameters

Steps involved in doing remote computation through RPC
2-8

33. RPC

avg.x --> interface specification
− Setelah di compile pakai rpcgen, menghasilkan
− avg.h, avg_xdr.c, avg_clnt.c, avg_svc.c

avg_proc.c --> procedure di server

ravg.c --> main program di client

Di compile dengan cara:
− Client: cc -o ravg ravg.c avg_xdr.c avg_clnt.c
− ravg
− Server: cc -o avg_svc avg_proc.c avg_xdr.c avg_svc.c
− avg_svc

34. avg.x
const MAXAVGSIZE = 200;
struct input_data {
double input_data<200>;
};
typedef struct input_data input_data;
program AVERAGEPROG {
version AVERAGEVERS {
double AVERAGE(input_data) = 1;
} = 1;
} = 22855;

35. Client: ravg.c
#include "avg.h"
#include <stdlib.h>
void averageprog_1( char* host, int argc, char *argv[]) {
CLIENT *clnt;
double *result_1, *dp, f;
char *endptr;
int i;
input_data average_1_arg;
average_1_arg.input_data.input_data_val =
(double*) malloc(MAXAVGSIZE*sizeof(double));
dp = average_1_arg.input_data.input_data_val;
average_1_arg.input_data.input_data_len =
argc - 2;

36. Client: ravg.c
for (i=1;i<=(argc - 2);i++) {
f = strtod(argv[i+1],&endptr);
printf("value = %en",f);
*dp = f;
dp++;
}
clnt = clnt_create(host, AVERAGEPROG,
argv[0]);
exit(1);
}
if(argc > MAXAVGSIZE + 2) {
printf("Two many input valuesn");
exit(2);

37. Server: avg_proc.c
#include <rpc/rpc.h>
#include "avg.h"
#include <stdio.h>
static double sum_avg;
double * average_1(input_data *input, CLIENT *client) {
double *dp = input->input_data.input_data_val;
u_int i;
sum_avg = 0;
for(i=1;i<=input->input_data.input_data_len;i++) {
sum_avg = sum_avg + *dp; dp++;
}

38. Server: avg_proc.c
sum_avg = sum_avg / input->input_data.input_data_len;
return(&sum_avg);
}
double * average_1_svc(input_data *input, struct svc_req *svc)
{
CLIENT *client;
return(average_1(input,client));
}

39. Running RPC
Menjalankan server:
avg_svc &
menjalankan client:
ravg server 2 3 4 5
hasilnya
value = 2.000000e+00
value = 3.000000e+00
value = 4.000000e+00
value = 5.000000e+00
average = 3.500000e+00
bila berhasil

40. Aplikasi yang menerapkan RPC

NFS (Network File System)

NIS (Network Information System)
− YP (Yellow Pages)

41. Bentuk Komunikasi

Unicast --> TCP
− Satu tujuan

Broadcast --> UDP
− Semua tujuan
− Semua host pada jaringan A, B, dan C akan
menerima

Multicast --> bentuk khusus dari UDP
− Banyak tujuan yang dipilih
− Misal pada jaringan A dipilih 5 dari 20, jaringan B
dipilih 3 dari 10, dan jaringan C dipilih 2 dari 6
− Jumlah hosts dari jaringan A, B, dan C ada 36,
namun yang dipilih hanya 10

42. Multicast socket

Class MulticastSocket merupakan subclass dari
DatagramSocket
public class MulticastSocket extends DatagramSocket

Pemanggilan class tanpa parameter
public MulticastSocket( ) throws SocketException

Pemanggilan class dengan parameter port
public MulticastSocket(int port) throws SocketException

Pemanggilan class dengan parameter SocketAddress
public MulticastSocket(SocketAddress bindAddress) throws
IOException

43. Contoh pemanggilan
try {
MulticastSocket ms = new MulticastSocket( );
// send some datagrams...
}
catch (SocketException se) {
System.err.println(se);
}
try {
MulticastSocket ms = new MulticastSocket(4000);
// receive incoming datagrams...
}
catch (SocketException ex) {
System.err.println(ex);
}

44. Contoh pemanggilan
try {
SocketAddress address = new
InetSocketAddress(4000);
MulticastSocket ms = new MulticastSocket(address);
// receive incoming datagrams...
}
catch (SocketException ex) {
System.err.println(ex);
}

45. Java RMI

Interface --> Fibonacci.java

Class untuk implementasi dari interface
− FibonacciImpl.java

Class untuk register server nya
− FibonacciServer.java

Class untuk client
− FibonacciClient.java

46. Meng compile RMI

Seluruh class di compile dengan cara
javac Fibonacci*.java

Hasil compile dari class Implementasi server
(file .class nya) di compile lagi untuk
menghasilkan skeleton dan stub dengan cara
rmic FibonacciImpl

47. Menjalankan Java RMI

Menjalankan rmiregistry dengan cara
start rmiregistry --> di Windows
atau
rmiregistry & --> di Linux

Menjalankan server dengan cara
java FibonacciServer

Menjalankan client dengan cara
java FibonacciClient rmi://host.com/fibonacci 0 1 2 3 4 5

Hasil outputnya:
The 0th Fibonacci number is 1
The 1th Fibonacci number is 1
The 2th Fibonacci number is 2
The 3th Fibonacci number is 3
The 4th Fibonacci number is 5
The 5th Fibonacci number is 8

48. 
Pemrograman berbasis Socket, aplikasi yang dibuat

langsung menggunakan transport (TCP/UDP) -->

layer 4 = identik dengan low level programming

Pemrograman berbasis RPC/RMI, aplikasi yang

dibuat tidak mengakses langsung ke transport

melainkan melalui perantaraan RPC/RMI (layer 5 dan

6) = midle level programming

Pemrograman berbasis Web, aplikasi di buat di atas

aplikasi Web (layer 7) = high level programming

49. Arsitektur Web
Web Browser Web Server
URL via HTTP
HTML via HTTP
Client Server

50. Web Programming

Program di jalan kan di Web Browser (di Client)
− Dibuat menggunakan bahasa pemrograman
− Java (Applet) atau bahasa scripting Javascript

Program di jalan kan di Web Server (di Server)

51. Client side program

Program diambil dari server bersama-sama
dengan html nya dan di jalan kan di client

Menggunakan Javascript atau Java Applet

52. Server Side Program

Memakai: CGI dengan bahasa apa saja (c++
dan perl/python, ASP, Java Servlet, dan PHP