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

最新推荐文章于 2023-10-17 09:12:49 发布
最新推荐文章于 2023-10-17 09:12:49 发布
阅读量6k 收藏 30
点赞数 7
分类专栏： 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文件路径即可运行

无聊的大石头
关注
专栏目录
【C语言】Linux socket 编程
数字人生
01-03 1753
在 TCP 连接中，`close()` 函数的执行将启动 TCP 连接的终止过程，通常称为四次挥手（four-way handshake）。函数在 Socket 编程中用于将一个未连接的 socket 转换成一个被动的监听 socket，指示内核应当接受指向该 socket 的连接请求。在 Linux 系统中，socket 是一种特殊的文件描述符，用于在网络中的不同主机间或者同一台主机中的不同进程间进行双向通信。函数时，如果存在待处理的连接请求，它会创建一个新的已连接套接字，并从队列中移除该请求。
liunx上socket C++编程（可以实现图片、文件传输）
12-02
实际测试能传输大型文件，能与windows进行通讯，传输文件
Linux C Socket局域网文件互传
a44645的博客
04-17 608
本人刚接触c/c++不是特别久，所以很多地方的写法可能会比较蠢和复杂化，思路也不是特别明确，各位请见谅.. 代码是在安卓手机软件"C4droid"上开发运行的，运行环境是linux. 程序即是客户端也是服务端，第一次使用先定义自己的用户名,用户名保存在本地文件中. 可以拿两部手机来测试，进入程序后，先输入'1'进行局域网嗅探在线的用户，时间可能比较久。 然后输入2文件传输，再输入需要配对用户的id即可进行传输. 另一台手机 代码: #include <s...
linux c 发送文件内容,关于linux c中 用socket发送txt文件解决方案
weixin_42503645的博客
04-30 211
C/C++ code#include #include #include #include #include #include #include #include #include /*stat用到*/#define BUFFER_SIZE 1024unsigned long get_file_size(char filename) /*定义一个用来获取文件大小的函数*/{stru...
C语言 Socket入门示例1—— 单工通信（客户端向服务器发送消息）
热门推荐
lynch0571的专栏
05-04 1万+
如果对Windows API不太熟悉、对TCP/IP通信协议不太熟悉，或者对C语言本身不太熟悉的话，学习Socket会有点难受的。以前学习操作系统的时候，被API吓怕了，很多莫名其妙的API有着多如牛毛的参数，令人费解。学习计算机网络的时候，又有那么多的协议，并且很多协议本身比较复杂，什么三次握手建立连接，什么四次握手释放链接等等，也没有学得特别透彻。更遗憾的是，以前学C的时候，误以为自己把C学会
C 实现socket 数据互传
jojo2333的博客
03-20 696
因为参加某场测试偶然拿到了这样一个题目 之前完全没有接触过计算机网络问题 写的比较粗糙 发上来做个记录日后进行优化 主体思想如图 根据服务器与客户端的此原理以及 传入传出函数 Òrecv()/send() Òsend(intsockfd, constvoid *buf, size_tlen, intflags); Òrecv(intsockfd,void *buf,
Linux环境下C语言Socket编程——客户端向服务端单次发送一个或多个文件的功能
03-23
网上很多有关socket文件传输的源码都是每次只能发送一个文件，如果想传输多个文件，不但需要多次交互，还需要把每个文件的文件名都输入进去，很不方便，所以进行了一个小扩展：即客户端可以将打算传送的多个文件都先...
Linux下C语言编程（聊天室）
03-04
综上所述，"Linux下C语言编程（聊天室）"项目涵盖了C语言基础、网络编程、多线程/进程编程、文件操作、协议设计等多个核心领域，对于提升Linux系统开发能力具有很高的实践价值。通过这个项目，开发者不仅可以学习到...
C语言实现Linux下的socket文件传输实例
09-03
在C语言中，实现Linux下的socket文件传输涉及网络编程的基本概念和函数，主要分为服务器端和客户端两部分。本文将详细解析如何使用C语言在Linux系统中通过socket接口进行文件的传输。 首先，我们来看服务器端的代码...
Linux下C语言socket网络编程简例
01-09
　这里给出在linux下的简单socket网络编程的实例，使用tcp协议进行通信，服务端进行监听，在收到客户端的连接后，发送数据给客户端；客户端在接受到数据后打印出来，然后关闭。程序里有详细的说明，其中对具体的...
Linux socket（套接字编程）编程 （图片 文字 文件传输
12-15
文件包含服务器端和客户端，是基于Linux下的套接字（socket）编程，能够传输图片、文件、文字。
Linux下使用串口发送数据
05-15
在Linux系统下实现读取文件内容，并使用串口发送。串口为RS232.
14.9 Socket 高效文件传输
最新发布
CSDN
10-17 5248
网络上的文件传输功能也是很有必要实现一下的，网络传输文件的过程通常分为客户端和服务器端两部分。客户端可以选择上传或下载文件，将文件分块并逐块发送到服务器，或者从服务器分块地接收文件。服务器端接收来自客户端的请求，根据请求类型执行对应的操作，并根据发送的文件名或其他标识来确定要传输的文件。
socket网络通信，传输文件，c/c++
qq_44711805的博客
09-24 1754
当我们在实现网络通信时，避免不了发送文件，在这里给出基于tcp协议的文件传输，使用C语言编写，当然此程序亦可以传输字符串，详情请看我的上一篇博客，以下先给出发送文件需要用到的函数，再对socket套接字进行初始化，最后给出main函数。
C语言----详解socket通信
ftzchina的博客
09-01 7321
刚接触socket的同学想必也知道socket的中文名，套接字，与其说是中文名倒不如说这是什么玩意，我们先不要管中文名的实际意义，我们先来了解一下什么是socket。我们上网产生的数据都是经过协议栈一层一层的封装然后经网卡发送到网络，经网络发送到服务端，然后服务端又是一层一层的解封装拿到自己想要的数据。对于协议栈都是集成在操作系统里，我们并不需要关心TCP,UDP等这些协议是如何实现的，我们关心的是我们的应用程序的数据能不能正常的发送出去和接收服务端发回来的数据。
linux socket 结构定义 send,Linux下Socket编程中用send发送结构体
weixin_33539912的博客
05-14 191
Linux网络通信 Linux下多客户端聊天软件最近在开发一个Linux下的聊天软件，好久没有做C语言的开发了，感觉到很多东西已经生疏了，这下又碰到用Socket传递结构体的问题，google了一下，发现也有不少朋友遇到同样的问题，所以就打算写出自己的解决办法，跟大家分享。Socket中的send函数可以发送字符串，但不能直接发送结构体，因此在发送端先把结构体转成字符串，然后用send发送，在接收...
Socket编程（c语言示例）
好记性不如写博客！
11-09 9889
前言                Socket可以看成在两个程序进行通讯连接中的一个端点，是连接应用程序和网络驱动程序的桥梁，Socket在应用程序中创建，通过绑定与网络驱动建立关系。此后，应用程序送给Socket的数据，由Socket交网络驱动程序向网络上发送出去。计算机从网络上收到与该Socket绑定IP地址和端口号相关的数据后，由网络驱动程序交给Socket，应用程序便可从该Socket
Linux 下使用C++面向对象实现socket通信
人间世
03-10 1414
0X00 什么是Socket通信 我们知道，在网络编程中，socket通信是入门级编程。就像是你学一门语言，就先用这门语言写出Hello World。所以我们今天就先写出这Hello World。 Socket通信，也就是我们所说的套接字，这是进程间的一种通信方式，但与其它通信方式不一样的是，套接字可以通过网络进行传输。 我们知道的是，Socket通信是一种通信。通信通信，总该有两个对象才能进行相...
Linux 利用socket实现文件传输
qigaohua的博客
10-29 4166
文章目录一、要求二、实现提示：三、程序四、现象     一、要求   利用Linux Socket进行文件传输，本次只支持client端向sever端上传文件   二、实现提示： client.c client的参数有两个，分别是服务器主机名和端口； 在while循环中输入你想要传输的文件名，然后建立socket，通过服务器主机名和端口连接服务器； 打开文件，在wh...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值