Anda di halaman 1dari 25

CHAPTER 17

Pengenalan Layer Aplikasi


Bab ini adalah bab pengenalan layer aplikasi. Pada delapan bab setelah
ini kita akan mengenal aplikasi client-server yang biasa digunakan dalam
internet. Pada bab ini, kita akan memberi gambaran umum bagaimana sebuah
program client-server di desain dan memberikan beberapa code yang simple
dari pelaksanaannya. Area dari network programming sangat cepat dan rumit,
semua itu tidak bisa digabungkan dalam satu bab. Kita perlu untuk melihat
dengan tajam seperti mata burung dan disiplin untuk membuat konten dari
delapan bab setelahnya menjadi mudah untuk dimengerti.

SASARAN
Bab ini memiliki beberapa sasaran :

Untuk memperkenalkan model client-server.


Untuk memperkenalkan socket interfaces dan daftar beberapa fungsi yang umum dalam
interface ini.
Untuk mendiskusikan komunikasi client-server menggunakan connectionless iterative
yang ditawarkan oleh UDP.
Untuk memberi sebuah contoh dari sebuah client program menggunakan UDP.
Untuk memberi sebuah contoh dari sebuah server program menggunakan UDP.
Untuk memberi sebuah contoh dari sebuah client program menggunakan TCP.
Untuk memberi sebuah contoh dari sebuah server program menggunakan TCP.
Untuk mendiskusikan dengan singkat pola peer-to-peer dan penggunaannya.

17.1 Model Client-Server


Tujuan dari sebuah jaringan, atau sebuah internetwork adalah untuk menyediakan layanan
kepada pengguna (user): seorang user di suatu daerah ingin menerima layanan dari komputer
di tempat terpencil. Salah satu cara untuk mencapai tujuan ini adalah untuk menjalankan dua
program. Komputer lokal menjalankan sebuah program untuk meminta sebuah layanan dari
remote computer. Ini artinya ada dua komputer yang terhubung dengan internet, masingmasing harus menjalankan program, satu untuk menyediakan layanan dan satunya lagi
meminta layanan.
Sekilas pandang, itu terlihat simple untuk membolehkan komunikasi antara dua
program aplikasi, satu berjalan di local site, yang lain berjalan di remote site. Tapi banyak
pertanyaan muncul ketika kita ingin untuk melaksanakan pendekatan. Beberapa pertanyaan
yang mungkin kita tanyakan adalah:
1. Bisakah kedua program aplikasi digunakan untuk meminta layanan dan menyediakan
layanan atau bisakah program aplikasi hanya melakukan satu atau yang lainnya? Satu
solusi adalah mempunyai sebuah program aplikasi yang disebut client, berjalan di
local mesin, meminta sebuah layanan dari program alikasi lain, yang disebut server
dan menyediakan layanan yang terpisah satu sama lain. Salah satu program aplikasi
adalah peminta (client) atau penyadia (server). Dengan kata lain, program aplikasi
menjadi sepasang, client dan server keduanya mempunyai nama yang sama.
2. Haruskah server menyediakan layanan hanya untuk satu klien tertentu atau harus
server menjadi mampu memberikan layanan kepada setiap klien yang meminta jenis
layanan yang disediakan? Solusi yang paling umum adalah server yang menyediakan
layanan untuk setiap klien yang membutuhkan jenis layanan, bukan satu tertentu .
Dengan kata lain, hubungan server-client adalah satu - ke-banyak .
3. Haruskah komputer hanya menjalankan satu program ( client atau server ) ? Solusinya
adalah bahwa setiap komputer yang terhubung ke Internet harus mampu menjalankan
program klien apapun jika perangkat lunak yang bersangkutan tersedia . Program
server yang perlu dijalankan pada komputer yang dapat terus berjalan seperti yang
akan kita lihat nanti .
4. Kapan program aplikasi akan berjalan? Sepanjang waktu atau hanya saat ada
kebutuhan untuk layanan ini? Umumnya, sebuah program klien yang meminta
layanan, harus dijalankan hanya bila diperlukan. Program server, yang menyediakan
layanan, harus menjalankan sepanjang waktu karena tidak tahu kapan layanan akan
dibutuhkan .
5. Harus hanya ada satu program aplikasi universal yang dapat memberikan jenis
layanan pengguna? Atau harus ada satu program aplikasi untuk setiap jenis layanan?
Dalam TCP / IP, layanan yang dibutuhkan sering dan oleh banyak pengguna memiliki
spesifik program aplikasi client-server. Sebagai contoh, kita memiliki client - server
terpisah program aplikasi yang memungkinkan pengguna untuk mengakses file,
mengirim e -mail, dan sebagainya. Untuk layanan yang lebih disesuaikan, kita harus
memiliki satu aplikasi generik program yang memungkinkan pengguna untuk
mengakses layanan yang tersedia pada remote komputer. Sebagai contoh, kita harus
memiliki program aplikasi client-server yang memungkinkan pengguna untuk login
ke komputer remote dan kemudian menggunakan layanan yang diberikan oleh yang
komputer.

Server
Server adalah sebuah program yang berjalan pada mesin remote yang menyediakan layanan
kepada klien. Ketika mulai, ini akan membuka pintu untuk permintaan masuk dari klien, tapi
tidak pernah memulai layanan sampai diminta untuk melakukannya. Sebuah program server
adalah sebuah program yang tak terbatas. Ketika mulai, itu berjalan jauh kecuali masalah
muncul. Ini menunggu permintaan masuk dari klien. Ketika permintaan datang, hal itu akan
menanggapi permintaan tersebut, baik iteratif atau bersamaan seperti yang akan kita lihat
segera.
Klien
Seorang klien adalah program yang berjalan pada layanan mesin lokal yang meminta dari
server. Sebuah program klien terbatas, yang berarti dimulai oleh pengguna ( atau Program
aplikasi lain ) dan berakhir pada saat layanan selesai. Biasanya, klien membuka saluran
komunikasi dengan menggunakan alamat IP dari host remote dan alamat port dikenal baik
dari program server tertentu yang berjalan pada mesin itu. Setelah saluran komunikasi
dibuka, client mengirimkan request dan menerima respon. Meskipun bagian permintaanrespon dapat diulang beberapa kali, seluruh proses terbatas dan akhirnya berakhir.
concurrency
Kedua klien dan server dapat berjalan dalam mode bersamaan .
Concurrency di Klien
Klien dapat dijalankan pada mesin baik iteratif atau bersamaan. Menjalankan klien iteratif
berarti menjalankan mereka satu per satu, satu klien harus mulai menjalankan, dan
mengakhirinya sebelum mesin dapat memulai klien lain. Kebanyakan komputer saat ini,
memungkinkan klien berjalan bersamaan, yaitu dua atau lebih klien dapat berjalan pada
waktu yang sama .
Concurrency di Server
Sebuah server yang berulang dapat memproses hanya satu permintaan pada satu waktu,
melainkan menerima permintaan dalam proses itu, dan mengirim respon terhadap pemohon
sebelum menangani permintaan lain. Sebuah Server bersamaan, dapat memproses banyak
permintaan pada saat yang sama sehingga dapat berbagi waktu antara banyak permintaan.
Server menggunakan UDP salah, lapisan transport protokol connectionless, atau TCP / SCTP,
lapisan transport protokol berorientasi koneksi. Operasi Server tergantung pada dua faktor :
protokol lapisan transport dan metode layanan. secara teoretis kita dapat memiliki empat jenis
server : connectionless berulang, connectionless bersamaan, connection-oriented berulang,
dan connection-oriented bersamaan (lihat Gambar 17.1 ) .

