socket linux编译

在Linux编译中，使用socket函数创建一个套接字。socket函数的原型是[intsocket(int protofamily, int type, int protocol)] ，其中protofamily指定协议族，type指定套接字的类型，protocol指定具体的协议。该函数返回一个唯一的文件描述符sockfd，它用于后续的套接字操作。

一旦创建了套接字，可以使用connect函数来连接到服务器。connect函数的原型是[connect(sockfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr))] ，其中sockfd是之前socket函数返回的文件描述符，serveraddr是服务器的地址结构。通过调用connect函数，客户端可以与服务器建立连接。

在服务器端，可以使用accept函数来接受客户端的连接。accept函数的原型是[int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)] ，其中sockfd是之前socket函数返回的文件描述符，addr是用于存储客户端地址信息的结构体指针，addrlen是addr结构体的长度指针。accept函数返回一个新的文件描述符connect_fd，它用于与特定客户端进行通信。

总结起来，socket编程在Linux中的编译过程包括使用socket函数创建套接字，使用connect函数连接到服务器，以及使用accept函数接受客户端的连接。

相关问题

socket通信实例linux c

下面是一个简单的Linux C Socket通信实例：

服务端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 6000

int main()
{
    int sockfd, newsockfd, n;
    char buffer[256];
    struct sockaddr_in serv_addr, cli_addr;
    socklen_t clilen;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("ERROR opening socket");
        exit(1);
    }

    bzero((char *)&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(PORT);

    if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        perror("ERROR on binding");
        exit(1);
    }

    while (1)
    {
        listen(sockfd, 5);
        clilen = sizeof(cli_addr);
        newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
        if (newsockfd < 0)
        {
            perror("ERROR on accept");
            exit(1);
        }

        bzero(buffer, 256);
        n = read(newsockfd, buffer, 255);
        if (n < 0)
        {
            perror("ERROR reading from socket");
            exit(1);
        }

        printf("Here is the message: %s\n", buffer);

        n = write(newsockfd, "I got your message", 18);
        if (n < 0)
        {
            perror("ERROR writing to socket");
            exit(1);
        }

        close(newsockfd);
    }

    close(sockfd);
    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#define PORT 6000

int main(int argc, char *argv[])
{
    int sockfd, n;
    struct sockaddr_in serv_addr;
    struct hostent *server;

    char buffer[256];
    if (argc < 2)
    {
        fprintf(stderr, "usage %s hostname\n", argv[0]);
        exit(0);
    }

    server = gethostbyname(argv[1]);
    if (server == NULL)
    {
        fprintf(stderr, "ERROR, no such host\n");
        exit(0);
    }

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("ERROR opening socket");
        exit(1);
    }

    bzero((char *)&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr_list[0], (char *)&serv_addr.sin_addr.s_addr, server->h_length);
    serv_addr.sin_port = htons(PORT);

    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        perror("ERROR connecting");
        exit(1);
    }

    printf("Please enter the message: ");
    bzero(buffer, 256);
    fgets(buffer, 255, stdin);

    n = write(sockfd, buffer, strlen(buffer));
    if (n < 0)
    {
        perror("ERROR writing to socket");
        exit(1);
    }

    bzero(buffer, 256);
    n = read(sockfd, buffer, 255);
    if (n < 0)
    {
        perror("ERROR reading from socket");
        exit(1);
    }

    printf("%s\n", buffer);

    close(sockfd);
    return 0;
}

运行方式：

1. 编译服务端代码：`gcc server.c -o server`
2. 编译客户端代码：`gcc client.c -o client`
3. 启动服务端：`./server`
4. 在另一个终端中启动客户端：`./client localhost`

其中，`localhost`可以替换为服务端的IP地址。在客户端中输入消息，服务端将接收到消息并回复“`I got your message`”。

linux socket 传输大文件

在Linux中，你可以使用socket来传输大文件。下面是一个简单的示例代码，用于将文件从一个客户端传输到一个服务器端：

服务器端代码（server.c）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8080
#define BUFSIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFSIZE] = {0};

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

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定套接字到指定端口
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

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

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

    // 接收文件名
    char filename[BUFSIZE];
    memset(filename, 0, sizeof(filename));
    read(new_socket, filename, BUFSIZE);

    FILE *fp = fopen(filename, "wb");
    if (fp == NULL) {
        perror("file open failed");
        exit(EXIT_FAILURE);
    }

    // 接收并写入文件
    int n;
    while ((n = read(new_socket, buffer, BUFSIZE)) > 0) {
        fwrite(buffer, sizeof(char), n, fp);
    }

    fclose(fp);
    close(new_socket);
    close(server_fd);

    return 0;
}

客户端代码（client.c）：

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

#define PORT 8080
#define BUFSIZE 1024

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

    // 创建套接字
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 将IP地址从字符串转换为网络地址结构
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        perror("invalid address");
        exit(EXIT_FAILURE);
    }

    // 连接服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("connection failed");
        exit(EXIT_FAILURE);
    }

    // 发送文件名
    char filename[] = "file.txt";
    send(sock, filename, strlen(filename), 0);

    FILE *fp = fopen(filename, "rb");
    if (fp == NULL) {
        perror("file open failed");
        exit(EXIT_FAILURE);
    }

    // 读取文件并发送
    int n;
    while ((n = fread(buffer, sizeof(char), BUFSIZE, fp)) > 0) {
        send(sock, buffer, n, 0);
    }

    fclose(fp);
    close(sock);

    return 0;
}

你可以将上述代码保存到两个不同的文件中，例如`server.c`和`client.c`，然后使用以下命令分别编译它们：

gcc server.c -o server
gcc client.c -o client

运行服务器端程序：

./server

然后运行客户端程序：

./client

客户端程序将会将`file.txt`文件发送到服务器端，并在服务器端保存为同样的文件名。请确保客户端和服务器端在同一台机器上运行，并且客户端的IP地址和端口号与服务器端的地址和端口号匹配。

这只是一个简单的示例，实际情况可能会更复杂。你可能需要处理错误、添加缓冲区管理、实现更好的错误恢复机制等。