博客

Linux的本地回环接口是一种虚拟网络接口，通常表示为”lo”，用于将数据包从同一主机的一个网络应用程序传输到另一个网络应用程序。当数据被发送到本地回环接口时，操作系统将数据包传递给网络协议栈的上层，并将其视为来自外部网络的数据包。然后，协议栈将数据包传递给应用程序，应用程序对数据包进行处理，并将响应数据包发送回协议栈。协议栈再将响应数据包返回到回环接口，操作系统将其传递给应用程序。这个过程通常被称为”loopback”。

本地回环接口在Linux系统中具有广泛的用途。

1. 它可以用于测试网络应用程序的功能，例如在没有可用网络连接的情况下测试TCP/IP协议栈的正确性。
2. 此外，回环接口还可以用于本地网络通信.

例如在不同的应用程序之间进行通信，或者在同一台机器上的不同进程之间进行通信，这可以提高应用程序的性能和可扩展性。

以下代码进行本地 TCP 测试的简单示例：

// 服务器端代码
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

using namespace std;

int main() {
    int server_fd, new_socket, valread;
    struct sockaddr_in server_addr, client_addr;
    char buffer[1024] = {0};
    int opt = 1;
    int addrlen = sizeof(server_addr);

    // 创建 socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 设置 socket 地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);

    // 绑定 socket
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 监听 socket
    if (listen(server_fd, 3) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    // 接收连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&server_addr, (socklen_t*)&addrlen)) < 0) {
        perror("accept failed");
        exit(EXIT_FAILURE);
    }

    // 读取数据
    valread = read(new_socket, buffer, 1024);
    printf("%s\n", buffer);

    // 发送数据
    char* message = "Hello from server";
    send(new_socket, message, strlen(message), 0);

    return 0;
}

// 客户端代码
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

using namespace std;

int main() {
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // 创建 socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        cout << "Socket creation error" << endl;
        return -1;
    }

    // 设置 socket 地址
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // 将 IP 地址转换为二进制
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        cout << "Invalid address/ Address not supported" << endl;
        return -1;
    }

    // 连接服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        cout << "Connection Failed" << endl;
        return -1;
    }

    // 发送数据
    char* message = "Hello from client";
    send(sock, message, strlen(message), 0);
    printf("Message sent\n");

    // 读取数据
    valread = read(sock, buffer, 1024);
    printf("%s\n", buffer);

    return 0;
}

这里使用了本地 IP 地址 127.0.0.1（也称为 localhost），它指向了本地回环接口。服务端监听 8080 端口，客户端连接该端口进行通信。

下面是一个使用本地回环接口进行进程间通信的示例代码：

// 发送方进程
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define DEST_IP "127.0.0.1" // 目标IP地址为本地回环接口的地址
#define DEST_PORT 9999      // 目标端口号

int main() {
    // 创建socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        return -1;
    }

    // 设置目标地址
    struct sockaddr_in dest_addr;
    memset(&dest_addr, 0, sizeof(dest_addr));
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
    dest_addr.sin_port = htons(DEST_PORT);

    // 连接到目标地址
    if (connect(sockfd, (struct sockaddr*)&dest_addr, sizeof(dest_addr)) < 0) {
        perror("connect");
        close(sockfd);
        return -1;
    }

    // 发送数据
    char buf[] = "hello, world!";
    if (send(sockfd, buf, strlen(buf), 0) < 0) {
        perror("send");
        close(sockfd);
        return -1;
    }

    // 关闭socket
    close(sockfd);

    return 0;
}

// 接收方进程
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define LOCAL_IP "127.0.0.1" // 本地IP地址为本地回环接口的地址
#define LOCAL_PORT 9999      // 本地端口号

int main() {
    // 创建socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        return -1;
    }

    // 设置本地地址
    struct sockaddr_in local_addr;
    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.sin_family = AF_INET;
    local_addr.sin_addr.s_addr = inet_addr(LOCAL_IP);
    local_addr.sin_port = htons(LOCAL_PORT);

    // 绑定到本地地址
    if (bind(sockfd, (struct sockaddr*)&local_addr, sizeof(local_addr)) < 0) {
        perror("bind");
        close(sockfd);
        return -1;
    }

    // 监听连接请求
    if (listen(sockfd, 5) < 0) {
        perror("listen");
        close(sockfd);
        return -1;
    }

    // 接受连接请求
    int connfd = accept(sockfd, NULL, NULL);
    if (connfd < 0) {
        perror("accept");
        close(sockfd);
        return -1;
    }

    // 接收数据
    char buf[1024];
    int n = recv(connfd, buf, sizeof(buf)-1, 0);
    if (n < 0) {
        perror("recv");
        close(connfd);
        close(sockfd);
        return -1;
    }
    buf[n] = '\0';
    printf("received: %s\n", buf);

    // 关闭socket
    close(connfd);
    close(sockfd);

    return 0;