Connectionless Iterative Server


Server yang menggunakan UDP biasanya berulang-ulang, seperti yang telah kami katakan,
berarti bahwa server memproses satu permintaan pada satu waktu. Sebuah server
mendapatkan permintaan yang diterima dalam datagram dari UDP, proses permintaan, dan
memberikan respon terhadap UDP untuk mengirim ke klien. Server tidak membayar
perhatian pada datagrams lain. Datagrams ini disimpan dalam antrian, menunggu layanan.
Mereka semua bisa dari satu klien atau dari banyak klien. Di kedua kasus mereka diproses
satu demi satu dalam urutan kedatangan. Server menggunakan satu port tunggal untuk tujuan
ini, port yang sama-sama kita ketahui. Semua datagrams tiba di port ini menunggu antrean
untuk dilayani, seperti yang ditunjukkan pada Gambar 17.2.

Connection-Oriented Server Concurrent


Server yang menggunakan TCP (atau SCTP) biasanya berjalan bersamaan. Ini berarti
bahwa server dapat melayani banyak klien pada waktu yang sama. Komunikasi adalah
connection-oriented, yang berarti bahwa permintaan adalah aliran byte yang dapat tiba di
beberapa segmen dan respon dapat menempati beberapa segmen. Sambungan dibentuk antara
Server dan setiap klien, dan koneksi tetap terbuka sampai seluruh aliran diproses dan
sambungan diakhiri. Jenis server ini tidak dapat menggunakan hanya satu port karena setiap
koneksi membutuhkan port dan banyak koneksi mungkin terbuka pada waktu yang sama.
Banyak port yang dibutuhkan, tetapi server hanya dapat menggunakan satu port terkenal.
Solusinya adalah dengan memiliki satu port terkenal dan banyak port fana. Server menerima
permintaan sambungan di port yang telah diketahui. Seorang klien dapat melakukan

pendekatan awal ke port ini untuk membuat sambungan. Setelah koneksi dibuat, server
memberikan port sementara untuk hubungan ini untuk membebaskan port yang telah
diketahui. Transfer data sekarang dapat berlangsung antara dua port sementara ini, satu di
situs klien dan yang lainnya di server situs. Port terkenal sekarang bebas untuk klien lain
untuk membuat koneksi. Untuk melayani beberapa klien pada saat yang sama, server
menciptakan proses anak, yang merupakan salinan dari proses awal ( proses induk ).
Server juga harus memiliki satu antrian untuk setiap koneksi. Segmen datang dari
klien, disimpan dalam antrian yang sesuai, dan akan dilayani secara bersamaan oleh server.
Lihat Gambar 17.3 untuk konfigurasi ini.

Socket Interface
Bagaimana bisa sebuah proses client berkomunikasi dengan proses server? Sebuah
program komputer adalah set instruksi standar yang memberitahu komputer apa yang harus
dilakukan. Sebuah program komputer memiliki satu set instruksi untuk operasi matematika,
satu set instruksi untuk manipulasi string, masih satu set instruksi untuk akses input / output.
Jika kita perlu program untuk dapat berkomunikasi dengan program lain yang berjalan pada
mesin yang lain, kita perlu satu set baru instruksi untuk memberitahu lapisan transport untuk
membuka koneksi, mengirim data ke dan menerima data dari ujung yang lain, dan menutup
koneksi. Sebuah set instruksi semacam ini biasanya disebut sebagai interface.
Sebuah antarmuka adalah satu set instruksi yang dirancang untuk interaksi antara dua entitas.
Beberapa antarmuka telah dirancang untuk komunikasi. Tiga di antara mereka adalah:
socket antarmuka, lapisan transport antarmuka ( TLI ), dan STREAM. Meskipun programmer
jaringan harus akrab dengan semua interface ini, kita membahas secara singkat hanya soket
antarmuka dalam bab ini untuk memberikan gambaran umum tentang jaringan komunikasi
pada lapisan aplikasi. Socket antarmuka dimulai pada awal 1980-an di Universitas Berkeley
sebagai bagian dari Lingkungan UNIX. Untuk lebih memahami konsep socket interface, kita
perlu mempertimbangkan hubungan antara sistem operasi yang mendasari, seperti UNIX atau
Windows, dan TCP / IP protocol suite. Masalah yang kita telah diabaikan sejauh ini. Gambar
17.4 menunjukkan hubungan konseptual antara sistem operasi dan suite.
Gambar 17.4 Hubungan antara sistem operasi dan TCP / IP.

Soket interface, sebagai set instruksi, terletak antara operasi sistem dan program
aplikasi. Untuk mengakses layanan yang diberikan oleh TCP / IP protocol suite, aplikasi perlu
menggunakan instruksi didefinisikan dalam soket antarmuka.
Contoh 17.1
Sebagian besar bahasa pemrograman memiliki antarmuka berkas , satu set instruksi
yang memungkinkan programmer untuk membuka file, membaca dari file, menulis ke file,
melakukan operasi lain pada file tersebut, dan akhirnya menutup file. Ketika program perlu
membuka file tersebut, ia menggunakan nama berkas ini dikenal dengan sistem operasi.
Ketika berkas dibuka, sistem operasi mengembalikan referensi ke file ( integer atau pointer )
yang dapat digunakan untuk instruksi lain, seperti membaca dan menulis.
Stopkontak (Socket)
Stopkontak adalah abstrak perangkat lunak simulasi soket hardware yang kita lihat
dalam kehidupan sehari-hari. Untuk menggunakan saluran komunikasi, program aplikasi
(client atau server ) perlu meminta sistem operasi untuk menciptakan socket. Program
aplikasi kemudian dapat steker ke dalam soket untuk mengirim dan menerima data. Untuk
komunikasi data terjadi, sepasang soket, masing-masing di salah satu ujung komunikasi,
diperlukan. Gambar 17.5 mensimulasikan ini abstraksi menggunakan soket dan steker yang
kita gunakan dalam kehidupan kita sehari-hari ( untuk telepon , untuk misalnya) , dalam
Internet socket adalah struktur data software seperti yang kita bahas segera.
Gambar 17.5 Konsep soket

