samba实现linux共享文件夹

核心思想:

1 在无限循环中 accpet()后 创建线程

2 预防多线程下的数据竞态:

accept()返回的client_sockfd 是否可以直接填入pthread_create()作为创建线程的参数?

我们观察到 while(1)中并没有阻塞的函数,假设accept()的速度足够快

他会不断地更新client_sockfd的值,而传递给pthread_create()是这个值的地址

也就是说 线程来没来得及启动(没获得cpu时间片) client_sockfd值就被更新了

我们的本意是用每个accept()返回的值,创建一条线程,很显然行为不符合预期

3 解决方案:

为了解决这个问题，最佳做法是为每个接受的连接分配一个新的内存空间来存储它的client_sockfd，并将这块内存的指针传递给新创建的线程。这样，每个线程都有自己独立的client_sockfd副本，不会受到主线程中client_sockfd值改变的影响。

4 扩展:

用同样的思想 扩展传递参数结构体

实现功能:

1 tcp多线程服务器

2 使用信号量计数的计数器

3 测试用客户端

运行注意事项:

1 先开启服务器 

2 根据实际情况修改ip地址及端口

3 手动运行客户端 可以无限次开启观察服务器现象

4 适用于unix-like 且 安装了 gnu_c 的系统 其他酌情改装

服务端:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>
// 服务器地址
#define SERVER_IP "192.168.142.132"
// 服务器端口
#define SERVER_PORT 50010
// 给线程执行函数传递的参数
struct thread_args
{
    // 文件描述符
    int sockfd;
    // 端口号
    uint16_t port;
    // posix信号量
    sem_t *sem;
};
// 线程执行函数
void *start_routine(void *p)
{
    // 类型转换
    struct thread_args ta = *((struct thread_args *)p);
    // 赋值局部变量
    sem_t *sem = ta.sem;
    u_int16_t port = ta.port;
    int client_sockfd = ta.sockfd;

    ssize_t send_bytes, recv_bytes;
    char send_buf[1024] = "How can I help you today ?";
    char recv_buf[1024] = {0};
    // 连接数+1
    sem_post(sem);
    int sval;
    // 获取连接数并打印
    sem_getvalue(sem, &sval);
    printf("V [+] %u connected : %d\n", port, sval);
    // 接收数据
    recv_bytes = recv(client_sockfd, recv_buf, sizeof(recv_buf), 0);
    if (recv_bytes == -1)
    {
        perror("recv");
    }
    if (recv_bytes == 0)
    {
        printf("close by peer\n");
    }
    if (recv_bytes > 0)
    {
        printf("Message : %s\n", recv_buf);
    }
    // 处理数据
    sleep(9);
    // 服务器响应
    send_bytes = send(client_sockfd, send_buf, strlen(send_buf), 0);
    if (send_bytes == -1)
    {
        perror("send");
    }
    // 关闭socket
    if (close(client_sockfd) == -1)
    {
        perror("close");
    }
    // 连接 -1
    sem_wait(sem);
    printf("P [-] %u disconnected \n", port);
    // 释放之前由malloc分配的指针
    free(p);
    // 线程退出
    pthread_exit(NULL);
}
int main()
{
    int server_sockfd, client_sockfd;
    struct sockaddr_in server_sockaddr, client_sockaddr;
    memset(&server_sockaddr, 0, sizeof(server_sockaddr));
    memset(&client_sockaddr, 0, sizeof(client_sockaddr));
    socklen_t client_sockaddr_len = sizeof(client_sockaddr);
    socklen_t server_sockaddr_len = sizeof(server_sockaddr);
    pthread_t tid;
    // 信号量 是否存在都先卸载
    sem_unlink("/sem1");
    // 新建信号量
    sem_t *sem = sem_open("/sem1", O_CREAT, 0700, 0);
    if (sem == SEM_FAILED)
    {
        perror("sem_open");
    }
    // tcp标准流程 socket
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sockfd == -1)
    {
        perror("socket");
    }
    // 设置套接字选项:地址端口复用
    int optval = 1;
    if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1)
    {
        perror("setsockopt");
    }
    // 绑定服务器地址,recv用
    server_sockaddr.sin_port = htons(SERVER_PORT);
    inet_pton(AF_INET, SERVER_IP, &server_sockaddr.sin_addr.s_addr);
    server_sockaddr.sin_family = AF_INET;
    if ((bind(server_sockfd, (struct sockaddr *)&server_sockaddr, server_sockaddr_len)) == -1)
    {
        perror("bind");
    }
    // 第二个参数backlog:允许排队等待接受的连接数的最大值
    if ((listen(server_sockfd, 16)) == -1)
    {
        perror("listen");
    }

    printf("listening on : %d\n", SERVER_PORT);
    // 因为在一个while循环中 主线程永远不会先行结束,设置分离是安全的
    while (1)
    {
        // 接收连接并返回client_sockfd
        client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_sockaddr, &client_sockaddr_len);
        if (client_sockfd == -1)
        {
            perror("accept");
            continue;
        }
        // 为每个参数结构体分配独立内存,预防多线程下的数据竞态
        struct thread_args *ta_p = (struct thread_args *)malloc(sizeof(struct thread_args));
        if (ta_p == NULL)
        {
            return -1;
        }
        // 填充
        ta_p->port = ntohs(client_sockaddr.sin_port);
        ta_p->sem = sem;
        ta_p->sockfd = client_sockfd;
        // 创建线程
        if (pthread_create(&tid, NULL, start_routine, ta_p))
        {
            perror("pthread_create");
        }
        // 设置分离
        if (pthread_detach(tid))
        {
            perror("pthread_detach");
        }
    }
    return 0;
}

客户端:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>

#define SERVER_IP "192.168.142.132"
#define SERVER_PORT 50010

int main()
{
    int client_sockfd;
    struct sockaddr_in server_sockaddr;
    memset(&server_sockaddr, 0, sizeof(server_sockaddr));
    ssize_t send_bytes, recv_bytes;
    char send_buf[1024] = {"hello server !!!"};
    char recv_buf[1024] = {0};
    client_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    inet_pton(AF_INET, SERVER_IP, &server_sockaddr.sin_addr.s_addr);
    server_sockaddr.sin_port = htons(SERVER_PORT);
    server_sockaddr.sin_family = AF_INET;
    connect(client_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr));
    send_bytes = send(client_sockfd, send_buf, strlen(send_buf), 0);
    recv_bytes = recv(client_sockfd, recv_buf, sizeof(recv_buf), 0);
    printf("%s\n", recv_buf);
    close(client_sockfd);
    return 0;
}