Pengenalan Socket Programming





Harga Handphone, Harga Blackberry, Harga Laptop, Harga Mobil, Harga Motor

DAPATKAN BUKU GRATIS DARI BUKUKITA.COM, CARANYA KLIK DISINI!!!

Di tempat-tempat lain sudah sangat banyak artikel tentang socket programming ini.
Tapi nggak apa-apa ya, kita review lagi. Sebelumnya artikel ini bagi pengguna GNU/Linux. Mungkin teman-teman yang belum tahu akan bertanya-tanya apa sih socket programming itu?, apakah pemrograman processor (socket selama ini bagi kita identik dengan processor)?. Tapi yang saya maksudkan disini bukan socket processor, melainkan socket pada pemrograman jaringan.
Pada dasarnya socket adalah sebuah cara untuk berkomunikasi dengan program atau node lain menggunakan file deskriptor. Di UNIX (dimana socket diciptkan) kita sering mendengar slogan: “everything is a file”, jadi untuk berkomunikasi dengan program atau node lain semudah kita membaca dan menulis file deskriptor. Antarmuka socket dan file adalah mirip, jika pada file kita membukanya dengan open() sedangkan pada socket kita manggunakan socket(). Pada file deskriptor yang menjadi tujuan adalah sebuah file, sedangkan pada socket adalah komputer atau node lain. Intinya ketika kita telah terhubung dengan socket(), maka antarmukanya sama saja dengan sebuah file.

Socket Stream dan Datagram
————————–
Pada umumnya socket ada dua macam yang sering dipakai (sebenarnya ada 4 lagi). Yang pertama disebut ‘Socket Stream’ (SOCK_STREAM) dan yang kedua adalah ‘Socket Datagram’ (SOCK_DGRAM). Lalu apa perbedaanya?, (Ini sepengatahuan saya :) untuk Socket Stream, data dikomunikasikan (dikirmkan) secara simultan, Socket Stream menggunakan protokol TCP. Seperti yang kita tahu TCP mengantar data secara simultan, selalu mencek dan mengirim ulang jika terjadi error.
Sedangkan pada Socket Datagram (juga dikenal “connectionless socket”), data mencapai/sampai ke node lain tanpa membuat koneksi, sehingga dalam perjalanan ke tujuan data dapat saja hilang karena tidak ada koneksi langsung antara kedua host, jika datanya sampai ke tujuan berarti ‘error-free’. Biasanya Socket Datagram digunakan dalam pengiriman data per packet, contoh FTP. Sederhananya socket jenis ini hanya ‘memancarkan’ saja, tidak untuk berinteraksi.
oh iya pada program di artikel ini kita gunakan Socket Stream.

Tipe-tipe data yang diperlukan
——————————
0. Untuk peng-handle socket selama koneksi (socket deskriptor), gunakan variabel yang bertipe int.
1. Untuk pengalamatan digunakan variabel yang bertipe sockaddr_in.
Berikut ini deskripsi tipe sockaddr_in :

struct sockaddr_in {
sa_family_t sin_family; /* short int */
u_int16_t sin_port; /* port number */
struct in_addr sin_addr; /* internet address */
};

Keterangan:
– sin_family dapat berupa AF_INET.
– sin_port adalah nomor port.
– sin_addr alamat host.
berikut deskripsi struct in_addr:
struct in_addr {
u_int32_t s_addr; /* panjang 32 bit */
};

3. Untuk mendapatkan alamat dari nama host yang diberikan, gunakan variabel bertipe hostent, biasanya digunakan pada pihak client.
Berikut ini deskripsi tipe hostent:
struct hostent {
char *h_name; /* official name of host */
char **h_aliases; /* alias list */
int h_addrtype; /* host address type */
int h_length; /* length of address */
char **h_addr_list; /* list of addresses */
}
#define h_addr h_addr_list[0] /* for backward compatibility */