Struktur Data
Format struktur data untuk menentukan socket tergantung pada bahasa yang digunakan oleh
proses. Untuk sisa bab ini, kita berasumsi bahwa proses yang ditulis dalam bahasa C. Dalam
bahasa C, socket didefinisikan sebagai struktur lima bidang ( struct atau merekam ) seperti
yang ditunjukkan pada Gambar 17.6.
Gambar 17.6 struktur data Socket

Perhatikan bahwa programmer tidak harus mendefinisikan struktur ini, melainkan sudah
didefinisikan. Programmer hanya perlu menggunakan file header yang mencakup definisi ini
(dibahas kemudian). Mari kita secara singkat mendefinisikan penggunaan bidang dalam
struktur ini :

Keluarga
Field ini mendefinisikan kelompok protokol : IPv4, IPv6, protokol domain UNIX, dan
seterusnya. Jenis keluarga kita gunakan dalam TCP / IP didefinisikan oleh IF_INET
konstan untuk protokol IPv4 dan IPv6 IF_INET6 untuk protokol.
Type.
Field ini mendefinisikan empat jenis soket : SOCK_STREAM (untuk TCP ),
SOCK_DGRAM (untuk UDP ), SOCK_SEQPACKET ( untuk SCTP ), dan
SOCK_RAW (untuk aplikasi yang secara langsung menggunakan layanan IP).
Mereka ditunjukkan pada Gambar 17.7.
Protokol.
Bidang ini mendefinisikan protokol yang menggunakan antarmuka. Hal ini diatur ke 0
untuk TCP / IP protocol suite.
Alamat soket lokal.
Field ini mendefinisikan alamat soket lokal. Sebuah alamat soket, seperti dibahas
dalam Bab 13, adalah kombinasi dari sebuah alamat IP dan nomor port.
alamat soket remote.
Field ini mendefinisikan alamat soket remote .
Gambar 17.7 tipe Socket

Struktur Alamat Socket


Sebelum kita dapat menggunakan socket, kita perlu memahami struktur alamat socket,
sebuah kombinasi alamat IP dan nomor port. Meskipun beberapa jenis socket alamat yang
telah ditetapkan dalam pemrograman jaringan, kita mendefinisikan hanya satu yang
digunakan untuk IPv4. Dalam versi ini alamat soket adalah struktur data yang kompleks
(struct di C) seperti ditunjukkan pada Gambar 17.8.
Gambar 17,8 IPv4 alamat soket

Perhatikan bahwa struct sockaddr_in memiliki lima bidang, tetapi bidang sin_addr itu sendiri
merupakan struct jenis in_addr dengan s_addr satu bidang tunggal. Pertama-tama kita
mendefinisikan struktur in_addr seperti yang ditunjukkan di bawah ini:
struct in_addr
{
in_addr_t s_addr; // A 32-bit IPv4 address
}
struct sockaddr_in
{
uint8_t sin_len; // length of structure (16 bytes)
sa_family_t sin_family; // set to AF_INET
in_port_t sin_port; // A 16-bit port number
struct in_addr sin_addr; // A 32-bit IPv4 address
char sin_zero[8]; // unused
}

Fungsi
Interaksi antara proses dan sistem operasi dilakukan melalui daftar fungsi yang telah
ditetapkan. Pada bagian ini, kami memperkenalkan fungsi-fungsi ini pada bagian berikutnya,
kita menunjukkan bagaimana mereka dikombinasikan untuk menciptakan proses .

Fungsi Soket

Sistem operasi mendefinisikan struktur socket yang ditunjukkan pada Gambar 17.6.
Bagaimanapun, sistem operasi tidak membuat socket sampai diperintahkan oleh proses.
Proses itu perlu menggunakan fungsi panggilan socket untuk menciptakan socket. Prototipe
untuk fungsi ini adalah sebagai berikut:
int socket (int family, int type, int protocol);

Panggilan untuk fungsi ini menciptakan socket, tetapi hanya tiga bidang dalam struktur
socket ( keluarga , jenis , dan protokol ) yang terisi. Jika panggilan berhasil, fungsi
mengembalikan unik sockfd socket descriptor ( integer non - negatif ) yang dapat digunakan
untuk merujuk kepada soket dalam panggilan lain, jika panggilan tidak berhasil, sistem
operasi kembali -1 .

Fungsi Mengikat

Fungsi socket mengisi kolom-kolom pada soket secara parsial. Untuk mengikat socket ke
komputer lokal dan port lokal, fungsi mengikat perlu dipanggil. Fungsi mengikat, mengisi
nilai untuk alamat soket lokal (alamat IP lokal dan port nomor lokal ). Ia mengembalikan -1
Jika gagal mengikat. Prototipe ini ditunjukkan di bawah ini :

int bind (int sockfd, const struct sockaddress* localAddress, socklen_t addrLen);

Dalam prototipe ini, sockfd adalah nilai deskriptor soket kembali dari fungsi socket
panggilan, localAddress adalah pointer ke alamat socket yang perlu didefinisikan ( oleh
sistem atau programmer ), dan addrLen adalah panjang alamat socket. Kita akan lihat nanti
ketika fungsi mengikat yang bisa dan tidak bisa digunakan.

Fungsi Menghubungkan

Fungsi menghubungkan digunakan untuk menambahkan alamat soket remote untuk struktur
socket. Ia mengembalikan -1 jika koneksi fails.The prototipe diberikan di bawah ini :
int connect (int sockfd, const struct sockaddress* remoteAddress, socklen_t addrLen);

Argumen adalah sama, kecuali argumen kedua dan ketiga mendefinisikan alamat remote
bukan satu lokal

Fungsi Mendengarkan

Fungsi mendengarkan hanya dipanggil oleh server TCP. Setelah TCP menciptakan dan
terikata socket, ia harus menginformasikan sistem operasi bahwa soket siap menerima
permintaan klien. Hal ini dilakukan dengan memanggil fungsi mendengarkan. Backlog
adalah jumlah maksimum permintaan sambungan . Fungsi ini mengembalikan -1 jika gagal .
Berikut ini menunjukkan prototipe :
int listen (int sockfd, int backlog);

Fungsi Menerima

Fungsi menerima digunakan oleh server untuk menginformasikan TCP yang siap menerima
koneksi dari klien. Fungsi ini mengembalikan -1 jika gagal . Prototipe ditampilkan di bawah
ini :
int accept (int sockfd, const struct sockaddress* clientAddr, socklen_t* addrLen);

