Socket网络编程--小小网盘程序(4)

　　在这一小节中实现了文件的下载，具体的思路是根据用户的uid和用户提供的文件名filename联合两张表，取得md5唯一标识符，然后操作这个标识符对应的文件发送给客户端。

　　实现下载的小小网盘程序

　　client.cpp增加下面这个函数以实现文件的下载。

int file_pull(struct Addr addr,struct User user,char *filenames)
{
    struct sockaddr_in servAddr;
    struct hostent *host;
    struct Control control;
    struct File file;
    int sockfd;
    FILE * fp=NULL;

    host=gethostbyname(addr.host);
    servAddr.sin_family=AF_INET;
    servAddr.sin_addr=*((struct in_addr *)host->h_addr);
    servAddr.sin_port=htons(addr.port);

    if(host==NULL)
    {
        perror("获取IP地址失败");
        exit(-1);
    }
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        perror("socket创建失败");
        exit(-1);
    }
    if(connect(sockfd,(struct sockaddr *)&servAddr,sizeof(struct sockaddr_in))==-1)
    {
        perror("connect 失败");
        exit(-1);
    }

    //传输控制信号
    control.control=FILE_PULL;
    control.uid=user.uid;
    if(send(sockfd,(char *)&control,sizeof(struct Control),0)<0)
    {
        perror("控制信号发送失败");
        exit(-1);
    }
    strcpy(file.filename,filenames);
    file.uid=user.uid;
    if(send(sockfd,(char *)&file,sizeof(struct File),0)<0)
    {
        perror("文件指纹发送失败");
        exit(-1);
    }
    if((fp=fopen("data","wb"))==NULL)
    {
        perror("文件打开失败");
        exit(-1);
    }
    int size=0;
    int data_len=0;
    char buffer[BUFFER_SIZE];
    memset(buffer,0,sizeof(buffer));
    recv(sockfd,buffer,64,0);
    if(buffer[0]=='n')
    {
        printf("服务器中没有该文件，请确认后再输入，如不知道是否有文件，可以使用file list查看
");
        return 0;
    }
    memset(buffer,0,sizeof(buffer));
    while(data_len=recv(sockfd,buffer,BUFFER_SIZE,0))
    {
        if(data_len<0)
        {
            perror("接收数据有误");
        }
        size++;
        if(size==1)
        {
            printf("正在接收来自服务器的文件");
        }
        else
        {
            printf(".");
        }
        int write_len=fwrite(buffer,sizeof(char),data_len,fp);
        if(write_len>data_len)
        {
            perror("写入数据有误");
        }
        bzero(buffer,BUFFER_SIZE);
    }
    printf("
文件接收完毕
");
    fclose(fp);
    rename("data",filenames);
    close(sockfd);
    return 0;
}

　　server.cpp 同样的实现一个相同的功能

int main(int argc,char *argv[])
{
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    struct User user;
    struct Control control;
    char ch[64];
    int clientfd;
    pid_t pid;
    socklen_t length;
    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    server_addr.sin_addr.s_addr=htons(INADDR_ANY);
    server_addr.sin_port=htons(SERVER_PORT);

    //创建套接字
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        perror("创建套接字失败");
        exit(-1);
    }

    if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr))==-1)
    {
        perror("bind 失败");
        exit(-1);
    }

    if(listen(sockfd,LISTEN_QUEUE))
    {
        perror("listen 失败");
        exit(-1);
    }

    length=sizeof(struct sockaddr);

    while(1)
    {
        clientfd=accept(sockfd,(struct sockaddr *)&client_addr,&length);
        if(clientfd==-1)
        {
            perror("accept 失败");
            continue;
        }
        printf(">>>>>%s:%d 连接成功，当前所在的ID(fd)号: %d 
",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),clientfd);
        print_time(ch);
        printf("加入的时间是:%s
",ch);

        //来一个连接就创建一个进程进行处理
        pid=fork();
        if(pid<0)
        {
            perror("fork error");
        }
        else if(pid==0)
        {
            recv(clientfd,(char *)&control,sizeof(struct Control),0);
            printf("用户 %d 使用命令 %d
",control.uid,control.control);
            switch(control.control)
            {
                case USER_CHECK_LOGIN:
                    {
                        //身份验证处理
                        recv(clientfd,(char *)&user,sizeof(struct User),0);
                        printf("客户端发送过来的用户名是:%s,密码:%s
",user.username,user.password);
                        if((user.uid=mysql_check_login(user))>0)
                        {
                            printf("验证成功
");
                        }
                        else
                        {
                            printf("验证失败
");
                        }
                        send(clientfd,(char *)&user,sizeof(struct User),0);
                        break;
                    }
                case FILE_PUSH:
                    {
                        char buffer[BUFFER_SIZE];
                        int data_len;
                        FILE * fp=NULL;
                        struct File file;
                        //获取文件指纹
                        recv(clientfd,(char *)&file,sizeof(struct File),0);
                        printf("获取到的用户名ID: %d 文件名:%s  MD5:%s
",file.uid,file.filename,file.md5);
                        //对文件进行验证，如果文件已经存在就不用进行接收了
                        int t=mysql_check_md5(file);
                        char ch[64]={0};
                        printf("t=%d
",t);
                        if(t!=0)
                        {
                            printf("该文件存在,使用秒传功能
");
                            strcpy(ch,"yes");
                            send(clientfd,ch,64,0);
                            mysql_file_in(file.uid,t);
                            //continue;
                        }
                        strcpy(ch,"no");
                        send(clientfd,ch,64,0);
                        printf("md5验证后得到的fid:%d
",t);
                        bzero(buffer,BUFFER_SIZE);
                        if((fp=fopen("data","wb"))==NULL)
                        {
                            perror("文件打开失败");
                            exit(-1);
                        }
                        //循环接收数据
                        int size=0;//表示有多少个块
                        while(data_len=recv(clientfd,buffer,BUFFER_SIZE,0))
                        {
                            if(data_len<0)
                            {
                                perror("接收数据错误");
                                exit(-1);
                            }
                            size++;
                            if(size==1)
                                printf("正在接收来自%s:%d的文件
",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                            else
                                printf(".");
                            //向文件中写入
                            int write_len=fwrite(buffer,sizeof(char),data_len,fp);
                            if(write_len>data_len)
                            {
                                perror("写入数据错误");
                                exit(-1);
                            }
                            bzero(buffer,BUFFER_SIZE);
                        }
                        if(size>0)
                        {
                            printf("
%s:%d的文件传送完毕
",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                            //如果文件传输成功那么就可以写入数据库了
                            mysql_file_in(file);
                        }
                        else
                            printf("
%s:%d的文件传送失败
",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                        fclose(fp);
                        rename("data",file.md5);//这里可以修改文件的名字
                        exit(0);
                        break;
                    }
                case FILE_PULL:
                    {
                        struct File file;
                        char ch[64];
                        memset(ch,0,sizeof(ch));
                        //获取接下来要发送的文件
                        recv(clientfd,(char *)&file,sizeof(struct File),0);
                        //根据uid和filename获取服务器中的唯一文件，然后发送
                        int t=mysql_get_md5_from_file(&file);
                        printf("获取到的MD5:%s
",file.md5);
                        if(t==-1||file.md5[0]==0)//服务器没有对应的文件
                        {
                            printf("没有对应的文件
");;
                            strcpy(ch,"no");
                            send(clientfd,ch,64,0);
                            continue;
                        }
                        strcpy(ch,"yes");
                        send(clientfd,ch,64,0);

                        FILE * fp = NULL;
                        if((fp=fopen(file.md5,"rb"))==NULL)
                        {
                            perror("文件打开失败");
                        }
                        char buffer[BUFFER_SIZE];
                        bzero(buffer,BUFFER_SIZE);
                        printf("正在传输文件");
                        int len=0;
                        while((len=fread(buffer,sizeof(char),BUFFER_SIZE,fp))>0)
                        {
                            if(send(clientfd,buffer,BUFFER_SIZE,0)<0)
                            {
                                perror("发送数据失败");
                            }
                            bzero(buffer,BUFFER_SIZE);
                            printf(".");
                        }
                        printf("传输完成
");
                        fclose(fp);
                        break;
                    }
                case FILE_LIST:
                    {
                        break;
                    }
                case FILE_DELECT:
                    {
                        break;
                    }
                default:
                    {
                        break;
                    }
            }
            shutdown(clientfd,2);//这里要注意加一个shutdown否则客户端接收不到结束符而一直等待接收数据。普通的close是不会发送结束符的
            close(clientfd);//短连接结束
            exit(0);//退出子进程
        }
    }

    return 0;
}

///////////////////

int mysql_get_md5_from_file(struct File * file)
{
    //select md5 from files,relations where files.fid=relations.fid and file.md5=file.md5;
    MYSQL conn;
    MYSQL_RES * res_ptr;
    MYSQL_ROW result_row;
    int res;int row;int column;
    int rt;
    char sql[256]={0};
    rt=0;
    strcpy(sql,"select md5 from files,relations where files.fid=relations.fid and files.filename="");
    strcat(sql,file->filename);
    strcat(sql,""");
    printf("查询的sql:%s
",sql);
    mysql_init(&conn);
    if(mysql_real_connect(&conn,"localhost","root","","filetranslate",0,NULL,CLIENT_FOUND_ROWS))
    {
        res=mysql_query(&conn,sql);
        if(res)
        {
            perror("select sql error!");
        }
        else
        {
            res_ptr=mysql_store_result(&conn);
            if(res_ptr)
            {
                column=mysql_num_fields(res_ptr);
                row=mysql_num_rows(res_ptr)+1;
                if(row<=1)
                {
                    ;
                }
                else
                {
                    result_row=mysql_fetch_row(res_ptr);
                    if(result_row[0]==NULL)
                    {
                        rt=-1;
                        strcpy(file->md5,"");
                    }
                    else
                        strcpy(file->md5,result_row[0]);
                }
            }
            else
            {
                rt=-1;
                printf("没有数据
");
            }
        }
    }
    else
    {
        perror("Connect Failed1");
        exit(-1);
    }
    mysql_close(&conn);
    return rt;
}

　　mysql_get_md5_from_file这个函数是利用用户的uid和文件名进行查询的。因为保存在服务器中的文件是以MD5的值作为文件名的(目的是不同的用户可以有相同的文件名，但是所对应的文件确实不同的)，查询后返回一个唯一文件标识MD5值，根据这个值取得文件然后发送给客户端。

　　还有一个要注意的是在server.cpp的199行处，使用了shutdown来结束服务器的发送，一开始我没有使用该函数，造成的结果是服务器发送数据后，调用close，调用exit退出子进程，结束socket连接。虽然是关闭了socket，但是在客户端却在recv处一直处于阻塞，好像是还有数据没有接收完。经过调试还有查资料才知道，这里要调用shutdown，否则客户端接收不到结束符而一直等待接收数据。普通的close是不会发送结束符的。

　　#include <sys/socket.h>

　　int shutdown(int sockfd, int how);  //返回值: 如果成功则返回0，否则出错返回-1

　　套接字通信是双向的。可以采用函数shutdown来禁止套接字上的输入/输出。如果how是SHUT_RD(关闭读端 0 )，那么就无法从套接字读取数据；如果how是SHUT_WR(关闭写端 1 )，那么无法使用套接字发送数据；使用SHUT_RDWR则将同时无法读取和发送数据(2).

　　既然能够close关闭套接字，那么为什么还要用shutdown呢？理由如下：首先，close只有在最后一个活动引用被关闭时才释放网络端点【这就是为什么我以前的章节可以用close来结束上传，那是因为客户端的发送数据是在一个函数里面的一个连接，函数结束，连接也就断了。而这次出现不能下载，就是因为我的服务器是使用多进程的，而进程clientfd实在fork的前面定义的，所以当发送完毕后调用close是因为clientfd还被引用到，而不是最后一个活动应用】。这意味着如果复制一个套接字(如采用dup)，套接字直到关闭了最后一个引用它的文件描述符之后才会被释放。而shutdown允许使一个套接字处于不活动状态，无论引用它的文件描述符数目多少。其次，有时只有关闭套接字双向传输中的一个方向会很方便。例如，如果想让所通信的进程能够确定数据发送何时结束，可以关闭该套接字的写端，然而通过该套接字读端仍然可以继续接收数据。

 　　下面给出运行时的截图

　　运行的顺序具体看一下命令就知道了，最后出现了一个问题，就是使用不同的用户居然可以下载src这个文件，想想应该是数据库sql没有写好。我们修改如下：

　　在上面server.cpp代码的第222行处加上下面代码即可，实现对用户的权限控制。

    strcat(sql," and relations.uid=");
    sprintf(ch,"%d",file->uid);
    strcat(sql,ch);
    strcat(sql,";");

　　好了，至此我们已经实现了文件的上传和下载了，并且还能进行用户权限的控制。话说FTP是不是就差不多这个样子啊。

 

　　本文地址: http://www.cnblogs.com/wunaozai/p/3892729.html