Membangun Model Client-Server
Pemrograman soket adalah proses membangun saluran komunikasi antara server dan klien menggunakan soket. Dalam contoh kode berikut, klien memulai kontak dengan server, dan server diatur untuk menerima koneksi klien. Mari kita memahami segmen kode server dan klien dengan menunjukkan inti kerja mereka dalam komunikasi jaringan. Berikut ini adalah kode sisi server. Mari kita lihat kodenya terlebih dahulu, lalu jelaskan kodenya secara detail poin demi poin.
1. Sisi Server
Kode untuk sisi server model diberikan berikut ini. Mari kita lihat apa yang terjadi pada kode:
#termasuk
#termasuk
#termasuk
#termasuk
menggunakan ruang nama std ;
#tentukan PORT 8080
#tentukan MAX_BUF_SIZE 1024
ke dalam utama ( ) {
ke dalam ser_socket, cli_socket ;
struktur sockaddr_in ser_address, cli_address ;
arang penggemar [ MAX_BUF_SIZE ] = { 0 } ;
jika ( ( ser_socket = stopkontak ( AF_INET, SOCK_STREAM, 0 ) ) == - 1 ) {
kesalahan ( 'Kesalahan dalam pembuatan Socket' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
alamat_ser. dosa_keluarga = OF_INET ;
alamat_ser. sin_addr . s_addr = INADDR_APA PUN ;
alamat_ser. dosa_port = htons ( PELABUHAN ) ;
jika ( mengikat ( menjadi_socket, ( struktur sockaddr * ) & alamat_ser, ukuran dari ( alamat_ser ) ) == - 1 ) {
kesalahan ( 'Kegagalan dalam pengikatan' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
jika ( mendengarkan ( menjadi_socket, 3 ) == - 1 ) {
kesalahan ( 'Gagal Mendengarkan' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
cout << 'Server mendengarkan di port' << PELABUHAN << '... \N ' ;
socklen_t cli_address_len = ukuran dari ( alamat_kli ) ;
jika ( ( klik_socket = menerima ( menjadi_socket, ( struktur sockaddr * ) & alamat_kli, & cli_address_len ) ) == - 1 ) {
kesalahan ( 'Gagal menerima' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
membaca ( cli_socket, buf, MAX_BUF_SIZE ) ;
cout << 'Pesan klien adalah:' << penggemar << akhir ;
mengirim ( klik_socket, 'Pesan server' , strlen ( 'Pesan server' ) , 0 ) ;
menutup ( klik_socket ) ;
menutup ( ser_socket ) ;
kembali 0 ;
}
Contoh yang diberikan adalah kode sisi server dari program C++. Kode ini berfungsi untuk server TCP sederhana untuk mendengarkan koneksi pada satu port tertentu. Ketika koneksi berhasil dibuat, server akan menerima pesan yang dikirimkan dari klien. Setelah itu, ia mencetaknya di konsol dan mengirimkan pesan respons ke klien. Mari kita pahami setiap baris kode.
Program dimulai dengan menyertakan perpustakaan: “iostream” untuk definisi input/output standar, “cstring” untuk fungsi penanganan string, “unistd.h” untuk menyediakan akses ke API sistem operasi POSIX, dan “arpa/inet.h” untuk melakukan operasi internet. Pernyataan “#define PORT 8080” berarti menyatakan nomor port 8080 yang akan didengarkan oleh server. Tanda “#define MAX_BUF_SIZE 1024” berarti ukuran buffer maksimum untuk data yang masuk yaitu 1024.
Dalam fungsi utama, dua variabel diinisialisasi, “ser_socket” dan “cli_socket”, untuk masing-masing mewakili server dan klien. Tiga variabel lainnya yaitu “sockaddr_in”, “ser_address”, dan “cli_address” bertipe “struct” diinisialisasi sebagai struktur alamat untuk server dan klien. Setelah itu, buffer bernama “buf” diinisialisasi yang menyimpan data yang berasal dari klien.
Fungsi socket() dalam kondisi “if” membuat soket TCP baru. AF_INET menunjukkan IPv4, SOCK_STREAM mewakili soket TCP yang berorientasi koneksi dan andal, argumen terakhir yaitu 0 diberikan untuk memilih protokol TCP default, INADDR_ANY menerima koneksi pada alamat IP mana pun, dan htons (PORT) mengubah nomor port dari urutan byte host ke urutan byte jaringan.
Karena semuanya sudah didefinisikan dengan benar, langkah selanjutnya adalah mengatur server sebagai lister pada port tertentu dan menerima koneksi pada antarmuka jaringan apa pun. Soket diberikan dengan informasi di “ser_address” dengan metode bind(). Kami mencetak kesalahan dan mengakhiri proses jika pengikatan gagal. Fungsi terima() membuka soket baru untuk koneksi dengan klien, sedangkan fungsi mendengarkan() memerintahkan server untuk menunggu koneksi masuk. Jika fungsi terima() gagal, pesan kesalahan akan dicetak dan fungsi akan keluar.
Selanjutnya, server membaca pesan klien dengan fungsi read() ke dalam buffer “buf” dan kemudian mencetaknya ke konsol. Fungsi send() digunakan oleh server untuk mengirim pesan sebagai respons ke klien. Terakhir, dengan menggunakan close(), server menutup soket klien, menghentikan program sehingga semua koneksi ditutup dengan benar dan tidak ada kemungkinan pelanggaran data.
2. Sisi Klien
Sekarang, mari kita lihat apa yang terjadi pada model klien:
#termasuk#termasuk
#termasuk
#termasuk
#tentukan PORT 8080
#tentukan SERVER_IP '127.0.0.1'
ke dalam utama ( ) {
ke dalam klik_socket ;
struktur sockaddr_in ser_address ;
konstanta arang * pesan = 'Klien mengirimkan salam!' ;
jika ( ( klik_socket = stopkontak ( AF_INET, SOCK_STREAM, 0 ) ) == - 1 ) {
kesalahan ( 'Kesalahan dalam pembuatan soket' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
alamat_ser. dosa_keluarga = OF_INET ;
alamat_ser. dosa_port = htons ( PELABUHAN ) ;
jika ( inet_pton ( AF_INET, SERVER_IP, & alamat_ser. sin_addr ) <= 0 ) {
kesalahan ( 'Salah alamat' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
jika ( Menghubung ( klik_socket, ( struktur sockaddr * ) & alamat_ser, ukuran dari ( alamat_ser ) ) == - 1 ) {
kesalahan ( 'Koneksi Bermasalah' ) ;
KELUAR ( EXIT_FAILURE ) ;
}
mengirim ( cli_socket, pesan, strlen ( pesan ) , 0 ) ;
arang penggemar [ 1024 ] = { 0 } ;
membaca ( cli_socket, buf, ukuran dari ( penggemar ) ) ;
std :: cout << 'Respon server:' << penggemar << std :: akhir ;
menutup ( klik_socket ) ;
kembali 0 ;
}
Mari kita lihat setiap baris kode untuk memahami cara kerja program.
Empat perpustakaan yang sama – iostream, cstring, unistd.h, dan arpa/inet.h – juga disertakan di sisi klien. Nomor port juga ditentukan bersama dengan alamat IP host lokal 127.0.0.1. Pesan yang harus dikirim ke server diberikan. Klien dan server perlu membuat koneksi sebagai langkah berikut:
“jika ((client_socket = soket(AF_INET, SOCK_STREAM, 0)) == -1);” membuat soket untuk IPv4 dengan tipe aliran dan protokol default TCP. Perror() mencetak detail kesalahan jika fungsi socket() gagal membuat koneksi dan keluar dari program.
“server_address.sin_port = htons(PORT);” menetapkan nomor port setelah mengonversi ke urutan byte jaringan. Setelah itu, pesan kegagalan lainnya yaitu “Alamat salah” diberikan di sini yang dicetak jika ada yang salah dengan alamat tersebut. Dengan menemukan alamat di “ser_address”, klien akan terhubung ke server. Jika koneksi gagal, rincian kesalahan akan dicetak. Fungsi send() akan mentransfer pesan ke server, memastikan bahwa pesan tersebut tidak mengandung tanda apa pun.
Untuk menerima dan menyimpan respons dari server, buffer bernama “buf” dengan tipe “char” diinisialisasi. Fungsi read() membaca respon server ke dalam buffer. Terakhir, respons server dicetak ke konsol. Terakhir, koneksi ditutup menggunakan pernyataan close() untuk mengakhiri soket. Berikut output programnya:
Kesimpulan
Pemrograman soket adalah bagian penting dari komunikasi jaringan dalam ilmu komputer. Hal ini memungkinkan pengembangan aplikasi yang dapat berkomunikasi melalui jaringan, memungkinkan berbagai kemungkinan dari arsitektur client-server sederhana hingga sistem terdistribusi terstruktur. Ketika soket dibuat dalam konteks pemrograman, program harus mengkonfigurasi karakteristik titik akhirnya seperti protokol, TCP atau UDP, dan alamat jaringan seperti alamat IP dan nomor port. Soket ini memungkinkan server mengirim dan menerima data. Artikel ini menunjukkan contoh praktis tentang cara kerja model klien-server dalam pemrograman soket.