Dua argumen terakhir adalah pointer ke alamat dan panjang. Fungsi menerima adalah fungsi
blocking, ketika dipanggil, blok-blok itu sendiri sampai sambungan dibuat oleh klien. Fungsi
menerima kemudian mendapat klien alamat soket dan alamat panjang dan lolos ke proses
server yang akan digunakan untuk mengakses klien. Perhatikan beberapa poin berikut :
a. Panggilan untuk menerima fungsi membuat cek proses jika ada koneksi klien setiap
meminta dalam buffer tunggu. Jika tidak, fungsi menerima membuat proses untuk
tidur. Proses ini bangun saat antrian setidaknya memiliki satu permintaan .
b. Setelah panggilan sukses untuk menerima, soket baru dibuat dan komunikasi
didirikan antara soket klien dan socket baru server.
c. Alamat yang diterima dari fungsi menerima mengisi alamat soket terpencil di soket
baru .
d. Alamat klien dikembalikan melalui pointer. Jika pemrogram tidak membutuhkan
alamat ini, maka dapat diganti dengan NULL.
e. Panjang alamat dikembalikan, dilewatkan ke fungsi dan juga kembali melalui pointer.
Jika panjang alamat ini tidak diperlukan, dapat diganti dengan NULL.

Fungsi Percabangan

Fungsi percabangan digunakan oleh proses untuk menduplikasi proses. Proses yang
memanggil fungsi percabangan disebut sebagai proses induk, proses yang dibuat duplikat,
disebut proses anak. Prototipe ini ditunjukkan di bawah ini :
pid_t fork (fork);

Sangat menarik untuk mengetahui bahwa proses percabangan disebut sekali, tapi hasilnya
dua kali. Di proses induk, nilai kembalian adalah bilangan bulat positif ( proses ID dari orang
tua proses yang memanggilnya ). Dalam proses anak, nilai kembalian adalah 0. Jika ada error,
fungsi percabangan mengembalikan -1. Setelah percabangan, dua proses yang berjalan secara
bersamaan; CPU memberikan waktu untuk menjalankan setiap proses secara bergantian.

Fungsi Mengirim dan Menerima

Fungsi mengirim digunakan oleh proses untuk mengirim data ke proses lain yang berjalan
pada mesin remote. Fungsi menerima digunakan oleh proses untuk menerima data dari proses
lain yang berjalan pada mesin remote. Fungsi ini berasumsi bahwa ada sudah koneksi terbuka
antara dua mesin, sehingga hanya dapat digunakan oleh TCP ( atau SCTP ). Fungsi-fungsi ini
mengembalikan jumlah byte mengirim atau menerima .
int send (int sockfd, const void* sendbuf, int nbytes, int flags);
int recv (int sockfd, void* recvbuf, int nbytes, int flags);

Berikut sockfd adalah socket descriptor, sendbuf adalah pointer ke buffer di mana data
dikirim telah disimpan, recvbuf adalah pointer ke buffer di mana data yang diterima akan
disimpan. nbytes adalah ukuran data yang akan dikirim atau diterima. fungsi ini
mengembalikan jumlah byte yang sebenarnya dikirim atau diterima jika berhasil dan -1 jika
ada kesalahan .

Fungsi Sendto dan RecvFrom (Mengirim ke dan Menerima dari)

Fungsi sendto digunakan oleh proses untuk mengirim data ke proses remote menggunakan
jasa UDP. Fungsi recvfrom digunakan oleh proses untuk menerima data dari proses remote
menggunakan jasa UDP. Karena UDP adalah protokol connectionless, salah satu argumen
untuk mendefinisikan alamat soket remote ( tujuan atau sumber ).
int sendto (int sockfd, const void* buffer, int nbytes, int flags
struct sockaddr* destinationAddress, socklen_t addrLen);
int recvfrom (int sockfd, void* buffer, int nbytes, int flags
struct sockaddr* sourceAddress, socklen_t* addrLen);

Berikut sockfd adalah socket descriptor, buffer adalah pointer ke buffer di mana data dikirim
atau diterima disimpan, dan buflen adalah panjang buffer. meskipun, nilai bendera bisa nol,
kita biarlah 0 untuk program sederhana kami dalam hal ini bab. Fungsi-fungsi ini
mengembalikan jumlah byte yang dikirim atau diterima jika berhasil dan -1 jika ada
kesalahan .

Fungsi Dekat (Close Function)

Fungsi dekat digunakan oleh proses untuk menutup socket .


int close (int sockfd);

Sockfd tidak valid setelah memanggil fungsi ini. Soket mengembalikan sebuah integer, 0
untuk sukses dan -1 untuk kesalahan .

Fungsi Byte Ordering

Informasi dalam komputer disimpan dalam host byte order, yang bisa di little-endian, di mana
byte kecil -end ( paling signifikan byte ) disimpan dalam alamat awal, atau big-endian, di
mana byte besar -end ( byte paling signifikan ) disimpan dalam startting address.
Pemrograman jaringan memerlukan data dan informasi lain berada di urutan byte jaringan,
yang big-endian. Karena ketika kita menulis program, kami tidak bisa yakin, bagaimana
informasi seperti alamat IP dan nomor port yang disimpan dalam komputer, kita perlu
mengubah mereka untuk jaringan urutan byte. dua fungsi dirancang untuk tujuan ini : htons
(host untuk jaringan pendek ), yang mengubah sebuah pendek ( 16 - bit ) nilai pesanan
jaringan byte, dan htonl (host ke jaringan lama ), yang melakukan hal yang sama untuk waktu
yang lama ( 32-bit ) value. Ada juga dua fungsi yang melakukan justru sebaliknya : ntohs dan
ntohl. Prototipe fungsi ini ditunjukkan di bawah ini :
uint16_t htons (uint16_t shortValue);
uint32_t htonl (uint32_t longValue);
uint16_t ntohs (uint16_t shortValue);
uint32_t ntohl (uint32_t longValue);

Fungsi Manajemen Memori

Kita perlu beberapa fungsi untuk mengelola nilai-nilai yang tersimpan dalam memori . Kami
memperkenalkan tiga fungsi memori umum di sini, walaupun kita tidak menggunakan semua
dari mereka di bab ini .
void* memset (void* destination, int chr, size_t len);
void* memcpy (void* destination, const void* source, size_t nbytes);
int memcmp (const void* ptr1, const void* ptr2, size_t nbytes);

Fungsi pertama, memset ( set memori ) digunakan untuk mengatur ( toko ) sejumlah byte
( nilai len ) tertentu dalam memori ditentukan oleh pointer tujuan ( mulai alamat ). Fungsi
kedua, memcpy ( salinan memori ) digunakan untuk menyalin sejumlah byte ( nilai nbytes )
tertentu dari bagian dari memori ( source) ke bagian lain dari memori ( destination ). Fungsi
ketiga, memcmp (memori membandingkan), digunakan untuk membandingkan dua set byte
(nbytes) mulai dari ptr1 dan ptr2. Hasilnya adalah 0 jika dua set adalah sama, kurang dari nol
jika set pertama lebih kecil dari yang kedua, dan lebih besar dari nol jika set pertama lebih
besar dari kedua. Perbandingan ini didasarkan pada membandingkan string byte di bahasa C.

