Substansi:
- Karakteristik dari Aplikasi
- Pemrograman dengan Socket API
- Struktur dan Penanganan Data
- Perubahan variable
- Penanganan alamat IP
- System Call
- Skenario penggunaan pemrograman socket
- Socket lanjutan
- Remote Procedure Call (RPC)
Intro
Layer tertinggi adalah layer aplikasi. Layer ini saling berkomunikasi antar host dan merupakan interface yang tampak oleh user pada protokol TCP/IP.
Application Layer Metamodel
1. Karakteristik dari Aplikasi
Pada layer aplikasi terdapat beberapa karakterisik yang sama yaitu:
1). Merupakan aplikasi yang ditulis oleh user (user-written) atau aplikasi sudah merupakan standar dengan didalamnya sudah terdapat produk TCP/IP. Aplikasi TCP/IP set yang terdapat antara lain :
- TELNET, digunakan untuk mengakses remote host melalui terminal yang interaktif
- FTP (File Transfer Protocol) digunakan untuk transfer file antar disk
- SMTP (Simple Mail Transfer Protocol) digunakan sebagai sistem surat di internet
2). Menggunakan sistem transpor UDP atau TCP
3). Menggunakan model client-server
2. Pemrograman dengan Socket API
Application Programming Interface (API) dapat digunakan oleh user untuk dapat membuat suatu aplikasi. Sedangkan untuk fasilitas jaringannya dapat menggunakan API bagian SOCKET. Dalam bagian ini akan dijelaskan contoh API yang digunakan untuk jaringan.
Pada bab ini dijelaskan bagaimana menggunakan bahasa pemrograman C untuk kepentingan jaringan pada mesin linux.
Contoh kompilasi dan menjalankan program:
#gcc --o program source.c
#./program
3. Struktur dan Penanganan Data
Sebelum menggunakan pemrograman socket diperlukan suatu variable struktur untuk menyimpan informasi tentang jaringan. Struktur yang diperlukan antara lain:
Contoh penggunaannya yaitu:
struct sockaddr {
unsigned short sa_family; // address family, AF_xxx
char sa_data[14]; // 14 bytes of protocol address
};
Dimana, sa_family digunakan untuk penentuan jenis family yang digunakan pada bab ini menggunakan AF_INET artinya menggunakan family INTERNETWORKING. Sedangkan untuk sa_data digunakan untuk informasi tujuan dan port yang digunakan.
Untuk menggunakan struktur tersebut diperlukan 1 lagi struktur yaitu sockadd_in dimana arti "in" adalah internet.
struct sockaddr_in {
short int sin_family; // Address family
unsigned short int sin_port; // Port number
struct in_addr sin_addr; // Internet address
unsigned char sin_zero[8]; // Same size as struct sockaddr
};
Dengan struktur ini maka programmer akan dengan mudah mengontrol data. Pada bagian sin_zero digunakan sebagai pelengkap dimana harus diset dengan nilai 0, hal tersebut dapat digunakan fungsi memset().
Untuk menggunakan alamat IP perlu juga sebuah variabel struktur yaitu struktur in_addr, dimana struktur in_addr adalah sebagai berikut:
// Internet address (a structure for historical reasons)
struct in_addr {
unsigned long s_addr; // that's a 32-bit long, or 4 bytes
};
Sehingga untuk penggunanya dapat dilakukan dengan cara, membuat sebuah variable contoh ina dan bertipe struct sockaddr_in maka ina.sin_addr.s_addr dapat digunakan sebagai objek untuk alamat IP.
4. Perubahan variable
Perubahan awal yang dapat digunakan adalah perubahan dari short (2 byte) menjadi long (4 byte). Kemudian perubahan lainnya adalah perubahan dari host menjadi network. Sehingga masing-masing perubahan bisa disingkat menjadi 1 huruf yaitu , s, l, n, dan h.
Fungsi yang dapat digunakan untuk perubahan tersebut antara lain:
- htons() : perubahan host ke network dengan sistem short
- htonl() : perubahan host ke network dengan sistem long
- ntohs() : perubahan network ke host dengan sistem short
- ntohl() : perubahan network ke host dengan sistem long
5. Penanganan alamat IP
Ada beberapa cara untuk memasukkan alamat IP kedalam suatu variable pada pemrograman socket.
Apabila kita sudah memiliki variable struct sockadd_in ina, dan kita memiliki alamat IP "10.252.102.23". Maka dengan fungsi inet_addr(), akan dapat merubah alamat IP menjadi unsigned long. Contoh penggunaan:
ina.sin_addr.s_addr = inet_addr("10.252.102.23");
Selain itu ada cara yang lainnya, yaitu dengan menggunakan inet_aton:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
Dan contoh penggunaannya adalah sebagai berikut:
struct sockaddr_in my_addr;
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
inet_aton("10.252.102.53", &(my_addr.sin_addr));
memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
Sehingga apabila kita ingin menampilkan isi variabel tersebut dapat dilakukan dengan fungsi tambahan inet_ntoa (network to ascii).
printf("%s", inet_ntoa(ina.sin_addr));
Contoh lengkapnya:
char *a1, *a2;
.
.
a1 = inet_ntoa(ina1.sin_addr); // this is 192.168.4.14
a2 = inet_ntoa(ina2.sin_addr); // this is 10.12.110.57
printf("address 1: %s\n",a1);
printf("address 2: %s\n",a2);
Maka akan menghasilkan
address 1: 10.12.110.57
address 2: 10.12.110.57
6. System Call
System call adalah fungsi-fungsi dalam pemrograman. Fungsi-fungsi tersebut digunakan untuk menjalankan dan mengakses jaringan.
socket()
Penggunaan:
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
Fungsi ini digunakan untuk inisialisasi dalam penggunaan socket. Dimana domain berisikan AF_INET, sedangkat type berisikan SOCK_STREAM atau SOCK_DGRAM dan protocol berisikan angka 0.
SOCK_STREAM digunakan apabila menggunakan protokol TCP dan SOCK_DGRAM digunakan untuk protokol UDP.
Selain isi diatas, masih banyak lagi lainnya dan bisa dilihat pada manual page.
bind()
Penggunaan:
#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
fungsi bind digunakan untuk melakukan asosiasi terhadap alamat IP dan port. Variabel sockfd didapat dari fungsi socket().
Contoh:
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define MYPORT 3490
main()
{
int sockfd;
struct sockaddr_in my_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking!
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = inet_addr("10.12.110.57");
memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
// don't forget your error checking for bind():
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
.
.
.
Apabila ingin menggunakan alamat IP mesin kita, dapat digunakan:
my_addr.sin_port = 0; // choose an unused port at random
my_addr.sin_addr.s_addr = INADDR_ANY; // use my IP address
connect()
Penggunaan:
#include <sys/types.h>
#include <sys/socket.h>
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
Contoh:
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define DEST_IP "10.12.110.57"
#define DEST_PORT 23
main()
{
int sockfd;
struct sockaddr_in dest_addr; // will hold the destination addr
sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking!
dest_addr.sin_family = AF_INET; // host byte order
dest_addr.sin_port = htons(DEST_PORT); // short, network byte order
dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
memset(&(dest_addr.sin_zero), '\0', 8); // zero the rest of the struct
// don't forget to error check the connect()!
connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
.
.
.
listen()
Penggunaan:
int listen(int sockfd, int backlog);
Fungsi dari perintah listen digunakan untuk menunggu koneksi dari suatu host.
accept()
Penggunaan:
#include <sys/socket.h>
int accept(int sockfd, void *addr, int *addrlen);
Fungsi dari accept digunakan setelah fungsi listen. Dimana socket akan meneruskan ke variable socket yang baru setelah suatu host menghubungi. Accept akan membentuk socket baru dan bisa diproses untuk send atau recv.
Contoh:
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define MYPORT 3490 // the port users will be connecting to
#define BACKLOG 10 // how many pending connections queue will hold
main()
{
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // connector's address information
int sin_size;
sockfd = socket(AF_INET, SOCK_STREAM, 0); // do some error checking!
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // auto-fill with my IP
memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
// don't forget your error checking for these calls:
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
listen(sockfd, BACKLOG);
sin_size = sizeof(struct sockaddr_in);
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
.
.
.
send() dan recv()
Penggunaan:
int send(int sockfd, const void *msg, int len, int flags);
int recv(int sockfd, void *buf, int len, unsigned int flags);
Funsi dari send dan recv adalah untuk pertukaran data. Fungsi send() dan recv() digunakan untuk data dengan protokol yang berbasis connection-oriented, sedangkan untuk protokol yang berbasis connectionless-oriented menggunakan sendto() dan recvfrom().
Pointer *msg merupakan isi dari data yang akan dikirim, begitu juga dengan *buf merupakan pointer yang berisi data yang diterima. Variabel len digunakan sebagai panjang data tersebut.
Contoh:
char *msg = "Beej was here!";
int len, bytes_sent;
.
.
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
.
.
.
sendto() dan recvfrom()
Penggunaan:
int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct
sockaddr *to, int tolen);
int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr
*from, int *fromlen);
Fungsi dari sendto dan recvfrom adalah untuk pertukaran data dengan protokol DGRAM. Fungsi tersebut hampir sama dengan fungsi send dan recv dimana terdapat variabel tambahan yaitu struct sockaddr *to, dan int toleni.
close() dan shutdown()
Penggunaan:
close(sockfd);
int shutdown(int sockfd, int how);
Fungsi close() dan shutdown() digunakan untuk menutup koneksi setelah melakukan pertukaran data. Shutdown digunakan apabila diinginkan suatu kondisi tertentu, variabel tersebut ditambahkan pada variable how. Varibel tersebut mempunya nilai dan arti tertentu yaitu:
- 0 -- Setelah ditutup, hanya diperbolehkan menerima
- 1 -- Setelah ditutup, hanya diperbolehkan mengirim
- 2 -- Seteleh ditutup, menerima dan mengirim tidak diperbolehkan (sama dengan close() )
getpeername()
Penggunaan:
#include <sys/socket.h>
int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);
Fungsi getpeername() digunakan untuk mengetahui informasi tentang tujuan.
gethostname()
Penggunaan:
#include <unistd.h>
int gethostname(char *hostname, size_t size);
Fungsi gethostname() digunakan untuk mengetahui informasi tentang mesin jaringan kita.
DNS -- Mengirim ke "whitehouse.gov", Dijawab "198.137.240.92"
Penggunaan:
#include <netdb.h>
struct hostent *gethostbyname(const char *name);
Struktur hostent memiliki objek didalam antara lain:
struct hostent {
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
};
#define h_addr h_addr_list[0]
Dimana:
- h_name -- nama resmi dari suatu host
- h_aliases -- NULL , nama alternatif dari suatu host
- h_addrtype -- type dari alamat, contoh AF_INET
- h_length -- panjang dari data alamat IP
- h_addr_list -- ZERO, sekumpulan IP dengan nama tersebut
- h_addr -- alamat pertama dari h_addr_list
Untuk mendapatkan hasil dari struktur hostent digunakan fungsi gethostbyname(). Cara penggunaan dapat dilihat pada contoh program.
Contoh program:
/*
** getip.c - a hostname lookup demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(int argc, char *argv[])
{
struct hostent *h;
if (argc != 2) { // error check the command line
fprintf(stderr,"usage: getip address\n");
exit(1);
}
if ((h=gethostbyname(argv[1])) == NULL) { // get the host info
herror("gethostbyname");
exit(1);
}
printf("Host name : %s\n", h->h_name);
printf("IP Address : %s\n", inet_ntoa(*((struct in_addr *)h->h_addr)));
return 0;
}
7. Skenario penggunaan pemrograman socket
Pemrograman socket menggunakan sistem client-server, dimana proses client berbicara dengan proses server dan sebaliknya. Contoh, client dengan aplikasi telnet akan menghubungi server yang menjalankan aplikasi telnetd.
Client-Server
Diagram alir yang digunakan tampak pada
Diagram Alir Program Berbasis Connection-oriented
Diagram Alir Program Berbasis Connectionless-oriented
Contoh Server Berbasis STREAM
/*
** server.c - a stream socket server demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#define MYPORT 3490 // the port users will be connecting to
#define BACKLOG 10 // how many pending connections queue will hold
void sigchld_handler(int s)
{
while(wait(NULL) > 0);
}
int main(void)
{
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // connector's address information
int sin_size;
struct sigaction sa;
int yes=1;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
if (setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))== -1)
{
perror("bind");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
while(1) { // main accept() loop
sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr,
&sin_size)) == -1) {
perror("accept");
continue;
}
printf("server: got connection from %s\n",
inet_ntoa(their_addr.sin_addr));
if (!fork()) { // this is the child process
close(sockfd); // child doesn't need the listener
if (send(new_fd, "Hello, world!\n", 14, 0) == -1)
perror("send");
close(new_fd);
exit(0);
}
close(new_fd); // parent doesn't need this
}
return 0;
}
Untuk mencoba program server tersebut jalankan: #telnet server 3490
Contoh Client Berbasis STREAM
/*
** client.c - a stream socket client demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 3490 // the port client will be connecting to
#define MAXDATASIZE 100 // max number of bytes we can get at once
int main(int argc, char *argv[])
{
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr; // connector's address information
if (argc != 2) {
fprintf(stderr,"usage: client hostname\n");
exit(1);
}
if ((he=gethostbyname(argv[1])) == NULL) { // get the host info
perror("gethostbyname");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
their_addr.sin_family = AF_INET; // host byte order
their_addr.sin_port = htons(PORT); // short, network byte order
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), '\0', 8); // zero the rest of the struct
if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct sockaddr))
== -1) {
perror("connect");
exit(1);
}
if ((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
perror("recv");
exit(1);
}
buf[numbytes] = '\0';
printf("Received: %s",buf);
close(sockfd);
return 0;
}
Program ini mencari server dengan port 3490 dan menerima string dari server dan menampilkan ke layar.
Socket dengan DATAGRAM
Program listener akan bersiap pada sebuah mesin dan akan menunggu paket yang menuju ke port 4950. Program talker akan mengirim paket menuju ke port tersebut.
Listing program listernet :
/*
** listener.c - a datagram sockets "server" demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MYPORT 4950 // the port users will be connecting to
#define MAXBUFLEN 100
int main(void)
{
int sockfd;
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // connector's address information
int addr_len, numbytes;
char buf[MAXBUFLEN];
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("socket");
exit(1);
}
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
if (bind(sockfd, (struct sockaddr *)&my_addr,sizeof(struct sockaddr)) == -1)
{ perror("bind");
exit(1);
}
addr_len = sizeof(struct sockaddr);
if ((numbytes=recvfrom(sockfd,buf, MAXBUFLEN-1, 0,(struct sockaddr
*)&their_addr, &addr_len)) == -1) {
perror("recvfrom");
exit(1);
}
printf("got packet from %s\n",inet_ntoa(their_addr.sin_addr));
printf("packet is %d bytes long\n",numbytes);
buf[numbytes] = '\0';
printf("packet contains \"%s\"\n",buf);
close(sockfd);
return 0;
}
Listing program talker:
/*
** talker.c - a datagram "client" demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define MYPORT 4950 // the port users will be connecting to
int main(int argc, char *argv[])
{
int sockfd;
struct sockaddr_in their_addr; // connector's address information
struct hostent *he;
int numbytes;
if (argc != 3) {
fprintf(stderr,"usage: talker hostname message\n");
exit(1);
}
if ((he=gethostbyname(argv[1])) == NULL) { // get the host info
perror("gethostbyname");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("socket");
exit(1);
}
their_addr.sin_family = AF_INET; // host byte order
their_addr.sin_port = htons(MYPORT); // short, network byte order
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), '\0', 8); // zero the rest of the struct
if ((numbytes=sendto(sockfd, argv[2], strlen(argv[2]), 0,(struct sockaddr
*)&their_addr, sizeof(struct sockaddr))) == -1) {
perror("sendto");
exit(1);
}
printf("sent %d bytes to %s\n", numbytes,
inet_ntoa(their_addr.sin_addr));
close(sockfd);
return 0;
}
8. Socket lanjutan
Pada bagian ini dijelaskan tentang penggunaan beberapa fungsi yang dapat mendukung kerja dari program jaringan menggunakan pemrograman socket.
Blocking
Suatu aplikasi server dapat menerima paket data secara bersamaan, untuk itu perlu dilakukan pelepasan suatu pembatas atau yang disebut non-blocking. Sehingga server bisa menerima data secara bersamaan.
Pada initialisasi socket(), socket secara awal memiliki nilai awal blocking. Untuk membuat mejadi bersifat non-blocking dilakukan dengan cara memanggil fungsi fcntl(). Hal ini dapat dilihat pada contoh berikut :
#include <unistd.h>
#include <fcntl.h>
.
.
sockfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(sockfd, F_SETFL, O_NONBLOCK);
.
.
select() -- Synchronous I/O Multiplexing
Dengan fungsi select, aplikasi akan dapat memilah dan memroses data pada waktu yang bersamaan. Contoh penggunaan select()
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct
timeval *timeout);
Untuk memperjelas berikut adalah contoh program dimana akan menunggu dalam 2.5 detik apakah ada data yang masuk dari inputan keyboard.
/*
** select.c - a select() demo
*/
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#define STDIN 0 // file descriptor for standard input
int main(void)
{
struct timeval tv;
fd_set readfds;
tv.tv_sec = 2;
tv.tv_usec = 500000;
FD_ZERO(&readfds);
FD_SET(STDIN, &readfds);
// don't care about writefds and exceptfds:
select(STDIN+1, &readfds, NULL, NULL, &tv);
if (FD_ISSET(STDIN, &readfds))
printf("A key was pressed!\n");
else
printf("Timed out.\n");
return 0;
}
Contoh penggunaan select() pada alikasi multiperson chat server
/*
** selectserver.c - a cheezy multiperson chat server
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define PORT 9034 // port we're listening on
int main(void)
{
fd_set master; // master file descriptor list
fd_set read_fds; // temp file descriptor list for select()
struct sockaddr_in myaddr; // server address
struct sockaddr_in remoteaddr; // client address
int fdmax; // maximum file descriptor number
int listener; // listening socket descriptor
int newfd; // newly accept()ed socket descriptor
char buf[256]; // buffer for client data
int nbytes;
int yes=1; // for setsockopt() SO_REUSEADDR, below
int addrlen;
int i, j;
FD_ZERO(&master); // clear the master and temp sets
FD_ZERO(&read_fds);
// get the listener
if ((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
// lose the pesky "address already in use" error message
if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
// bind
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = INADDR_ANY;
myaddr.sin_port = htons(PORT);
memset(&(myaddr.sin_zero), '\0', 8);
if (bind(listener, (struct sockaddr *)&myaddr, sizeof(myaddr)) == -1) {
perror("bind");
exit(1);
}9\.
// listen
if (listen(listener, 10) == -1) {
perror("listen");
exit(1);
}
// add the listener to the master set
FD_SET(listener, &master);
// keep track of the biggest file descriptor
fdmax = listener; // so far, it's this one
// main loop
for(;;) {
read_fds = master; // copy it
if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
perror("select");
exit(1);
}
// run through the existing connections looking for data to read
for(i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &read_fds)) {
// we got one!!
if (i == listener) {
// handle new connections
addrlen = sizeof(remoteaddr);
if ((newfd = accept(listener, (struct sockaddr *)&remoteaddr, &addrlen))
== -1) {
perror("accept");
} else {
FD_SET(newfd, &master); // add to master set
if (newfd > fdmax) { // keep track of the maximum
fdmax = newfd;
}
printf("selectserver: new connection from %s on socket %d\n",
inet_ntoa(remoteaddr.sin_addr), newfd);
}
} else {
// handle data from a client
if ((nbytes = recv(i, buf, sizeof(buf), 0)) <= 0) {
// got error or connection closed by client
if (nbytes == 0) {
// connection closed
printf("selectserver: socket %d hung up\n", i);
} else {
perror("recv");
}
close(i); // bye!
FD_CLR(i, &master); // remove from master set
} else {
// we got some data from a client
for(j = 0; j <= fdmax; j++) {
// send to everyone!
if (FD_ISSET(j, &master)) {
// except the listener and ourselves
if (j != listener && j != i) {
if (send(j, buf, nbytes, 0) == -1) {
perror("send");
}
}
}
}
}
} // it's SO UGLY!
}
}
}
return 0;
}
9. Remote Procedure Call (RPC)
RPC adalah suatu protokol yang memperbolehkan suatu program komputer yang memberikan suatu subroutin kepada komputer yang lain untuk menjalankan suatu perintah tanpa melalui programmner membuat program terlebih dahulu.
