linux下c语言编程，使用socket发送文件和数据

最新推荐文章于 2023-12-24 14:00:14 发布
最新推荐文章于 2023-12-24 14:00:14 发布
阅读量5.8k 收藏 30
点赞数 6
分类专栏： socket编程 文章标签： socket c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geshi201028/article/details/50634501
版权

这个程序使用的是多线程机制+缓冲机制。

服务端会创建一个子线程来对应一个客户端，这样就可以实现多个客户端同时在线，客户端会有一个队列，用于循环读取的文件的缓冲机制。

这个程序默认是把接受的文件放在当前目录下的。

服务端：

#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<memory.h>
#include<time.h>
#include<string.h>
#include<sys/wait.h>
#include<signal.h>
#include<time.h>
#include<sys/time.h>
#include<pthread.h>
#include<semaphore.h>
#define SERV_PORT 8888
#define SOCK_COUNT 30
#define MAXSIZE 1000
#define BUF_COUNT 10
#define MSG_FILENAME 1
#define MSG_CONTINUE 2
#define MSG_ACK 3
#define MSG_DONE 4
#define MSG_EXCEPTION 5
//消息结构体
struct msg
{
    int  type;
    int len;
    char data[];
};


int main(int argc,char *argv[])
{
    int sockfd,new_fd;
    struct sockaddr_in servaddr,cliaddr;
    int sin_size,numbytes;
    pid_t pid;
    struct timeval start;
    struct timeval end;
    char strptr[16];
    //创建socket
    if((sockfd = socket(AF_INET,SOCK_STREAM,0))<0)
    {
        perror("socket error");
        exit(-1);
    }
    //初始化socket结构体
    memset(&servaddr,0x00,sizeof(servaddr));
    memset(&cliaddr,0x00,sizeof(cliaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    //避免僵死进程
    void sig_child(int signo)
    {
        pid_t pid;
        int stat;
        while((pid = waitpid(-1,&stat,WNOHANG))>0)
        {
            printf("chlid %d terminated\n",pid);
        }
        return;
    }
    //绑定套接口
    if(bind(sockfd,(struct sockaddr *)&servaddr,sizeof(struct sockaddr)) == -1)
    {
        perror("bind error");
        exit(-1);
    }
    //创建监听套接口
    if(listen(sockfd,SOCK_COUNT) == -1)
    {
        perror("listen error");
        exit(-1);
    }
    //等待连接
    //printf("0-1\n");
    while(1)
    {
        sin_size = sizeof(struct sockaddr_in) ;
        if((new_fd = accept(sockfd,(struct sockaddr *)&cliaddr,(socklen_t *)&sin_size)) == -1)
        {
            perror("accept error");
            exit(-1);
        }
        //创建子进程
        if((pid=fork()) == 0)
        {
            int head=0;//队头指针
            int rear=0;//队尾指针
            struct msg *buf_ptr[BUF_COUNT];//缓冲区队列
            sem_t count;//已经使用的缓冲区
            sem_t empty_count;//未使用的缓冲区
            int i;
            close(sockfd);
            struct msg *sm,*rm;
            pthread_t ptid1,ptid2;
            rm=(struct msg *)malloc(MAXSIZE+sizeof(struct msg));
            sm=(struct msg *)malloc(MAXSIZE+sizeof(struct msg));
            //初始化确认信息
            sm->type = MSG_ACK;
            sm->len = 0;
            gettimeofday(&start,NULL);
            //将消息结构体，拷贝进缓冲区
            void cpy_sm_to_buf(struct msg *sm)
            {

                sem_wait(&empty_count);
                memset(buf_ptr[rear],0x00,MAXSIZE);
                memcpy(buf_ptr[rear],sm,sizeof(struct msg)+sm->len);
                //更新队列状态
                rear = (rear+1)%BUF_COUNT;
                //控制线程2退出
                sem_post(&count);
            }
            //生产者，接收数据并放入缓存区
            void* producer(void *arg)
            {
                int th_new_fd= *(int *)arg;
                int  producer_flag = MAXSIZE;
                while( producer_flag != 0)
                {
                    if((numbytes = recv(th_new_fd,(void *)rm,sizeof(struct msg),0)) == -1)
                    {
                        perror("recv error");
                        exit(-1);
                    }
                    if(numbytes == 0)//判断客户端是否断开
                    {
                        printf("客户端已断开！\n");
                        exit(-1);
                    }
                    producer_flag = rm->len;

                    if((rm->type == MSG_DONE)||(rm->type == MSG_EXCEPTION))
                    {
                        cpy_sm_to_buf(rm);
                        break;
                    }
                    memset(rm->data,0x00,MAXSIZE);
                    if((numbytes = recv(th_new_fd,rm->data,rm->len,0)) == -1)
                    {
                        perror("recv error");
                        exit(-1);
                    }
                    cpy_sm_to_buf(rm);
                }
                free(rm);
                pthread_exit(NULL);
            }
            //消费者，将缓存区的内容写入文件
            void* consumer()
            {
                FILE *fp;
                int consume_flag = MAXSIZE;
                while(consume_flag != 0)
                {
                    sem_wait(&count);
                    consume_flag = buf_ptr[head]->len;
                    if(buf_ptr[head]->type == MSG_FILENAME)
                    {
                        if(buf_ptr[head]->len>256)
                        {
                            printf("文件名过长！\n");
                            exit(-1);
                        }
                        char file_name[256];
                        memset(file_name,0x00,256);
                        memcpy(file_name,buf_ptr[head]->data,buf_ptr[head]->len);
                        if((fp = fopen(file_name,"w+")) == NULL)
                        {
                            perror("fopen error");
                            exit(-1);
                        }
                    }
                    else if(buf_ptr[head]->type == MSG_CONTINUE)
                    {
                        if(fwrite(buf_ptr[head]->data,1,buf_ptr[head]->len,fp)<0)
                        {
                            printf("fwrite error\n");
                            exit(-1);
                        }
                    }
                    else if(buf_ptr[head]->type == MSG_DONE)
                    {
                        printf("send MSG_DONE!\n");
                        break;
                    }
                    else if(buf_ptr[head]->type == MSG_EXCEPTION)
                    {
                        printf("read the file failed！%d\n",buf_ptr[head]->type);
                        exit(-1);
                    }
                    else
                    {
                        printf("文件类型错误!rm->type=%d\n",buf_ptr[head]->type);
                        exit(-1);
                    }
                    //更新队列状态
                    head = (head+1)%BUF_COUNT;
                    sem_post(&empty_count);
                }
                fclose(fp);
                pthread_exit(NULL);
            }
            //为存放数据的缓冲去分配内存
            for(i=0; i<BUF_COUNT; i++)
            {
                buf_ptr[i]=(struct msg *)malloc(MAXSIZE+sizeof(struct msg));
            }
            if(sem_init(&count,0,0) == -1)
            {
                perror("sem_init error");
                exit(-1);
            }
            if(sem_init(&empty_count,0,BUF_COUNT) == -1)
            {
                perror("sem_init error");
                exit(-1);
            }
            gettimeofday(&start,NULL);
            pthread_create(&ptid1,NULL,producer,&new_fd);
            pthread_create(&ptid2,NULL,consumer,NULL);
            pthread_join(ptid1,NULL);
            pthread_join(ptid2,NULL);
            gettimeofday(&end,NULL);
            sem_destroy(&count);
            sem_destroy(&empty_count);

            printf("the time of receiving the file is %ld\n",(end.tv_sec - start.tv_sec)*1000000+(end.tv_usec - start.tv_usec));
            close(new_fd);
            free(sm);
            //释放缓冲队列
            for(i=0; i<BUF_COUNT; i++)
            {
                free(buf_ptr[i]);
            }
            exit(0);
        }
        //通过信号，防止僵尸进程
        signal(SIGCHLD,sig_child);
        //服务器端打印客户端的网址、端口号
        if(inet_ntop(AF_INET,&cliaddr.sin_addr,strptr,(socklen_t)sizeof(strptr)) == NULL)
        {
            perror("convert error");
            exit(-1);
        }
        printf("connect from %s,port is %d,pid is %d\n",strptr,ntohs(cliaddr.sin_port),pid);
        close(new_fd);
    }
    close(sockfd);
    return 0;
}


客户端：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
#include<time.h>
#include<pthread.h>
#include<sys/time.h>
#include<semaphore.h>
#define SERV_PORT 8888//服务端口号
#define MAXSIZE 1000//缓存队列可以存储的最大数据
#define BUF_COUNT 2//缓存去的个数
#define MSG_FILENAME 1
#define MSG_CONTINUE 2
#define MSG_ACK 3
#define MSG_DONE 4
#define MSG_EXCEPTION 5
//消息结构体
struct msg
{
    int type;
    int len;
    char data[];
};
sem_t count;//已经使用的缓冲区
sem_t empty_count;//未使用的缓冲区
int my_count;
int head;//队头指针
int rear;//队尾指针
struct msg *buf_ptr[BUF_COUNT];//缓冲区队列
//将消息结构体，拷贝进缓冲区
void cpy_sm_to_buf(struct msg *sm)
{
    sem_wait(&empty_count);
    memset(buf_ptr[rear],0x00,MAXSIZE);
    memcpy(buf_ptr[rear],sm,sizeof(struct msg)+sm->len);
    //更新队列状态
    rear = (rear+1)%BUF_COUNT;
    sem_post(&count);
}
//生产者，读取文件并放入缓存区
void* producer(void *arg)
{
    char *filepath=(char *)arg;
    FILE *fp;
    int i,j;
    int thread_exit_flag=0;
    int datalen;
    int produce_flag;
    struct msg *sm;
    sm = (struct msg*)malloc(MAXSIZE+sizeof(struct msg));
    //由文件路径获取文件名
    char file_name[256];
    memset(file_name,0x00,256);
    for(i=strlen(filepath)-1; i>=0; i--)
    {
        if(filepath[i] == '/')
        {
            break;
        }
    }
    for(j=i+1; j<strlen(filepath); j++)
    {
        file_name[j-i-1]=filepath[j];
    }
    sm->type = MSG_FILENAME;
    sm->len = strlen(file_name);
    memset(sm->data,0x00,MAXSIZE);
    memcpy(sm->data,file_name,sm->len);//将文件名拷贝到消息中
    cpy_sm_to_buf(sm);
//打开文件
    if((fp=fopen(filepath,"r")) == NULL)
    {
        perror("fopen error");
        exit(-1);
    }
//循环读取文件
    produce_flag = MAXSIZE;
    while(produce_flag == MAXSIZE)
    {
        sm->type = MSG_CONTINUE;
        memset(sm->data,0x00,MAXSIZE);
        if((datalen=fread(sm->data,1,MAXSIZE,fp)) == 0)
        {
            if(feof(fp))
            {
                printf("注意，文件为空！\n");
            }
            else
            {
                sm->type = MSG_EXCEPTION;
                sm->len = 0;
                memset(sm->data,0x00,MAXSIZE);
                cpy_sm_to_buf(sm);
                produce_flag = datalen;
                printf("fread error\n");
                exit(-1);
            }
        }
        sm->len = datalen;
        cpy_sm_to_buf(sm);
        produce_flag = datalen;
    }
    sm->type = MSG_DONE;
    sm->len = 0;
    memset(sm->data,0x00,MAXSIZE);
    cpy_sm_to_buf(sm);
    fclose(fp);
    free(sm);
    pthread_exit(NULL);
}
//消费者，将缓存区的内容发送到服务端
void* consumer(void *arg)
{
    int consufd = *(int *)arg;
    int i;
    int consume_flag = MAXSIZE;
    while(consume_flag != 0)
    {
        sem_wait(&count);
        //向服务端发送文件名消息
        consume_flag = buf_ptr[head]->len;
        if((send(consufd,buf_ptr[head],sizeof(struct msg)+buf_ptr[head]->len,0)) == -1)
        {
            perror("send error");
            exit(-1);
        }
        //更新队列状态
        head = (head+1)%BUF_COUNT;
        sem_post(&empty_count);
    }
    pthread_exit(NULL);
}
int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        printf("%s: input IP & filemane\n",argv[0]);
        return 1;
    }
    int i;
    head = 0;
    rear = 0;
    struct sockaddr_in their_addr;
    pthread_t ptid1,ptid2;
    int sockfd,numbytes;
    struct timeval start;
    struct timeval end;
    struct hostent *he;
    struct msg *rm;
    rm = (struct msg*)malloc(sizeof(struct msg)+MAXSIZE);
    //为存放数据的缓冲去分配内存
    for(i=0; i<BUF_COUNT; i++)
    {
        buf_ptr[i]=(struct msg *)malloc(MAXSIZE+sizeof(struct msg));
    }
    //将基本名字和地址转换
    he = gethostbyname(argv[1]);
    //建立一个TCP套接口
    if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        perror("socket");
        exit(1);
    }
    //初始化结构体
    their_addr.sin_family = AF_INET;
    their_addr.sin_port = htons(SERV_PORT);
    their_addr.sin_addr =*((struct in_addr *)he->h_addr);
    bzero(&(their_addr.sin_zero),8);
    //和服务端建立连接
    if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)
    {
        perror("connect");
        printf("%s\n",strerror(errno));
        exit(1);
    }
    if(sem_init(&count,0,0) == -1)
    {
        perror("sem_init error");
        exit(-1);
    }
    if(sem_init(&empty_count,0,BUF_COUNT) == -1)
    {
        perror("sem_init error");
        exit(-1);
    }
    gettimeofday(&start,NULL);
    pthread_create(&ptid1,NULL,producer,argv[2]);
    pthread_create(&ptid2,NULL,consumer,&sockfd);
    pthread_join(ptid1,NULL);
    pthread_join(ptid2,NULL);
    gettimeofday(&end,NULL);
    sem_destroy(&count);
    sem_destroy(&empty_count);
    printf("the time of sending the file is %ld\n",(end.tv_sec - start.tv_sec)*1000000+(end.tv_usec - start.tv_usec));
    //接受服务端发送的确认消息
    if((numbytes = recv(sockfd,(void *)rm,sizeof(struct msg),0)) == -1)
    {
        perror("recv error");
        exit(-1);
    }
    printf("send MSG_DONE!\n");
    close(sockfd);
    //释放缓冲队列
    for(i=0; i<BUF_COUNT; i++)
    {
        free(buf_ptr[i]);
    }
    free(rm);
    return 0;
}