Fungsi Konversi Alamat

Kami biasanya ingin bekerja dengan 32-bit alamat IP dalam format desimal bertitik. ketika
kita ingin menyimpan alamat dalam soket, kita perlu mengubahnya ke nomor. Dua fungsi
yang digunakan untuk mengkonversi alamat dari presentasi ke nomor dan sebaliknya:
inet_pton (presentasi ke nomor) dan inet_ntop (jumlah presentasi). Penggunaan konstan
untuk nilai keluarga adalah AF_INET untuk tujuan kita. prototipe mereka adalah sebagai
berikut:
int inet_pton (int family, const char* stringAddr, void* numericAddr);
char* inet_ntop (int family, const void* numericAddr, char* stringAddr, int len);

File Header
Untuk menggunakan fungsi yang dijelaskan sebelumnya, kita perlu satu set file header. Kami
mendefinisikan Header file ini dalam file terpisah, yang kita beri nama "headerFiles.h". Kami
menyertakan file ini di program kami untuk menghindari termasuk daftar panjang file header.
Tidak semua file header ini mungkin diperlukan di semua program, namun disarankan untuk
memasukkan semua dari mereka dalam kasus.
// "headerFiles.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <arpa/innet.h>
#include <sys/wait.h>

Komunikasi Menggunakan UDP


Gambar 17.9 menunjukkan diagram alir yang disederhanakan untuk jenis komunikasi.
Gambar 17.9 komunikasi berulang Connectionless menggunakan UDP

Proses Server
Proses server dijalankan pertama kali. Proses server memanggil fungsi socket untuk membuat
socket. Kemudian memanggil fungsi mengikat untuk mengikat socket ke port yang terkenal
dan Alamat IP dari komputer di mana proses server berjalan. Server kemudian memanggil
fungsi recvfrom, yang memblok sampai datagram tiba. Ketika datagram tiba, fungsi recvfrom
unblocks, ekstrak klien alamat soket dan alamat panjang dari datagram yang diterima, dan
mengembalikan mereka ke proses. Proses ini menghemat dua potongan-potongan informasi
dan memanggil prosedur ( fungsi) untuk menangani permintaan. Bila hasilnya sudah siap,
proses server memanggil fungsi sendto dan menggunakan Informasi yang disimpan untuk

mengirim hasilnya ke klien yang memintanya. Server menggunakan terbatasan loop untuk
merespon permintaan yang datang dari klien yang sama atau klien yang berbeda.

Proses Klien
Proses klien sederhana. Klien memanggil fungsi socket untuk menciptakan socket. Kemudian
memanggil fungsi sendto dan nilai alamat socket dari server dan lokasi buffer dari UDP yang
bisa mendapatkan data untuk membuat datagram. Kemudian klien memanggil fungsi
recvfrom yang menghalangi sampai jawabannya datang dari server. ketika balasan tiba, UDP
memberikan data ke proses klien, yang membuat fungsi recv untuk membuka blokir dan
memberikan data yang diterima ke proses klien. Perhatikan bahwa kita mengasumsikan
bahwa pesan klien sangat kecil sehingga cocok menjadi satu datagram tunggal. Jika hal ini
tidak terjadi, dua fungsi panggilan, sendto dan recvfrom, perlu diulang. Namun, server tidak
menyadari komunikasi multidatagram, melainkan menangani setiap permintaan secara
terpisah.
Contoh 17.2
Sebagai contoh, mari kita lihat bagaimana kita dapat merancang dan menulis dua program:
server echo dan echo Server. Klien mengirimkan baris teks ke server, server akan
mengirimkan baris yang sama kembali ke klien. Meskipun pasangan client / server ini tampak
sia-sia, ia memiliki beberapa aplikasi. Hal ini dapat digunakan, untuk Misalnya, ketika
komputer ingin menguji apakah komputer lain dalam jaringan hidup. untuk lebih memahami
kode dalam program, pertama-tama kita memberikan tata letak variabel yang digunakan
dalam kedua program seperti ditunjukkan pada Gambar 17.10.
Gambar 17.10 Variabel yang digunakan dalam server echo dan klien echo menggunakan
layanan UDP

Tabel 17.1 menunjukkan program untuk server echo. Kami telah menghilangkan banyak
detail dan kesalahan penanganan untuk menyederhanakan program. Kami meminta pembaca
untuk memberikan rincian lebih lanjut dalam latihan.
Tabel 17.1 Echo Server Program menggunakan Layanan UDP

Line 14 menciptakan socket. Baris 16 sampai 19 membuat alamat soket lokal; soket terpencil
alamat akan dibuat dalam baris 24 seperti yang dijelaskan kemudian. Baris 20 mengikat soket
ke soket alamat lokal. Baris 22 hingga 26 menerima dan mengirim datagram-datagram, dari
banyak klien. Ketika server menerima datagram dari klien, alamat socket klien dan panjang
alamat soket dikembalikan ke server. Kedua potongan informasi yang digunakan dalam baris
34 untuk mengirim echo pesan ke klien yang sesuai. Perhatikan bahwa kita telah
mengeliminasi banyak baris pengecekan error dari Kode, mereka telah dinggalkan sebagai
latihan.
Tabel 17.2 menunjukkan program klien untuk proses echo. Kita telah mengasumsikan bahwa
klien mengirimkan hanya satu datagram akan berecho oleh server. Jika kita perlu mengirim
lebih dari satu datagram, bagian transfer data harus diulang menggunakan loop.
Tabel Program 17.2 Echo Client menggunakan Layanan UDP

Line 12 menciptakan socket. Baris 14 sampai 17 menunjukkan bagaimana kita membuat


server alamat soket, ada tidak perlu untuk membuat klien alamat soket. Baris 19 sampai 25
membaca string dari keyboard, kirim ke server, dan menerimanya kembali. Baris 23
menambahkan karakter null ke string yang diterima untuk membuatnya Ditampilkan sejalan
25. Sejalan 27, kita menutup soket. Kami harus menghapus semua pengecekan error, kami
meninggalkan mereka sebagai latihan.
Untuk menjadi lengkap, kode pengecekan error perlu ditambahkan untuk kedua Server dan
program client.

Komunikasi Menggunakan TCP


Sekarang kita membahas connection-oriented , komunikasi bersamaan menggunakan layanan
TCP ( kasus SCTP akan sama ) . Gambar 17.11 menunjukkan diagram aliran umum untuk
jenis komunikasi .

