ifconfig		# 用于Linux和OpenHarmony，常用于查看IP
ipconfig		# 用于Windows，常用于查看IP
ping <IP>		# 測試網(wǎng)絡(luò)連通性

struct sockaddr_in{
	sa_family_t sin_family; /* 指定地址族，即網(wǎng)絡(luò)通信所使用的協(xié)議類型。*/
	in_port_t sin_port; /* 表示端口號*/
	struct in_addr sin_addr; /* 通配地址*/
	unint8_t sin_zero[8]; /* 指定套接字的通信地址，從而確立通信的目標(biāo)。通常未使用
};

if (bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1) 
{
	perror("Error binding socket");
	close(sockfd);
}

if (listen(server_sock, MAX_CLIENTS) == -1)
{
	perror("Failed to listen");
	close(server_sock);
}

if (accept(sockfd,(struct sockaddr *)&client_addr,&client_len) == -1) 
{
	perror("Error accepting connection");
	close(sockfd);
}

if (connect(client_sock,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0) 
{
	perror("Failed to connect to server");
}

#include <iostream> // 引入標(biāo)準(zhǔn)輸入輸出流庫
#include <stdio.h>  // 引入標(biāo)準(zhǔn)輸入輸出庫
#include <string.h> // 引入字符串處理庫
#include <netinet/in.h> // 引入IP網(wǎng)絡(luò)庫
#include <arpa/inet.h> // 引入地址轉(zhuǎn)換庫
#include <sys/socket.h> // 引入套接字庫
#include <unistd.h>    // 引入Unix系統(tǒng)調(diào)用庫

// 服務(wù)器端口號
#define SERVER_PORT 4567
// 最大客戶端數(shù)量
#define MAX_CLIENTS 5
// 緩沖區(qū)大小
#define TCP_BUFFER_SIZE 1024

int main()
{
    // 創(chuàng)建服務(wù)器套接字和客戶端套接字
    int server_sock, client_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

    // 創(chuàng)建一個服務(wù)端TCP套接字
    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(server_sock == -1)
    {
        perror("Failed to create socket"); // 創(chuàng)建套接字失敗，打印錯誤信息
        exit(EXIT_FAILURE); // 退出程序
    }

    // 設(shè)置服務(wù)端地址
    server_addr.sin_family = AF_INET; // 設(shè)置地址族為IPv4
    server_addr.sin_port = htons(SERVER_PORT); // 設(shè)置端口號，htons確保端口號為網(wǎng)絡(luò)字節(jié)序
    server_addr.sin_addr.s_addr = INADDR_ANY; // 設(shè)置IP地址為INADDR_ANY，表示接受任何接口的連接

    // 綁定套接字
    if (bind(server_sock, (struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
    {
        perror("Failed to bind socket"); // 綁定套接字失敗，打印錯誤信息
        close(server_sock); // 關(guān)閉套接字
        exit(EXIT_FAILURE); // 退出程序
    }

    // 開始監(jiān)聽客戶端連接請求
    if (listen(server_sock, MAX_CLIENTS) == -1)
    {
        perror("Failed to listen"); // 監(jiān)聽失敗，打印錯誤信息
        close(server_sock); // 關(guān)閉套接字
        exit(EXIT_FAILURE); // 退出程序
    }
    std::cout << "Server is listening on port " << SERVER_PORT << std::endl; // 打印服務(wù)器監(jiān)聽端口信息

    // 主循環(huán)，等待客戶端連接
    while(true)
    {
        // 接受客戶端連接請求
        client_sock = accept(server_sock, (struct sockaddr *)&client_addr, &client_addr_len);
        if (client_sock == -1)
        {
            perror("Failed to accept connection"); // 接受連接失敗，打印錯誤信息
            continue; // 繼續(xù)下一次循環(huán)
        }

        // 打印出連接成功的客戶端的IP地址和端口號
        std::cout << "Accepted connection from " << inet_ntoa(client_addr.sin_addr) << ":" << ntohs(client_addr.sin_port) << std::endl;

        // 發(fā)送數(shù)據(jù)給客戶端
        char request[] = "Hello, here is server!"; // 定義要發(fā)送的字符串
        size_t bytes_write = write(client_sock, request, strlen(request)); // 發(fā)送數(shù)據(jù)，并返回發(fā)送的字節(jié)數(shù)
        if (bytes_write == -1)
        {
            perror("Failed to write data"); // 發(fā)送數(shù)據(jù)失敗，打印錯誤信息
            close(client_sock); // 關(guān)閉客戶端套接字
            exit(EXIT_FAILURE); // 退出程序
        }

        // 接受客戶端發(fā)送的數(shù)據(jù)
        char buffer[TCP_BUFFER_SIZE]; // 定義緩沖區(qū)用于接收數(shù)據(jù)
        size_t bytes_read = read(client_sock, buffer, TCP_BUFFER_SIZE); // 從客戶端讀取數(shù)據(jù)，并返回讀取的字節(jié)數(shù)
        if (bytes_read == -1)
        {
            perror("Failed to read data"); // 讀取數(shù)據(jù)失敗，打印錯誤信息
            close(client_sock); // 關(guān)閉客戶端套接字
            exit(EXIT_FAILURE); // 退出程序
        }
        else
        {
            std::cout << "Received data from client: " << buffer << std::endl; // 打印接收到的數(shù)據(jù)
            break; // 退出循環(huán)
        }
    }

    // 關(guān)閉服務(wù)器套接字
    close(server_sock);

    return 0;
}

#include <iostream>          // 引入輸入輸出流庫
#include <stdio.h>           // 引入標(biāo)準(zhǔn)輸入輸出庫
#include <string.h>          // 引入字符串處理庫
#include <cstring>           // 引入C風(fēng)格字符串處理庫
#include <sys/socket.h>      // 引入socket編程庫
#include <netinet/in.h>      // 引入網(wǎng)絡(luò)地址結(jié)構(gòu)定義庫
#include <arpa/inet.h>       // 引入網(wǎng)絡(luò)地址轉(zhuǎn)換庫
#include <unistd.h>          // 引入Unix標(biāo)準(zhǔn)庫，提供close函數(shù)

#define TCP_BUFFER_SIZE 1024 // 定義TCP緩沖區(qū)大小為1024字節(jié)

int main()
{
    int client_sock = socket(AF_INET, SOCK_STREAM, 0); // 創(chuàng)建一個IPv4的TCP socket
    if (client_sock == -1) // 如果socket創(chuàng)建失敗
    {
        perror("Failed to create socket"); // 輸出錯誤信息
        exit(EXIT_FAILURE); // 退出程序
    }

    struct sockaddr_in server_addr; // 創(chuàng)建一個服務(wù)器地址結(jié)構(gòu)體

    int SERVER_PORT; // 服務(wù)器端口變量
    std::string SERVER_ADDR; // 服務(wù)器地址變量
    std::cout << "Input server address: "; // 輸出提示信息
    std::cin >> SERVER_ADDR; // 從標(biāo)準(zhǔn)輸入讀取服務(wù)器地址
    std::cout << "Input server port: "; // 輸出提示信息
    std::cin >> SERVER_PORT; // 從標(biāo)準(zhǔn)輸入讀取服務(wù)器端口

    server_addr.sin_family = AF_INET; // 設(shè)置地址族為IPv4
    server_addr.sin_port = htons(SERVER_PORT); // 設(shè)置端口，網(wǎng)絡(luò)字節(jié)序
    if (inet_pton(AF_INET, SERVER_ADDR.c_str(), &server_addr.sin_addr) <= 0) // 如果地址轉(zhuǎn)換失敗
    {
        std::cerr << "Invalid address/ Address not supported" << std::endl; // 輸出錯誤信息
        return -1; // 返回錯誤
    }

    while (true) // 無限循環(huán)嘗試連接
    {
        if (connect(client_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) // 如果連接失敗
        {
            perror("Failed to connect to server"); // 輸出錯誤信息
            close(client_sock); // 關(guān)閉socket
            exit(EXIT_FAILURE); // 退出程序
        }
        std::cout << "Connected to server " << inet_ntoa(server_addr.sin_addr) << ":" << ntohs(server_addr.sin_port) << std::endl; // 輸出連接成功信息

        // 向服務(wù)器發(fā)送數(shù)據(jù)
        char request[] = "Hello, here is client!"; // 創(chuàng)建請求字符串
        size_t bytes_write = write(client_sock, request, strlen(request)); // 發(fā)送數(shù)據(jù)
        if (bytes_write == -1) // 如果發(fā)送失敗
        {
            perror("Failed to write data"); // 輸出錯誤信息
            close(client_sock); // 關(guān)閉socket
            exit(EXIT_FAILURE); // 退出程序
        }

        // 從服務(wù)器接收數(shù)據(jù)
        char buffer[TCP_BUFFER_SIZE]; // 創(chuàng)建緩沖區(qū)
        size_t bytes_read = read(client_sock, buffer, TCP_BUFFER_SIZE); // 讀取數(shù)據(jù)
        if (bytes_read == -1) // 如果接收失敗
        {
            perror("Failed to read data"); // 輸出錯誤信息
            close(client_sock); // 關(guān)閉socket
            exit(EXIT_FAILURE); // 退出程序
        }
        else // 如果接收成功
        {
            std::cout << "Received data from server: " << buffer << std::endl; // 輸出接收到的數(shù)據(jù)
            break; // 退出循環(huán)
        }
    }

    // 關(guān)閉
    close(client_sock); // 關(guān)閉socket

    return 0; // 程序成功結(jié)束
}

import("http://build/ohos.gni") # 導(dǎo)入編譯模板
    ohos_executable("tcp") { # 可執(zhí)行模塊
    sources = [ # 模塊源碼
        "src/tcp_demo.cpp"
    ]
    cflags = []
    cflags_c = []
    cflags_cc = []
    ldflags = []
    configs = []
    deps =[] # 部件內(nèi)部依賴
    part_name = "tcp_demo" # 所屬部件名稱，必選
    install_enable = true # 是否默認(rèn)安裝（缺省默認(rèn)不安裝），可選
}

{
    "name": "@ohos/tcp_demo",
    "description": "",
    "version": "3.1",
    "license": "Apache License 2.0",
    "publishAs": "code-segment",
    "segment": {
        "destPath": "Mysample/tcp_demo"
    },
    "dirs": {},
    "scripts": {},
    "component": {
        "name": "tcp_demo",
        "subsystem": "Mysample",
        "syscap": [],
        "features": [],
        "adapted_system_type": [
            "standard"
        ],
        "rom": "10KB",
        "ram": "10KB",
        "deps": {
            "components": [],
            "third_party": []
        },
        "build": {
            "sub_component": [
                "http://Mysample/tcp_demo:tcp"
            ],
            "inner_kits": [],
            "test": []
        }
    }
}

./build.sh --product-name {product_name} #全量編譯
./build.sh --product-name {product_name}  --build-target {target_name} #單獨編譯部件
./build.sh --product-name {product_name}  --build-target {target_name} --fast-rebuild #快速重建

hb set #設(shè)置編譯參數(shù)
hb build #全量編譯
hb build -T {target_name} #單獨編譯部件
hb build -T {target_name} --fast-rebuild #快速重建

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

#define SERVER_PORT1 4567 // 服務(wù)器端口號
#define SERVER_PORT2 7654 // 服務(wù)器端口號
#define MAX_CLIENTS 5 // 最大客戶端數(shù)量
#define TCP_BUFFER_SIZE 1024 // 緩沖區(qū)大小

int main()
{
    // ------------------------------------本機(jī)作為服務(wù)端--------------------------------------------


    int server_sock, client_sock; // 服務(wù)器套接字和客戶端套接字
    struct sockaddr_in server_addr, client_addr; // 服務(wù)器地址和客戶端地址
    socklen_t client_addr_len = sizeof(client_addr); // 客戶端地址長度

    // 創(chuàng)建一個服務(wù)端TCP套接字
    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(server_sock == -1)
    {
        perror("Failed to create socket");
        exit(EXIT_FAILURE);
    }

    // 設(shè)置服務(wù)端地址
    server_addr.sin_family = AF_INET; // 使用IPv4協(xié)議
    server_addr.sin_port = htons(SERVER_PORT1); // 端口號
    server_addr.sin_addr.s_addr = INADDR_ANY; // 監(jiān)聽所有可用的IP地址

    // 綁定套接字
    if (bind(server_sock, (struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
    {
        perror("Failed to bind socket");
        close(server_sock);
        exit(EXIT_FAILURE);
    }

    // 開始監(jiān)聽客戶端連接請求
    if (listen(server_sock, MAX_CLIENTS) == -1)
    {
        perror("Failed to listen");
        close(server_sock);
        exit(EXIT_FAILURE);
    }
    std::cout << "Server is listening on port " << SERVER_PORT1 << std::endl;

    while(true)
    {
        // 接受客戶端連接請求
        client_sock = accept(server_sock, (struct sockaddr *)&client_addr, &client_addr_len);
        if (client_sock == -1)
        {
            perror("Failed to accept connection");
            continue;
        }

        // 打印出連接成功的客戶端的IP地址和端口號
        std::cout<<"Accepted connection from "<<inet_ntoa(client_addr.sin_addr)<<":"<<ntohs(client_addr.sin_port)<<std::endl;

        // 發(fā)送數(shù)據(jù)給客戶端
        char request[] = "Hello, here is server!";
        size_t bytes_write = write(client_sock, request, strlen(request));
        if (bytes_write == -1)
        {
            perror("Failed to write data");
            close(client_sock);
            exit(EXIT_FAILURE);
        }

        // 接受客戶端發(fā)送的數(shù)據(jù)
        char buffer[TCP_BUFFER_SIZE];
        size_t bytes_read = read(client_sock, buffer, TCP_BUFFER_SIZE);
        if (bytes_read == -1)
        {
            perror("Failed to read data");
            close(client_sock);
            exit(EXIT_FAILURE);
        }
        else
        {
            std::cout<<"Received data from client: "<<buffer<<std::endl;
            break;
        }
    }

    // 關(guān)閉
    close(server_sock);

    // ------------------------------------本機(jī)作為客戶端--------------------------------------------


    // 配置服務(wù)器地址信息
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT2);
    // 原來的客戶端地址作為服務(wù)端地址
    server_addr.sin_addr.s_addr = client_addr.sin_addr.s_addr;

    // 創(chuàng)建客戶端套接字
    client_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(client_sock == -1)
    {
        perror("Failed to create socket");
        exit(EXIT_FAILURE);
    }

    // 連接服務(wù)器
    while(true)
    {
        // 連接服務(wù)器
        if (connect(client_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) 
        {
            perror("Failed to connect to server");
            close(client_sock);
            exit(EXIT_FAILURE);
        }

        // 打印出連接成功的服務(wù)器的IP地址和端口號
        std::cout<<"Connected to server "<<inet_ntoa(server_addr.sin_addr)<<":"<<ntohs(server_addr.sin_port)<<std::endl;

        // 向服務(wù)器發(fā)送數(shù)據(jù)
        char request[] = "Hello, here is client!";
        size_t bytes_write = write(client_sock, request, strlen(request));
        if (bytes_write == -1)
        {
            perror("Failed to write data");
            close(client_sock);
            exit(EXIT_FAILURE);
        }

        // 從服務(wù)器接收數(shù)據(jù)
        char buffer[TCP_BUFFER_SIZE];
        size_t bytes_read = read(client_sock, buffer, TCP_BUFFER_SIZE);
        if (bytes_read == -1)
        {
            perror("Failed to read data");
            close(client_sock);
            exit(EXIT_FAILURE);
        }
        else
        {
            std::cout<<"Received data from server: "<<buffer<<std::endl;
            break;
        }
    }
    
    // 關(guān)閉
    close(client_sock);

    return 0;
}