Fungsi-fungsi yang sering digunakan
———————————–
0. socket(), membuat socket.
1. htonl(), meng-convert unsigned integer ke network byte order.
2. inet_ntoa(), ntoa singkatan ‘network to ascii’,
nilai return-nya berupa string dari alamat yang dilewatkan.
3. inet_addr(), meng-convert string menjadi network byte order.
4. bind(), digunakan pada pihak server, untuk membuka ‘port’ komunikasi.
5. write(), send(), bertugas mengirimkan data.
6. read(), recv(), bertugas menerima data.
7. connect(), digunakan pada pihak client, untuk mengadakan koneksi ke server.
8. listen(), menunggu koneksi socket.
9. accept(), menerima koneksi socket.
10.close(), shutdown() menutup atau mengakhiri koneksi.

untuk lebih jelasnya lihat man page dari masing-masing fungsi.

Baiklah kita langsung ke coding-nya saja ya … :)

Server
——

Skema untuk server :

1. Pasang socket dengan socket().
2. Buka port komunikasi, dengan bind ().
3. Dengarkan socket dengan listen().
4. Dalam looping, terima hubungan client dengan accept().
5. Buat child dari program dengan fork() agar dapat melayani banyak client sekaligus.
masing-masing child akan melayani satu client.
6. Kirim pesan dengan send().
7. Tutup socket dengan close() atau shutdown().
8. Akhiri child process dengan exit().

/* serverteman.c */

#include
#include
#include
#include
#include
#include

#include

#define KONEKSI_MAKSIMAL 10

int main (int argc, char *argv[])
{
struct sockaddr_in alamat_serv;
struct sockaddr_in alamat_clie;
unsigned no_port;
int socketfd;

if (argc != 2) {
fprintf (stderr, “gunakan: %s n”, argv[0]);
exit(1);
}

no_port = atoi (argv[1]);

socketfd = socket (AF_INET, SOCK_STREAM, 0);

/* untuk membersihkan child process,
yang telah selesai */
signal(SIGCHLD, SIG_IGN);

/* kita reset terlebih dahulu variable alamat_serv */
bzero (&alamat_serv, sizeof(alamat_serv));
alamat_serv.sin_family = AF_INET;
alamat_serv.sin_port = htons (no_port);
/* macro INADDR_ANY menghasilkan current ip */
alamat_serv.sin_addr.s_addr = htonl (INADDR_ANY);

/* buka port */
if (bind (socketfd, (struct sockaddr *)&alamat_serv, sizeof (struct sockaddr)) < 0) {
fprintf (stderr, "maaf ya, tidak bisa memasang port !n");
exit(1);
}

printf ("serverteman menunggu teman datang ...n");

/* menuggu koneksi yang masuk,
* koneksi maksimal dilayani sebanyak KONEKSI_MAKSIMAL
*/
listen (socketfd, KONEKSI_MAKSIMAL);

while(1) {
int client_size = sizeof (struct sockaddr_in);
int newfd;

/* menerima koneksi yang datang */
newfd =accept (socketfd, (struct sockaddr *)&alamat_clie, &client_size);
if(newfd == -1) {
perror ("accept");
/* jika terjadi error akan looping lagi */
continue;
}

/* mengetahui siapa yang mengadakan koneksi */
printf("Teman dari %s telah datangn", inet_ntoa (alamat_clie.sin_addr));

/* fork mengasilkan nilai return 0 pada child process,
pada parent process, fork() menghasilkan nilai pid dari child yang diciptakan*/

if (!fork ()) {
/* child process */

/* peringatan !, variabel buffer hanya menampung 255 karakter */
char buffer[256];

sprintf (buffer, "Halo Teman, selamat datang di Server.Temann");

/* kirim pesan */
if (send (newfd, buffer, strlen (buffer), 0) == -1) {
perror ("send");
continue;
}
close (newfd);
exit (0);
}
else
/* parent process,
disini tidak dibutuhkan newfd, jadi sebaiknya ditutup.
parent process akan looping lagi untuk menerima client yang lain*/
close (newfd);
}

return 0;
}

