网络套接字

ZY--920

已于 2024-07-04 12:47:39 修改

阅读量154

点赞数 2

分类专栏：计算机网络文章标签：网络服务器运维

于 2024-03-25 22:07:26 首次发布

本文链接：https://blog.csdn.net/m0_70402487/article/details/137025958

版权

计算机网络专栏收录该内容

9 篇文章 0 订阅

订阅专栏

套接字: 在网络上进行进程间通信

网络字节序与主机字节序的转化

1.端口的转化

2.IP地址的转化

字符串转in_addr的函数

in_addr转字符串的函数

将字符串形式的IPv4地址转换为网络字节序的整数形式--inet_pton

#include <netinet/in.h>
#include <arpa/inet.h>

// ...创建套接字后填充信息
struct sockaddr_in server;
memset(&server, 0, sizeof(server)); 
// 设置地址族
server.sin_family = AF_INET;
// 设置端口号
server.sin_port = htons(12345);
// 将字符串形式的IP地址转换为网络字节序的整数形式
if (inet_pton(AF_INET, "120.53.91.43", &server.sin_addr) != 1) 
{
    // 转换失败返回0 , 无效IP地址返回-1
    perror("inet_pton error");
}

将网络字节序的 IPv4 地址转换为点分十进制格式的字符串--inet_ntoa

一般在accept的时候, 获取对端的ip + port

#include <stdio.h>
#include <arpa/inet.h>

int main() {
    struct in_addr ip_addr;
    // 将点分十进制的字符串转换为网络字节序的整数
    ip_addr.s_addr = inet_addr("120.53.91.43"); 

    // 使用 inet_ntoa 将网络字节序的整数转换为点分十进制的字符串
    char *ip_str = inet_ntoa(ip_addr);

    if (ip_str != NULL) 
        printf("IPv4 address in dotted-decimal notation: %s\n", ip_str);
    else 
        perror("inet_ntoa");
    return 0;
}

sockaddr

struct sockaddr {
    sa_family_t sa_family; // 地址族
    char        sa_data[14]; // 地址数据，具体内容与地址族相关
};

sockaddr_in :主要是地址类型, 端口号, IP地址. 基于IPv4编程时, 使用的数据结构是sockaddr_in

struct sockaddr_in {
    sa_family_t    sin_family;  // 地址族，通常为 AF_INET
    in_port_t      sin_port;    // 端口号，网络字节顺序
    struct in_addr sin_addr;    // IPv4 地址结构
    char           sin_zero[8]; // 无用字段，通常用零填充
};

struct in_addr {
    in_addr_t s_addr; // IPv4 地址，32 位无符号整数，网络字节顺序
};

sock常见API

头文件: <sys/socket.h>  <netinet/in.h>  <arpa/inet.h>  <sys/types.h>

// 创建 socket 文件描述符(TCP/UDP, 客户端 + 服务器) (返回一个套接字描述符，失败返回 -1)
int socket(int domain, int type, int protocol);

// 绑定端口号 (TCP/UDP, 服务器) (成功绑定返回 0，失败返回 -1)
int bind(int socket, const struct sockaddr *address,socklen_t address_len);

// 开始监听socket (TCP, 服务器) (成功返回 0，失败返回 -1)
int listen(int socket, int backlog);

// 接收请求 (TCP, 服务器) (成功返回一个套接字描述符，失败返回 -1)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);

// 建立连接 ((TCP, 客户端) (成功返回0, 失败返回-1)
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

//关闭文件描述符 (成功返回 0, 失败返回-1)
close(sockfd);

// 发送数据 (TCP/UDP) (返回发送的字节数，失败返回 -1)
ssize_t send(int sockfd, const void *buf, size_t len, int flags);

// 接收数据 (TCP/UDP) (返回接收的字节数，失败返回 -1)
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

// 发送数据到指定目标 (UDP)
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, 
             const struct sockaddr *dest_addr, socklen_t addrlen);

// 接收数据并记录发送端地址信息 (UDP)
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
               struct sockaddr *src_addr, socklen_t *addrlen);

TCP套接字

客户端

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() 
{
    // 1.创建套接字 (-1表示失败)
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);

    // 设置服务器地址信息
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080); // 服务器端口
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 服务器 IP 地址

    // 2.连接服务器 
    connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

    // 3.发送数据
    send(sockfd, "Hello, server!", strlen("Hello, server!"), 0);

    // 4.接收数据
    char buffer[1024];
    recv(sockfd, buffer, sizeof(buffer), 0);
    printf("Server says: %s\n", buffer);

    // 5.关闭套接字
    close(sockfd);

    return 0;
}

服务端

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() 
{
    // 1.创建套接字 (-1表示失败)
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);

    // 设置服务器地址信息
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);       // 监听端口
    server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有网络接口

    // 2.绑定端口(-1表示失败)
    bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)

    // 3.监听连接(-1表示失败)
    listen(sockfd, 5);

    // 4.接受连接(-1表示失败)
    int newsockfd;
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    newsockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len);

    // 5.接收数据
    char buffer[1024;
    recv(newsockfd, buffer, sizeof(buffer), 0);
    printf("Client says: %s\n", buffer);

    // 6.发送数据
    send(newsockfd, "Hello, client!", strlen("Hello, client!"), 0);

    // 7.关闭连接
    close(newsockfd);
    close(sockfd);

    return 0;
}

UDP套接字

客户端

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1"
#define PORT 12345
#define MAX_LINE 100

int main() {
    // 1.创建套接字(返回值 < 0 表示失败)
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // 设置服务器地址
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    //将一个文本格式的 IPv4 或 IPv6 地址转换为网络字节序（大端序）的二进制形式
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);


    // 发送数据 (返回值 < 0 表示失败)
    socklen_t server_len;
    char *message = "Hello, server!";
    server_len = sizeof(server_addr);
    ssize_t bytes_sent = sendto(sockfd, message, strlen(message), 0, 
                (struct sockaddr*)&server_addr, server_len);

    // 接收数据 (返回值< 0 表示出错)
    char buffer[MAX_LINE];
    ssize_t bytes_received = recvfrom(sockfd, buffer, MAX_LINE, 0, NULL, NULL);
    buffer[bytes_received] = '\0';
    printf("Received from server: %s\n", buffer);

    // 关闭套接字
    close(sockfd);

    return 0;
}

服务端

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>

#define PORT 12345
#define MAX_LINE 100

int main() 
{
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // 设置服务器地址
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);

    // 2.绑定端口
    bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

    // 3.接收数据
    char buffer[MAX_LINE];
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    ssize_t bytes_received = recvfrom(sockfd, buffer, MAX_LINE, 0, 
            (struct sockaddr *)&client_addr, &client_len);
    buffer[bytes_received] = '\0';

    // 4.发送数据
    char *message = "Hello, client!";
    ssize_t bytes_sent = sendto(sockfd, message, strlen(message), 0, 
                (struct sockaddr *)&client_addr, client_len);

    // 5.关闭套接字
    close(sockfd);

    return 0;
}