Proses Server
Proses server dijalankan pertama kali. Ini panggilan fungsi socket untuk menciptakan socket ,
yang kita memanggil mendengarkan socket . Socket ini hanya digunakan selama
pembentukan koneksi. itu proses server kemudian memanggil fungsi mengikat untuk
mengikat hubungan ini ke alamat soket dari komputer server . Program server kemudian
memanggil menerima fungsi . fungsi ini adalah fungsi memblokir , ketika itu disebut, itu
diblokir sampai TCP menerima permintaan koneksi ( segmen SYN ) dari klien . The

menerima Fungsi kemudian adalah diblokir dan menciptakan socket baru yang disebut socket
connect yang mencakup soket alamat klien yang mengirim segmen SYN . Setelah menerima
fungsi diblokir , server tahu bahwa klien membutuhkan layanan . Untuk menyediakan
concurrency , server proses ( proses induk ) memanggil fungsi percabangan . Fungsi ini
membuat proses baru ( proses anak ) , yang persis sama dengan proses induk . Setelah
memanggil percabangan fungsi, dua proses yang berjalan secara bersamaan , tetapi masingmasing dapat melakukan hal yang berbeda . Setiap proses sekarang memiliki dua soket :
mendengarkan dan menghubungkan soket . Proses induk mempercayakan tugas melayani
klien untuk tangan proses anak dan menerima panggilan berfungsi lagi untuk menunggu klien
lain untuk meminta sambungan . Proses anak sekarang siap melayani klien . Ini pertama
menutup mendengarkan socket dan memanggil fungsi recv untuk menerima data dari klien .
Fungsi recv , seperti fungsi recvfrom , adalah sebuah blocking
Gambar 17.11 Diagram Arus untuk koneksi berorientasi, komunikasi bersamaan

berfungsi, melainkan diblokir sampai segmen tiba. Proses anak menggunakan loop dan
panggilan fungsi recv berulang kali sampai menerima semua segmen dikirim oleh klien.
Proses anak kemudian memberikan seluruh data ke fungsi (kami menyebutnya
handleRequest), untuk menangani permintaan dan mengembalikan hasil. Hasilnya kemudian
dikirim ke klien dalam satu panggilan ke send fungsi. Kita perlu menekankan beberapa poin
di sini. Pertama, diagram alir kita menggunakan adalah mungkin salah satu yang paling

sederhana . Server dapat menggunakan banyak fungsi lain untuk menerima dan mengirim
data, memilih salah satu yang sesuai untuk aplikasi tertentu . Kedua, kita berasumsi bahwa
ukuran data yang akan dikirim ke klien sangat kecil yang dapat dikirim dalam satu tunggal
panggilan ke fungsi kirim , jika tidak, kita perlu loop untuk berulang kali memanggil fungsi
kirim. Ketiga , meskipun server mungkin mengirim data menggunakan salah satu panggilan
ke fungsi send , TCP dapat menggunakan beberapa segmen untuk mengirim data . Proses
klien , oleh karena itu, tidak mungkin menerima data dalam satu segmen tunggal , seperti
yang akan kita lihat ketika kita menjelaskan proses client .
Gambar 17.12 menunjukkan status proses induk dan anak sehubungan dengan soket . Bagian
dalam gambar menunjukkan status sebelum menerima pengembalian fungsi . itu proses induk
menggunakan mendengarkan socket untuk menunggu permintaan dari klien . ketika
menerima fungsi diblokir dan kembali ( bagian b) , proses induk memiliki dua soket :
mendengarkan dan soket koneksi . Klien terhubung ke socket connect . setelah memanggil
fungsi fork ( bagian c ) , kita memiliki dua proses , masing-masing dengan dua soket. itu
client terhubung ke kedua processes.The orangtua harus ditutup socket connect untuk
membebaskan diri dari klien dan bebas untuk mendengarkan permintaan dari klien lain
( bagian d ). Sebelum anak bisa mulai melayani klien yang terhubung , perlu untuk menutup
nya mendengarkan socket sehingga permintaan masa depan tidak mempengaruhi itu ( bagian
e ) . Akhirnya , ketika anak selesai melayani klien yang terhubung , perlu untuk menutup
socket connect untuk memisahkan diri dari klien yang telah dilayani ( bagian f ).
Gambar 17.12 Status orangtua dan anak proses sehubungan dengan soket

Meskipun kita tidak termasuk operasi dalam program kami ( untuk kesederhanaan ) , anak
proses , setelah menjalani proses yang sesuai , perlu dihancurkan . Proses anak yang telah
melakukan tugasnya dan aktif biasanya disebut zombie dalam lingkungan UNIX sistem .
Seorang anak dapat dihancurkan secepat itu tidak diperlukan . Atau , sistem dapat
menjalankan program khusus sekali-sekali untuk menghancurkan semua zombie dalam
sistem . itu zombie menempati ruang dalam sistem dan dapat mempengaruhi kinerja sistem.

Proses Klien

Proses klien sederhana. Klien memanggil fungsi socket untuk menciptakan socket . itu
kemudian memanggil fungsi connect untuk meminta koneksi ke server . Fungsi connect
adalah fungsi blocking , melainkan diblokir sampai sambungan dibuat antara dua TCP .
Ketika fungsi connect kembali , klien memanggil fungsi send untuk mengirim data ke server .
Kami hanya menggunakan satu panggilan ke fungsi kirim , dengan asumsi bahwa data dapat
dikirim dengan satu panggilan . Berdasarkan jenis aplikasi , kita mungkin perlu untuk
memanggil fungsi ini berulang kali ( dalam satu lingkaran ) . Klien kemudian memanggil
fungsi recv , yang diblokir sampai segmen tiba dan data dikirim ke proses dengan TCP .
Perhatikan bahwa , meskipun data yang dikirim oleh server dalam satu panggilan ke fungsi
kirim , TCP di server situs mungkin telah menggunakan beberapa segmen untuk mengirim
data. Ini berarti kita mungkin perlu untuk memanggil fungsi recv berulang kali untuk
menerima semua data. Loop dapat dikontrol oleh kembalinya nilai fungsi recv .

Contoh 17.3
Kami ingin menulis dua program untuk menunjukkan bagaimana kita dapat memiliki klien
echo dan server yang menggunakan echo layanan dari TCP . Gambar 17.13 menunjukkan
variabel yang kita gunakan dalam kedua program . karena data mungkin tiba dalam potongan
yang berbeda , kita perlu pointer untuk menunjuk ke buffer . Buffer pertama adalah tetap
danselalu menunjuk ke awal buffer , pointer kedua bergerak untuk membiarkan byte tiba
akan ditambahkan ke akhir dari bagian sebelumnya.
Gambar 17,13 Variabel yang digunakan Contoh 17.3.

Tabel 17.3 menunjukkan program server untuk server echo yang menggunakan layanan dari
TCP. kami telah dieliminasi banyak rincian dan meninggalkan mereka untuk buku-buku
tentang pemrograman jaringan. Kami ingin hanya untuk menunjukkan gambaran global dari
program ini.
Tabel 17.3 Echo Server Program menggunakan Layanan dari TCP