由于使用到了多线程，编译的时候使用：gcc xxx.c -o xxx -lpthread

编译后使用:./server和./client 127.0.0.1文件路径即可运行

无聊的大石头
关注
  • 6
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
liunx上socket C++编程（可以实现图片、文件传输）
12-02
实际测试能传输大型文件，能与windows进行通讯，传输文件
RGMII
望都者
01-17 7321
RGMII（Reduced Gigabit Media Independent Interface）是Reduced GMII（吉比特介质独立接口）。GMII和RGMII均采用8位数据接口，工作时钟125MHz，因此传输速率可达1000Mbps。同时兼容MII所规定的10/100 Mbps工作方式，支持传输速率：10M/100M/1000Mb/s ，其对应clk 信号分别为：2.5MHz/25MH
小白也能搞通UDP通信（88E1111 RGMII 接口）
lzy13785490347的博客
09-21 3504
这些网络协议在FPGA实际开发的过程中用到的就是传输层、网络层、数据链路层和物理层，在我们的举例中用到UDP、IP、ARP协议，物理层就用88E1111（10/100/1000BASE-T IEEE 802.3 compliant ）的RGMII接口。
网络接口设计1-明晰MII GMII RGMII XAUI
hhpingyear的博客
05-06 3555
       MII（Medium Independent Interface）“介质独立接口”，该接口一般应用于以太网硬件平台的MAC层和PHY层之间。MII接口的类型有很多，常用的有MII、RMII、SMII、SSMII、SSSMII、GMII、RGMII、SGMII、TBI、RTBI、XGMII、XAUI、XLAUI等。下面对其中几个常见的进行介绍。  MII：  RXD(Receive D...
【必读】从MII到RGMII，一文了解以太网PHY芯片不同传输接口信号时序！
最新发布
weixin_50810761的博客
12-24 2858
本文主要讲解以太网PHY芯片与MAC数据传输的几种接口，详细MII、RMII、GMII、RGMII的接口信号和时序。
Linux下发送与接收组播数据(socket编程)
热门推荐
恨天低
06-14 1万+
Sender.cpp #include #include #include #include #include #include #include #include #include #define HELLO_PORT 12345 #define H
Linux C Socket局域网文件互传
a44645的博客
04-17 529
本人刚接触c/c++不是特别久，所以很多地方的写法可能会比较蠢和复杂化，思路也不是特别明确，各位请见谅.. 代码是在安卓手机软件"C4droid"上开发运行的，运行环境是linux. 程序即是客户端也是服务端，第一次使用先定义自己的用户名,用户名保存在本地文件中. 可以拿两部手机来测试，进入程序后，先输入'1'进行局域网嗅探在线的用户，时间可能比较久。 然后输入2文件传输，再输入需要配对用户的id即可进行传输. 另一台手机 代码: #include <s...
linux c 发送文件内容,关于linux c中 用socket发送txt文件解决方案
weixin_42503645的博客
04-30 171
C/C++ code#include #include #include #include #include #include #include #include #include /*stat用到*/#define BUFFER_SIZE 1024unsigned long get_file_size(char filename) /*定义一个用来获取文件大小的函数*/{stru...
Linux 下使用C++面向对象实现socket通信
人间世
03-10 1359
0X00 什么是Socket通信 我们知道，在网络编程中，socket通信是入门级编程。就像是你学一门语言，就先用这门语言写出Hello World。所以我们今天就先写出这Hello World。 Socket通信，也就是我们所说的套接字，这是进程间的一种通信方式，但与其它通信方式不一样的是，套接字可以通过网络进行传输。 我们知道的是，Socket通信是一种通信。通信通信，总该有两个对象才能进行相...
浅谈 Linux C语言 socket 网络编程
君君的博客
03-05 503
注意：本文是按照 TCP、UDP的工作过程进行总结的 TCP套 socket 接口编程： 基于TCP的 客户/服务器（C/S）模式的工作过程如下： image 服务器进程中的一些函数： socket()： /* 函数所需头文件及其原型 */ #include <sys/socket.h> int socket( int family, int type, int protocol); socketfd = soket(AF_INET, SOCK_STREAM
C语言实现Linux下的socket文件传输实例
09-03
主要介绍了C语言实现Linux下的socket文件传输的方法,较为详细的分析了C语言文件Socket文件传输客户端与服务器端相关实现技巧,需要的朋友可以参考下
linux c 实现通过socket传输文件(M)
01-30
tcp传输； 编译前需要自己指定文件路径和文件名等； 编译方式参见compile.txt；
使用socket的Linux上的C语言文件传输顺序服务器和客户端示例程序
01-03
利用socket作为桥梁，实现linux系统下服务器与客户端之间的传输。资源包含代码和说明。
linux环境下C语言实现图片的socket传输并保存到数据库
05-22
压缩包内包含客户端imclient.c 服务端imserver.c 以及makefile，测试在64位centos机器下运行，需要安装mysql数据。程序流程，客户端通过读取图片数据然后通过socket将图片数据发送给服务端，服务端接收数据后，插入数据库。注意;数据库字段位blob类型，UTF8编码格式。
Linux环境下C语言Socket编程——客户端向服务端单次发送一个或多个文件的功能
03-23
网上很多有关socket文件传输的源码都是每次只能发送一个文件，如果想传输多个文件，不但需要多次交互，还需要把每个文件的文件名都输入进去，很不方便，所以进行了一个小扩展：即客户端可以将打算传送的多个文件都先...
Linux下C语言socket网络编程简例
01-09
　这里给出在linux下的简单socket网络编程的实例，使用tcp协议进行通信，服务端进行监听，在收到客户端的连接后，发送数据给客户端；客户端在接受到数据后打印出来，然后关闭。程序里有详细的说明，其中对具体的...
Linux网络编程之socket文件传输示例
01-20
本文所述示例程序是基于Linux平台的socket网络编程，实现文件传输功能。该示例是基于TCP流协议实现的socket网络文件传输程序。采用C语言编写。最终能够实现传输任何格式文件的文件传输程序。 具体实现代码如下： ...
linux下C语言SOCKET编程客户端、服务器端代码
11-04
linux下C语言SOCKET编程客户端、服务器端代码
c语言 ofstream flush
05-30
很抱歉，你可能有些误解。C语言中没有 `ofstream` 和 `flush` 这两个关键词。它们是C++中用于文件操作和缓冲刷新的语法。 `ofstream` 是一个C++中用于输出文件的类，可以创建一个文件并向其中写入数据。在C语言中，可以使用标准库函数 `fopen()` 和 `fprintf()` 来进行文件的打开和写入操作。 `flush` 是一个函数，用于刷新输出缓冲区。在C++中，当我们使用 `cout` 输出数据时，数据会被存储在缓冲区中，而不是立即输出到屏幕上。如果我们想要立即输出缓冲区中的所有数据，可以使用 `cout.flush()` 函数。在C语言中，可以使用 `fflush()` 函数来完成同样的功能。 希望我的回答能够帮助你理解这些概念。如果你有其他问题，可以继续问我哦。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值