Cara Menulis Pelanggan/Pelayan TCP Mudah Di C

Jawapannya ialah menulis klien dan pelayan TCP yang mudah memerlukan antara muka pengaturcaraan soket yang disediakan oleh sistem operasi. Pelayan melengkapkan komunikasi dengan membuat soket, mengikat alamat, mendengar pelabuhan, menerima sambungan, dan menghantar dan menerima data. Pelanggan menyedari interaksi dengan membuat soket, menghubungkan ke pelayan, menghantar permintaan, dan menerima respons. Kod sampel menunjukkan pelaksanaan asas menggunakan API Socket Berkeley pada Linux atau MacOS, termasuk fail header yang diperlukan, tetapan pelabuhan, pengendalian ralat dan pelepasan sumber. Selepas penyusunan, jalankan pelayan terlebih dahulu dan kemudian jalankan pelanggan untuk mencapai komunikasi dua hala. Platform Windows perlu memulakan Perpustakaan Winsock. Contoh ini adalah model I/O yang menyekat, sesuai untuk mempelajari pengaturcaraan soket asas.

Menulis klien dan pelayan TCP yang mudah di C melibatkan penggunaan antara muka pengaturcaraan soket yang disediakan oleh sistem operasi (biasanya API Berkeley Socket pada sistem seperti Unix, atau Winsock pada Windows). Berikut adalah contoh asas yang berfungsi pada Linux atau MacOS. Untuk Windows, sedikit pengubahsuaian diperlukan (seperti memulakan Winsock).

Pelayan TCP asas di c

Pelayan mendengar pada port, menerima sambungan klien, menerima mesej, dan menghantar respons.

 // server.cpp
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main () {
    int server_fd, new_socket;
    struct sockaddr_in alamat;
    int addRlen = sizeof (alamat);
    penampan char [1024] = {0};
    const char *hello = "hello dari pelayan";

    // Buat deskriptor fail soket
    jika ((server_fd = socket (af_inet, sock_stream, 0)) == 0) {
        Perror ("soket gagal");
        keluar (exit_failure);
    }

    // Tentukan alamat pelayan
    alamat.sin_family = af_inet;
    alamat.sin_addr.s_addr = inaddr_any;
    alamat.sin_port = htons (8080);

    // mengikat soket
    jika (bind (server_fd, (struct sockaddr *) & alamat, sizeof (alamat)) <0) {
        Perror ("Bind gagal");
        tutup (server_fd);
        keluar (exit_failure);
    }

    // dengar sambungan masuk
    jika (dengar (server_fd, 3) <0) {
        Perror ("Dengar");
        tutup (server_fd);
        keluar (exit_failure);
    }

    std :: cout << "Mendengarkan pelayan di port 8080 ... \ n";

    // terima sambungan
    jika ((new_socket = menerima (server_fd, (struct sockaddr *) & alamat, (socklen_t *) & addrlen)) <0) {
        Perror ("Terima");
        tutup (server_fd);
        keluar (exit_failure);
    }

    // Baca data dari pelanggan
    baca (new_socket, buffer, 1024);
    std :: cout << "pelanggan:" << buffer << std :: endl;

    // Hantar respons
    hantar (new_socket, hello, strlen (hello), 0);
    std :: cout << "hello mesej dihantar \ n";

    // pembersihan
    tutup (new_socket);
    tutup (server_fd);
    kembali 0;
}

Pelanggan TCP Asas di C

Pelanggan menghubungkan ke pelayan, menghantar mesej, dan membaca respons.

 // client.cpp
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main () {
    int sock = 0;
    struct sockaddr_in serv_addr;
    const char *hello = "hello dari pelanggan";
    penampan char [1024] = {0};

    // Buat soket
    jika ((sock = soket (AF_INET, SOCK_STREAM, 0)) <0) {
        Perror ("Ralat penciptaan soket");
        kembali -1;
    }

    serv_addr.sin_family = af_inet;
    serv_addr.sin_port = htons (8080);

    // Tukar alamat IPv4 dari teks ke binari
    jika (inet_pton (af_inet, "127.0.0.1", & serv_addr.sin_addr) <= 0) {
        Perror ("Alamat / Alamat tidak sah tidak disokong");
        tutup (kaus kaki);
        kembali -1;
    }

    // Sambungkan ke pelayan
    jika (sambung (sock, (struct sockaddr *) & serv_addr, sizeof (serv_addr)) <0) {
        Perror ("Sambungan gagal");
        tutup (kaus kaki);
        kembali -1;
    }

    // Hantar mesej ke pelayan
    Hantar (Sock, Hello, Strlen (Hello), 0);
    std :: cout << "hello mesej dihantar \ n";

    // Baca respons
    Baca (Sock, Buffer, 1024);
    std :: cout << "Server:" << buffer << std :: endl;

    // pembersihan
    tutup (kaus kaki);
    kembali 0;
}

Cara Menyusun dan Menjalankan

Pada Linux/MacOS:

 pelayan server.cpp -o
g client.cpp -o client

# Terminal 1
./server

# Terminal 2 (selepas pelayan sedang berjalan)
./client

Output yang dijangkakan:

• Cetakan pelayan: Server listening on port 8080... , kemudian mesej klien, kemudian Hello message sent .
• Cetakan Pelanggan: Hello message sent , kemudian Server: Hello from server .

Mata utama

• Headers : sys/socket.h , netinet/in.h , arpa/inet.h , unistd.h adalah penting untuk pengaturcaraan soket pada UNIX.
• Port : Pelayan mengikat ke port 8080. Pastikan ia percuma.
• Alamat IP : Pelanggan menggunakan 127.0.0.1 (localhost). Tukar jika menyambung ke pelayan jauh.
• Menyekat I/O : Contoh -contoh ini menggunakan soket menyekat. Aplikasi sebenar boleh menggunakan I/O atau beberapa benang yang tidak menyekat.
• Pengendalian ralat : Sentiasa periksa nilai pulangan fungsi soket.

Nota untuk Windows

Di tingkap, anda mesti:

• Termasuk <winsock2.h> dan link dengan ws2_32.lib .
• Hubungi WSAStartup() sebelum menggunakan soket.
• Panggil WSACleanup() pada akhirnya.

Contoh coretan:

 Wsadata Wsadata;
WSastArtup (makeWord (2,2), & wsadata);
// ... kod soket ...
Wsacleanup ();

Ini adalah contoh kerja yang minimum. Dalam pengeluaran, anda akan menambah pemulihan ralat, sokongan untuk pelbagai pelanggan (menggunakan fork , benang, atau async I/O), dan pembingkaian data yang lebih baik.

Pada dasarnya hanya keperluan untuk mendapatkan pasangan soket bercakap.

Atas ialah kandungan terperinci Cara Menulis Pelanggan/Pelayan TCP Mudah Di C. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!