Program ini mengikuti diagram alir Gambar 17.11 . Setiap kali fungsi recv adalah diblokir
mendapat beberapa data dan menyimpannya pada akhir buffer . The movePtr kemudian
dipindahkan ke menunjuk ke lokasi di mana potongan data berikutnya harus disimpan ( baris
39 ) . Jumlah byte untuk baca juga dikurangi dari nilai asli ( 26 ) untuk mencegah overflow
dalam buffer ( baris 40 ). Setelah semua data telah diterima , server memanggil fungsi send
untuk mengirim mereka ke klien . sebagai yang telah disebutkan sebelumnya , hanya ada satu
mengirim panggilan , tetapi TCP dapat mengirimkan data dalam beberapa segmen. Proses
anak kemudian memanggil fungsi dekat dengan menghancurkan socket connect .
Tabel 17.4 menunjukkan program klien untuk proses echo yang menggunakan layanan dari
TCP . kemudian menggunakan strategi yang sama dijelaskan dalam Tabel 17.2 untuk
membuat server socket address . Program ini kemudian mendapatkan string yang akan
berecho dari keyboard , menyimpannya di sendBuffer , dan mengirimkannya . Hasilnya dapat
datang dalam segmen yang berbeda . Program ini menggunakan loop dan ulangi , memanggil
fungsi recv sampai semua Data tiba . Seperti biasa , kita telah mengabaikan kode untuk

memeriksa untuk membuat program sederhana error . itu perlu ditambahkan jika kode
tersebut benar-benar digunakan untuk mengirim data ke server .
Tabel Program 17.4 Echo Client menggunakan layanan dari TCP

Aplikasi Predefined Client-Server


Internet telah didefinisikan satu set aplikasi yang menggunakan paradigma client-server.
mereka adalah membentuk program yang dapat diinstal dan digunakan. Beberapa aplikasi ini
dirancang untuk memberikan beberapa layanan tertentu (seperti FTP), ada pula yang
dirancang untuk memungkinkan pengguna untuk login ke server dan melakukan tugas yang
diinginkan (TELNET tersebut), dan beberapa dirancang untuk membantu program aplikasi
lainnya (seperti DNS). Kami membahas aplikasi ini program secara rinci dalam Bab 18
sampai 24. Dalam Lampiran F kita berikan beberapa versi Java sederhana program dalam
Tabel 17,1-17,4
17.2 PEER-TO-PEER PARADIGMA
Meskipun sebagian besar aplikasi yang tersedia di Internet saat ini menggunakan clientserver paradigma, ide untuk menggunakan apa yang disebut peer-to-peer (P2P) paradigma

baru memiliki menarik perhatian. Dalam paradigma ini, dua komputer rekan (laptop, desktop,
atau frame utama) dapat berkomunikasi satu sama lain untuk bertukar jasa. Paradigma ini
adalah menarik di beberapa daerah seperti file transfer di mana paradigma client-server
mungkin menempatkan banyak beban pada mesin server jika klien ingin mentransfer file
besar seperti sebagai file audio atau video. Idenya adalah juga menarik jika dua rekan-rekan
perlu untuk bertukar beberapa file atau informasi satu sama lain tanpa pergi ke server.
Namun, kita perlu menyebutkan bahwa paradigma P2P tidak mengabaikan paradigma clientserver. Apa yang dilakukannya sebenarnya adalah membiarkan tugas server digunakan
bersama oleh beberapa pengguna yang ingin berpartisipasi dalam proses. Misalnya, bukan
memungkinkan beberapa klien untuk membuat koneksi dan masing-masing men-download
file besar, server dapat membiarkan setiap klien men-download bagian dari file dan kemudian
berbagi dengan satu sama lain. Dalam proses download bagian dari file atau berbagi file yang
didownload, bagaimanapun, komputer harus memainkan peran klien dan lain peran server.
Dengan kata lain, komputer dapat menjadi klien untuk aplikasi tertentu pada satu saat dan
server pada saat lain. Aplikasi ini sekarang dikendalikan komersial dan bukan merupakan
bagian formal dari Internet. Kami meninggalkan eksplorasi ini aplikasi untuk buku-buku
yang dirancang untuk setiap aplikasi tertentu.
17.3 BACAAN
Beberapa buku memberikan cakupan menyeluruh pemrograman jaringan . Secara khusus ,
kami sarankan [ Ste et al . 04 ] , [ Com 96 ] , [ Rob & Rob 96 ] , dan [ Don & Cal 01 ] .
17.4 SYARAT UTAMA
client-server socket

paradigma antarmuka

antarmuka

STREAM

peer-to-peer (P2P) paradigma

transport-layer interface (TLI)

stopkontak
17.5 RINGKASAN

Sebagian besar aplikasi di Internet dirancang menggunakan paradigma client-server di


yang program aplikasi , disebut server , menyediakan layanan dan aplikasi lain Program ,
yang disebut klien , menerima layanan . Sebuah program server adalah tak terbatas
Program . Ketika mulai berjalan jauh kecuali masalah muncul . Ini menunggu untuk
permintaan yang masuk dari klien . Sebuah program klien terbatas , yang berarti dimulai
oleh pengguna dan berakhir ketika layanan selesai . Kedua klien dan server dapat
berjalan dalam mode bersamaan .
Klien dapat dijalankan pada mesin baik iteratif atau bersamaan . sebuah berulang server
dapat memproses hanya satu permintaan pada satu waktu . Sebuah server bersamaan , di
sisi lain tangan , dapat memproses banyak permintaan pada saat yang sama .
paradigma client-server didasarkan pada satu set fungsi yang telah ditetapkan disebut
interface.Kami membahas antarmuka yang paling umum , yang disebut socket antarmuka
, dalam bab ini . itu socket antarmuka , sebagai set instruksi , terletak antara batang
operasi dan program aplikasi . Socket A adalah abstrak perangkat lunak simulasi
perangkat keras socket yang kita lihat dalam kehidupan sehari-hari . Untuk menggunakan

saluran komunikasi, aplikasi Program ( client atau server ) perlu meminta sistem operasi
untuk menciptakan socket.
Interaksi antara proses dan sistem operasi dilakukan melalui daftar fungsi yang telah
ditetapkan. Dalam bab ini, kami memperkenalkan subset dari fungsi-fungsi ini, yaitu
socket, mengikat, menghubungkan, mendengarkan, menerima, percabangan, mengirim,
recv, sendto, recvfrom, dan dekat. Kami juga memperkenalkan beberapa fungsi byte
pemesanan dan beberapa manajemen memori fungsi.
Sebuah server dapat dirancang untuk menjadi program berulang connectionless
menggunakan layanan UDP atau program bersamaan connection-oriented menggunakan
layanan dari TCP atau SCTP.
Meskipun paradigma client-server sangat umum di Internet saat ini, lain paradigma,
disebut peer-to-peer paradigma, telah menemukan beberapa penggunaan komersial.