/* serverteman.c */

ok sekarang kita compile:
gcc -o serverteman serverteman.c

lalu jalankan:
./serverteman 1024

mudah-mudahan serverteman sudah jalan.

catatan: untuk menjalankannya, jika anda bukan root port yang bisa 'buka' adalah >= 1024.

nah jika teman-teman mau mencoba ‘layanan’ serverteman, karena kita belum membuat program client-nya, telnet dapat kita gunakan.

telnet 127.0.0.1 1024

coba lihat pada terminal yang menjalankan client,

Trying 127.0.0.1…
Connected to 127.0.0.1.
Escape character is ‘^]’.
Halo Teman, selamat datang di Server.Teman
Connection closed by foreign host.

lalu coba lihat pada terminal yang menjalankan serverteman,

Teman dari 127.0.0.1 telah datang

baiklah sekarang kita buat program client-nya .

Skema client
————
skema client lebih sederhana dari server.

1. pasang dengan socket().
2. dapatkan alamat server dengan gethostbyname().
3. terima seluruh data yang dikirmkan dalam looping dengan recv().
4. tutup koneksi dengan close().

/* clienteman.c */

#include
#include
#include
#include
#include
#include

#include
#include

int main (int argc, char *argv[])
{
struct sockaddr_in alamat_ku;
struct sockaddr_in tujuan;
struct hostent *host_server;
int socketfd, connect_status, baca;
int no_port;
char buffer[256];

if (argc != 3) {
fprintf (stderr, “gunakan: %s n”, argv[0]);
exit(1);
}

if ((socketfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
fprintf (stderr, "tidak bisa memasang socket !n");
exit(1);
}

if ((host_server = gethostbyname(argv[1])) == NULL) {
fprintf (stderr, "Nama host mungkin salah :)n");
exit(1);
}
no_port = atoi(argv[2]);

bzero (&tujuan, sizeof(tujuan));
tujuan.sin_family = AF_INET;
tujuan.sin_port = htons (no_port);
memcpy ((char *)&tujuan.sin_addr.s_addr, host_server->h_addr_list[0], host_server->h_length);

if ((connect_status = connect (socketfd, (struct sockaddr *)&tujuan, sizeof(tujuan))) < 0) {
fprintf(stderr, "%s: tidak dapat melakukan koneksin", argv[0]);
exit(1);
}

while((baca = recv(socketfd, buffer, strlen(buffer), 0)) > 0) {
printf(“%s”, buffer);
}

close (socketfd);
return 0;
}

/* clienteman.c */

lalu kita compile:
gcc -o clienteman clienteman.c

jalankan:
./clienteman 127.0.0.1 1024

nomor ip dan port sesuaikan dengan server tujuan.

nah artikel-nya sampe disini dulu.
jika teman-teman ingin belajar lebih jauh tentang socket programming,
ada banyak sekali artikel lain tentang socket programming, coba cari di search engine.
oh iya saya punya informasi tentang buku yang bagus sekali, tapi sebelumnya saya minta maaf ini bukannya mau pasang iklan :).
Judul bukunya kalo nggak salah “UNIX Network Programming” karangan Stevens W Richard penerbitnya prentice-hall.
he..he.. kalo sudah punya boleh pinjem nggak buat foto copy?, ya syukur-syukur ada yang mau buat pdf-nya buat kemajuan bersama.

saya minta maaf ya jika ada yang salah dan kurang jelas.
semoga bermanfaat ;)

Bagaimana Ramalan Harian, Ramalan Zodiak Harian, Ramalan Mingguan, Zodiak Mingguan, Ramalan Zodiak Mingguan Anda?

Cek Harga HANDPHONE, MOTOR dan Harga Lainnya di www.harganya.com!

Facebook

Twitter