Chapter 17

CHAPTER 17Pengenalan 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.

SASARANBab 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, masing-masing 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 permintaan-respon 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_INETin_port_t sin_port; // A 16-bit port numberstruct in_addr sin_addr; // A 32-bit IPv4 addresschar 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 flagsstruct 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 masing-masing 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 client-server 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 client-server. 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-order02 #include "headerFiles.h"03 union04 {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 else17 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-order02 #include "headerFiles.h"03

04 int main (void)05 {06 // Declaration and definition07 char buff1 [10];08 char buff2 [12];09 int res1;10 int res2;11 // Statements12 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 program02 #include "headerFiles.h"0304 int main (void)05 {06 // Declaration and definition07 int sd;08 int ns;09 int nr;10 char buffer [256];11 struct sockaddr_in serverAddr;1213 // Create socket14 sd = socket (PF_INET, SOCK_DGRAM, 0);1516 // 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);2122 // 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 exit34 close (sd);35 exit (0);3637 } // End of echo client program

10. Lihat gambar dibawah