17.6 PRAKTEK SET


Latihan
1. Menunjukkan bagaimana 32 - bit integer disimpan di empat lokasi memori ( byte x , x
+ 1 , x + 2 , dan x + 3 ) menggunakan urutan byte little-endian .
2. Menunjukkan bagaimana 32 - bit integer disimpan di empat lokasi memori ( byte x , x
+ 1 , x + 2 , dan x + 3 ) menggunakan urutan byte little-endian .
3. Menulis sebuah program singkat untuk menguji apakah komputer Anda menggunakan
big-endian atau little-endian urutan byte .
4. Kami telah menggunakan beberapa jenis data dalam program dalam bab ini . Tulis
program singkat untuk menggunakan dan menguji mereka .
5. Tulis program pendek untuk menguji fungsi memori kita digunakan dalam bab ini .
6. Ada beberapa fungsi di UNIX yang dapat digunakan untuk mengambil informasi
host, seperti alamat IP dan nomor port - misalnya , gethostbyname , gethostbyaddress,
getservebyname, dan getservebyport. Cobalah untuk menemukan beberapa informasi
tentang fungsi-fungsi ini dan menggunakannya dalam program pendek .
7. Pada Tabel 17.1 , menambahkan beberapa kode untuk memeriksa apakah ada
kesalahan dalam panggilan ke soket fungsi . Program ini perlu untuk keluar jika
terjadi kesalahan . Petunjuk : gunakan perror dan keluar fungsi . Prototipe untuk
fungsi perror adalah sebagai berikut:
void perror (const char* string);

8. Pada Tabel 17.1 , menambahkan beberapa kode untuk memeriksa apakah ada
kesalahan dalam panggilan untuk mengikat fungsi. Program ini perlu untuk keluar
jika terjadi kesalahan . Petunjuk : gunakan perror dan keluar fungsi .
9. Memodifikasi program dalam Tabel 17.2 untuk mengizinkan klien untuk
mengirimkan lebih dari satu datagram .
10. Memodifikasi diagram alir pada Gambar 17.11 menunjukkan connectionless tapi
berulang Server.

Jawab :
1. Lihat Gambar 17.E1. Paling kanan (sedikit) byte dari 32-bit integer disimpan dalam
pertama lokasi memori (x).

2.
3. Suatu serikat dapat digunakan untuk mendefinisikan dua jenis data alternatif atau
kombinasi dari data jenis dan struktur data. Kami mendefinisikan serikat sebagai
kombinasi dari 16-bit integer dan sebuah array dari dua karakter. Kami disimpan
integer dalam serikat, tetapi menggunakan serikat sebagai array dari dua byte seperti
yang ditunjukkan dalam program pada Tabel 17.E3.
Table 17.E3
01 // A program to test the computer byte-order
02 #include "headerFiles.h"
03 union
04 {
05 uint16-t intData;
06 char charData[2];
07 }data;
09 int main (void)
10 {
11 data.intData = 0x0102;
if (data.charData[0] 1 && (data.charData[1] 2)
13 printf ("Big-endian byte order\n");
14 else if (data.charData[0] 2 && (data.charData[1] 1)
15 printf ("Little-endian byte order\n");
16 else
17 printf ("Unknown byte order\n");
18 } //End of main

4.
5. Tabel 17.E5 menunjukkan sebuah program sederhana. Pada baris 17 dan 18, kami
membuat dua potongan memori menggunakan fungsi memset dan menyimpan string
"AAAAAAAAA" di pertama dan string "BBBBBBBBBBBB" di kedua. Sejalan 21,
kita menggunakan fungsi memcpy untuk menyalin hanya lima karakter pertama dari
potongan kedua ke pertama. Sejalan 23, kita menggunakan fungsi memcmp untuk
membandingkan pertama byte pertama dari dua potongan. Sejalan 24, kita
menggunakan memcmp untuk membandingkan enam byte dua potongan.
Table 17.E5
01 // A program to test the computer byte-order
02 #include "headerFiles.h"
03
04 int main (void)
05 {
06 // Declaration and definition

07 char buff1 [10];


08 char buff2 [12];
09 int res1;
10 int res2;
11 // Statements
12 memset (buff1, 'A', 10);
13 memset (buff2, 'B', 12);
14 printf ("%s\n", buff1);
15 printf ("%s\n", buff2);
16 memcpy (buff1, buff2, 5);
17 printf ("%s\n", buff1);
18 res1 = memcmp (buff1, buff2, 5);
19 res2 = memcmp (buff1, buff2, 6);
20 printf ("%d %d \n", res1, res2);
21 return 0;
22 } //End of main

Hasil menjalankan program ditampilkan di bawah. Baris pertama menunjukkan isi dari
potongan pertama. Baris kedua menunjukkan isi dari potongan kedua. baris ketiga
menunjukkan isi potongan kedua setelah menyalin. Baris terakhir menunjukkan hasil
perbandingan.
AAAAAAAAAA
BBBBBBBBBBBB
BBBBBAAAAA
0 -1

6.
7. Kita bisa mengganti baris 14 dalam Tabel 17.1 dalam teks dengan baris berikut:
if (sd = socket (PF_INET, SOCK_DGRAM, 0) = 1)
{
perror("Call to socket function failed);
exit (1);
}

8.
9. Tabel 17.E9 menunjukkan program baru. Bagian berwarna (baris 21 sampai dengan
28) menunjukkan perubahan dalam program asli dalam teks.
Table 17.E9
// UDP echo client program
02 #include "headerFiles.h"
03
04 int main (void)
05 {
06 // Declaration and definition
07 int sd;
08 int ns;
09 int nr;
10 char buffer [256];
11 struct sockaddr_in serverAddr;
12
13 // Create socket
14 sd = socket (PF_INET, SOCK_DGRAM, 0);
15
16 // Create server socket address
17 memset (&servAddr, 0, sizeof(serverAddr));
18 servAddrsin_family AF_INET;
19 inet_pton (AF_INET, server address, &serverAddr.sin_addr);

20 serverAddrsin_port htons (7);


21
22 // Send and receive datagrams
while (fgets (buffer, 256, stdin));
24 {
25 ns sendto (sd, buffer, strlen (buffer), 0,
26 (struct sockaddr)&serverAddr, sizeof(serveraddr));
27 recvfrom (sd, buffer, strlen (buffer), 0, NULL, NULL);
28 buffer [nr] 0;
29 printf (Received from server:);
30 fputs (buffer, stdout);
31 }

// Close and exit


34 close (sd);
35 exit (0);
36
37 } // End of echo client program

10. Lihat gambar dibawah