©2020-2024 ioDraw All rights reserved,
Privacy Policy
<>TCP/IP通信：实现客户-服务器之间的通信、文件上传与下载
<>通信流程：
<>（一）搭建服务器（server）
<>1. socket 创建套接字
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：socket 函数功能：创建一个通信端口 参数1：
int domain ：使用的协议族 参数2：type ：套接字的类型 参数3：protocol ：默认为0 返回值：int 成功->
创建的新的套接字的文件描述符，失败->-1和错误代码 int socket(int domain , int type , int protocol);
<>参数1：通信协议
是通信协议族，使用Lunix命令【man socket】可以查看他的手册：
<>
为了实现稳定的TCP通信，传入AF_INET，标识使用IPv4网络协议。
<>参数2：数据传输方式/套接字类型
SOCK_STREAM:流式套接字，TCP使用
SOCK_DGRAM:数据报套接字，UDP使用
<>参数3：protocol：默认为0
<>2. bind 绑定
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：bind
函数功能：给socket绑定IP和端口（需要被找到的套接字才需要被绑定） 参数1：int sockfd：创建出来的新的套接字的文件描述符 参数2：const
struct sockaddr *addr:存储自己的IP地址、端口的结构的结构体首地址 参数3：socklen_t addrlen :
addrlen结构体的大小 返回值：int 成功->返回0，失败->-1和错误代码 int bind(int sockfd , const struct
sockaddr*addr , socklen_t addrlen); struct sockaddr { sa_family_t sa_family;
//地址族 char sa_data[14]; //14字节，包含套接字中的目标地址和端口信息 };
需要注意的是：bind主要用于服务器端，客户端创建的套接字可以不绑定地址
TCP搭建服务器使用的地址结构并不是struct sockaddr , 而是struct sockaddr_in
struct sockaddr_in { short int sin_family; //网络协议 unsigned short int sin_port;
//端口号 struct in_addr sin_addr; //32位IP地址 };
sockaddr_in结构体内还包含一个结构体：struct in_addr
struct in_addr { unit32_t s_addr; //32位IP地址 };
<>3. listen 监听
listen本质上是一个监听队列，在accept接收客户端连接之前，对将要链接的套接字进行标记。如果监听队列已经满了，再有新的客户端发起连接请求时，则无法监听，此时客户端可能会收到连接被拒绝的错误。
服务器端成功建立套接字并与地址进行绑定后，调用listen函数，将套接字标记为被动（监听模式）。准备接收客户端的连接请求
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：listen 参数1：int sockfd:
监听套接字文件描述符（即socket创建，被bind绑定的套接字） 参数2：int backlog:监听队列的大小 返回值：int 成功返回0， 失败返回-1
和错误代码int listen(int sockfd , int backlog);
<>4. accept 连接
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：accpet 函数功能：接收一个套接字的连接请求
参数1：int sockfd :监听套接字的文件描述符（经过listen的sockfd） 参数2：struct sockaddr *addr :
用来存储对方（客户端）地址结构的内存首地址 【对方的IP地址和端口号】 参数3：socklen_t *addrlen：存储地址结构信息长度变量的地址
返回值：成功->通信套接字的文件描述符，失败返回-1和错误代码 int accept(int sockfd , struct sockaddr *addr ,
socklen_t*addrlen);
accept接受连接的方式有两种：
1：不关心客户端的IP地址和端口号时，参数2和参数3设置为NULL
2：若要读取并保存客户端的IP地址和端口号，则需要新建一个socket_in结构体
做完前四步后就可以进行通信了。TCP/IP提供了一种通信方式：send函数和recv函数
<>
<>5. send
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：send 函数功能：通过socket发送数据 参数1
：int sockfd：通信套接字的文件描述符 参数2：const void *buf :被发送的数据的首地址 参数3： sizeof_t
len：想要发送的字节数（数据长度） 参数4：int flags：默认为0 返回值：ssize_t 类型。成功->返回成功发送的字节数，失败->返回-
和错误代码 ssize_tsend(int sockfd , const void *buf , size_t len , int flags);
<>6. recv
头文件：#include<sys/types.h> #include<sys/socket.h> 函数名：recv 函数功能：通过socket接收数据 参数1
：int sockfd ：通信套接字的文件描述符 参数2：const void *buf：用来存储接收的数据的内存首地址 参数3：size_t len
：想要接收的字节数（数据长度） 参数4：int flags：默认为0 返回值：ssize_t类型；成功->返回成功接收道德字节数，失败->返回-1 和错误码；0
：表示对端执行了一个有序关闭。
<>7. close
通信结束，关闭连接
如果malloc申请了空间，则需要free释放
如果打开了文件，则需要关闭fd
最后close(套接字)
<>以上时搭建TCP服务器的流程，一共分为7个步骤，其中前三个步骤可以打包为一个子函数。
<>（二）搭建客户端（client）
客户端的搭建较为简单，只需四个步骤：socket-connect-send/recv-close
<>1. socket ---->参考上面服务器介绍
<>2.connect
头文件：#include <sys/types.h> #include <sys/socket.h> 函数功能：发起一个socket的连接请求 参数1：int
sockfd：客户端socket函数创建的套接字的文件描述符 参数2：const struct sockaddr *addr：
存储服务器的IP地址和端口结构的内存首地址 参数3：socklen_t addrlen：addr只想的内存空间大小 返回值：int类型：成功->返回0，失败->
返回-1和错误码 int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
;
<>3.send /recv ---->参考上面服务器介绍
<>4.close
介绍完客户-服务器的搭建流程，开始写代码
<>代码实现
<>server【服务器端】
//服务器端模块化 //编写一子函数,实现监听客户端连接服务器 //参数1:IP地址 char * ip //参数2:端口号 int port
//返回值:成功->返回监听的socket对象,失败返回-1 int tcp_server(char * ip , int port); //函数实现 nt
tcp_server(char * ip , int port) //子函数实现 { //1.创建socket对象TCP //2.绑定自己的IP地址&端口号
//3.监听是否有人链接 //1.创建socket对象TCP int tcp_fd = -1; // tcp_fd = socket(AF_INET ,
SOCK_STREAM, 0); //1.1判断是否绑定成功 if(0 > tcp_fd) { perror("socket error!"); return
-1; } puts("socket success!"); //2.绑定自己的IP地址&端口号 //结构体见顶部注释 struct sockaddr_in
myaddr; //定义一个结构体myaddr,数据类型为struct sockaddr_in myaddr.sin_family = AF_INET;
//协议 myaddr.sin_port = htons(port); //端口号,atoi()意思是将主机字节序转换为网络字节序 myaddr.
sin_addr.s_addr = inet_addr(ip);//IP地址 //2.2bind if(bind(tcp_fd , (struct
sockaddr*)&myaddr , sizeof(myaddr)) < 0) { perror("bind error!"); //打印错误原因 close
(tcp_fd); //关闭 return -1; } puts("bind success!"); //3.监听是否有人链接 if(0 > listen(
tcp_fd, 5)) //参数2:监听队列的大小,一般设置为5 { perror("listen error!"); close(tcp_fd);
return -1; } puts("listen success!"); return tcp_fd; //监听成功,返回socket对象tcp_fd }
接下来时accept和通信
//编写一子函数,和客户端进行通信 //参数:accept后新生成的socket对象 //返回值:void int
tcp_server_communiction(int acp_fd); //函数实现 int tcp_server_communiction(int
acp_fd) { //5.1:收 //5.1.1:入参判断 if(0 > acp_fd) { perror("This acp_fd is NULL!");
return -1; } //5.1.2: acp_fd的格式正确,首先接受client客户端发送的数据 char buf[1024];
//定义一个数组,存储收发的文件 memset(buf , 0 , sizeof(buf)); //清空数组 //read(lst_fd , buf ,
sizeof(buf)); //将客户端发送的数据通过IO文件操作中的read方式读入到该数组中 //换第二种文件操作方式:
send和recv,这是TCP/IP自带的一种文件收发方式 int rec = -1; //定义一个变量rec用于接收recv()函数的返回值 rec =
recv(acp_fd , buf , sizeof(buf) , 0);//执行接收函数 //5.1.3:判断是否接收成功 if(0 > rec) {
perror("recv error!"); return -1; } //接收正常,但还要判断是否为空数据 if(0 < buf) {
//证明数组中接收到了客户端发来的数据 puts("buf"); char ncmd[10] = {0};
//用来存放客户端的操作方式:是上传[up]还是下载[down] char filename[64] = {0}; //用于存放客户端要操作的对象名字
//还需要定义一个子函数,以解析客户端发来的命令 analysis_cmd(buf , ncmd , filename);
//调用命令解析函数,将客户端发送的命令和文件名解析出来,并且存储到前面定义的ncmd[]和filename[]数组中 printf("%s\n" , ncmd
); printf("%s\n" , filename); //成功拿到命令和文件名 //下载文件 if(0 == strcmp(ncmd , "down"))
//调用字符串比较函数,两个字符串相同则返回0 { //下载文件 int fd = open(filename , O_RDONLY);
//fn:文件名,O_RDONLY:以只读的方式打开文件 //判断文件是否打开成功 if(0 > fd) {
//fd为open函数的返回值,小于0表明文件打开失败 char msg[30] = "文件不存在";
//调用send函数,将这个字符串发送给client客户端 send(acp_fd , msg , sizeof(msg) , 0); return -1; }
else { //文件打开成功 int len = lseek(fd , 0 , SEEK_END); printf("要发送的文件长度为:%d\n" ,
len); char fl[30] = {0}; sprintf(fl , "lend:%d" , len);//将计算到的文件长度输出重定向到fl[]数组中
//将文件长度先返回给客户端,以便于客户端创建一个同等大小的数组用于接收文件 send(acp_fd , fl , sizeof(fl) , 0);//发送
//然后准备发送文件 //由于lseek已经指向文件末尾了,所以需要让他回到文件开头 lseek(fd , 0 , SEEK_SET);
//SEEK_SET:文件的起始位置 /*大文件需要在栈区申请空间*/ char *picture = NULL; //创建一个图片指针 picture = (
char *)malloc(len); //为这个指针开辟一片内存空间 //判断是否开辟成功 if(NULL == picture) { perror(
"malloc error!"); return -1; } //开辟成功 //清空 memset(picture , 0 , sizeof(picture))
; int red = read(fd , picture , len); //判断是否读取文件成功 if(len == red)
//read()函数,读取文件成功时,会返回文件长度 { //将读取到的文件数据发送给client客户端 send(acp_fd , picture ,
sizeof(picture) , 0); } sleep(5); free(picture); close(fd); } } else if(0 ==
strcmp(ncmd , "up")) { //上传文件 //首先创建一个数组用来接收客户端发来的文件大小信息 char msg[30] = {0}; int
ret= -1; ret = recv(acp_fd , msg , sizeof(msg) , 0); //接收客户端的文件信息 //判断 if(0 <
ret) { puts(msg); //客户发来的数组fl已经接收成功,打印出来 //解析字符串中的数字 } if(strstr(msg , "lenth"))
//通过字符串定位函数,定位到数字的位置 { int len = atoi(msg + 6);//提取字符串中的数字
//printf("文件大小为:%d\n" , len); int fd = -1; // //调用open函数创建一个文件,大小为提取出的len fd =
open(filename , O_WRONLY | O_CREAT , 0777); if(0 > fd) { puts("open | creat
file error!"); close(fd); return -1; } //接收文件,大文件需要存放在堆区,使用maloc申请,使用完需手动释放 char
*file = NULL; file = (char *)malloc(len); if(NULL == file) { puts("malloc error"
); close(fd); return -1; } //大文件无法一次接收完,需要循环接受 int t = 0; int rec = -1; while(t
< len) { memset(file , 0 , len); rec = recv(acp_fd , file , len-t , 0); if(0 <
rec) { write(fd , file , rec); t += rec; } sleep(1); } puts("文件接收成功!"); free(
file); close(fd); } } } //5.2:发 /*memset(buf , 0 , sizeof(buf)); //先清空存储数据的数组
printf("write:"); fgets(buf , sizeof(buf) , stdin); //标准输入流:键盘获取数据到存储数据的数组中
write(acp_fd , buf , strlen(buf)); close(acp_fd); */ }
最后是字符串分析函数，通过此函数可以将客户端发来的【命令 文件】分离出来
臂如：down 1.jpg 说明客户端要从服务器下载一张名为1.jpg的图片
//定义一个子函数,解析从客户端接受到的命令 //从该命令(str字符串)中,解析出操作方式up 或 down // 解析出要操作的对象 filename
int analysis_cmd(char *str , char *cmd , char *filename); //参数1:从客户端接收到的字符串
//参数2:用于存储解析出的命令 //参数3:用于存储解析出的文件名 //返回值:无 //函数实现 int analysis_cmd(char *str ,
char *cmd , char *filename) //解析命令 { //1.入参判断 if(NULL == str || NULL == cmd ||
NULL == filename) { perror("参数不匹配,请重新输入!"); return -1; } char *p = str;
//定义一个指针p指向接收的字符串str的首地址 while(*p) { if(' ' == *p) //命令与文件名之间有一个空格 { break;
//跳出循环 } else { *cmd = *p; //从str的起始位置开始,将p指向的字符依次复制cmd cmd += 1;
//cmd是一个存储命令的数组,数组名就是数组的首地址,所以cmd+1,表示指针向后移动一个位置 }
//跳出while循环时表明已经将命令遍历出来了[解析出操作方式:up或down] p += 1; //p指针向后移动 } strcpy(filename ,
p+1); //这里的p还指在命令与文件名间的空格处,所以需要再向后移动一个位置才是文件名的首地址
//使用strcpy函数将p指针之后的字符复制给存储filename的数组 }
最后是主函数，调用
int main(int argc , char *argv[]) { //0.判断main函数传参是否正确 if(2 > argc) { perror(
"请输入正确的参数:IP地址 端口号"); return -1; } //1.监听socket对象 int tcp_fd = -1; tcp_fd =
tcp_server(argv[1] , atoi(argv[2])); while(1)
//accept,用于将客户端的链接请求与服务器建立TCP通信,并返回一个新的已经建立链接的accept套接字 { //2.接受链接
//若不关心客户端的IP地址和端口号,则将参数2,3设置为空 //4.1:定义一个保存客户端IP地址和端口号的结构体并清空 int lst_fd = -1;
struct sockaddr_in client; //创建一个结构体 memset(&client , 0 , sizeof(client));
//4.2:定义一个int型变量,保存结构体的大小 int len = sizeof(client); //4.3:接受连接,并且保存客户端的信息 lst_fd
= accept(tcp_fd , (struct sockaddr *)&client , &len);
//4.4:将网络字节序ip地址转换为主机字节序ip地址 char * ip = inet_ntoa(client.sin_addr);
//4.5:网络字节序port转换为主机字节序port unsigned short port = ntohs(client.sin_port);
//4.6:打印出客户端的ip地址和端口号 printf("client IP = %s , PORT = %d \n" , ip , port);
//lst_fd = accept(tcp_fd , NULL , NULL); //不需要获取客户端的ip地址和端口号 //4.7判断是否链接成功 if(0
> lst_fd) { perror("accept error!"); close(tcp_fd); return -1; } puts("accept
success!"); //do_work() //2.和客户端进行通信 tcp_server_communiction(lst_fd);
//6.关闭socket对象 close(tcp_fd); return 0; } }
<>client【客户端】
socket+connect,返回connect成功的套接字
//定义一个tcp连接的子函数 //参数1:ip地址 char * //参数2:端口号 int port
//返回值:成功->返回链接好的socket对象,失败返回-1 int tcp_connect(char * ip , int port); //函数实现
int tcp_connect(char * ip , int port) //子函数实现 { //1.创建TCP socket //2.设置对方的IP和端口号
//3.请求链接 //1.创建TCP socket int tcp_fd = -1; //初始化为-1 tcp_fd = socket(AF_INET ,
SOCK_STREAM, 0); //IPV4,流式套接字 //1.1 判断是否创建成功 if(0 > tcp_fd) { perror("socket
error!"); return -1; } puts("socket success!"); //2.设置对方的IP和端口号[bind] //2.1
定义一个结构体变量 struct sockaddr_in myser; //类似于c++的实例化对象 // myser.sin_family = AF_INET
; //协议 myser.sin_addr.s_addr = inet_addr(ip); myser.sin_port = htons(port);
//主机字节序转网络字节序 //3.请求链接 int ret = -1; ret = connect(tcp_fd , (struct sockaddr *)&
myser, sizeof(myser)); //connect连接 if(0 != ret) { perror("connect error!");
close(tcp_fd); return -1; } puts("connect success!"); return tcp_fd;
//返回connect成功后新生成的套接字 }
和服务器进行通信
//定义一个子函数,和服务器端进行通信 //参数:创建好的socket对象 //返回值:void int tcp_client_communiction(
int tcp_fd); // //函数实现 /*do_work*/ int tcp_client_communiction(int tcp_fd)
//子函数:和服务器进行通信的实现 { //入参判断 if(0 > tcp_fd) { printf("%s < 0 , connot to
communictioning with server!\n" , tcp_fd); return -1; }
//4.发送消息:给server发送下载或上传指令 char buf[50]; memset(buf , 0 , sizeof(buf)); gets(buf)
; //输入 send(tcp_fd , buf , strlen(buf) , 0); char ncmd[10] = {0}; char filename[
64] = {0}; analysis_cmd(buf , ncmd , filename); //puts(ncmd); //puts(filename);
//sleep(2); if(0 == strcmp(ncmd , "down")) { //send后准备recv,接受服务器的文件
//定义一个数组,用来接受server发过来的文件长度message char msg[30] = {0}; int ret = -1; ret = recv(
tcp_fd, msg , sizeof(msg) , 0); puts(msg); if(0 < ret) { //接收命令成功 puts(buf);
//打印buf里接收到的文本字符串[待接收的文件大小] //判断是否是server发来的错误信息 if(0 == strcmp(msg , "文件不存在"))
{ return 0; } else if(strstr(msg , "len")) { int len = atoi(msg + 5);
//提取字符串中的数字 printf("文件长度为:%d\n" , len); //用open函数新建一个文件,大小为len int fd = -1; fd =
open(filename , O_WRONLY | O_CREAT , 0777); //判断文件描述符是否创建成功 if(0 > fd) { puts(
"open|creat file error!"); close(fd); return -1; } //接收文件 char *file = NULL;
file= (char *)malloc(len); //判断文件接收空间是否申请成功 if(NULL == file) { puts("malloc
error!"); close(fd); return -1; } int rec = -1; //一次接收不完,需要循环接收 int t = 0; while
(t < len) { memset(file , 0 , len); rec = recv(tcp_fd , file , len-t , 0);
//recv的成功的返回值是接受到文件的大小 //判断是否接受成功 //printf("%d\n" , rec); if(0 < rec) {
//puts("进来了"); write(fd , file , rec); t += rec; } //printf("%d\n",t); sleep(1);
} puts("文件接收成功!"); free(file); close(fd); } } else if(0 == ret) //没有接受到任何字符 {
return 0; } } else if(0 == strcmp(ncmd , "up")) { //上传文件 //文件操作,打开文件 int fd =
open(filename , O_RDONLY); //以只读的方式打开文件 //judge if(0 > fd) {
//由于是客户向服务器上传文件,所以不必告诉服务器文件是否上传错误,只需告诉客户端就行 puts("文件打开失败,请重新上传!"); close(fd);
return -1; } //打开成功,需要计算文件长度并发送给服务器 int lenth = -1; lenth = lseek(fd , 0 ,
SEEK_END); //调用lseek函数,从0位置跳到文件末尾,计算出文件长度 printf("主人,您要上传的文件大小为:%d\n" , lenth);
char fl[30] = {0}; sprintf(fl , "lenth:%d" , lenth); //将字符串输出重定向到数组中,发送该数组给服务器
send(tcp_fd , fl , sizeof(fl) , 0); //准备发送文件 lseek(fd , 0 , SEEK_SET);
//回到文件起始位置 char *file = NULL; file = (char *)malloc(lenth); //申请空间,将图片存放于此,等待发送
if(NULL == file) { perror("malloc error!"); return -1; } memset(file , 0 , lenth
); int red = (fd , file , lenth); if(red == lenth) { //读取成功,准备向服务器发送 send(tcp_fd
, file , lenth , 0); } sleep(5); free(file); close(fd); } return 0; }
同样，客户端也需要一个字符串解析函数，所以直接拷贝服务器里面的函数
//字符串解析函数,解析出文件大小 int analysis_cmd(char *str , char *cmd , char *filename)
//解析命令 { //1.入参判断 if(NULL == str || NULL == cmd || NULL == filename) { perror(
"参数不匹配,请重新输入!"); return -1; } char *p = str; //定义一个指针p指向接收的字符串str的首地址 while(*p)
{ if(' ' == *p) //命令与文件名之间有一个空格 { break; //跳出循环 } else { *cmd = *p;
//从str的起始位置开始,将p指向的字符依次复制cmd cmd += 1;
//cmd是一个存储命令的数组,数组名就是数组的首地址,所以cmd+1,表示指针向后移动一个位置 }
//跳出while循环时表明已经将命令遍历出来了[解析出操作方式:up或down] p += 1; //p指针向后移动 } strcpy(filename ,
p+1); //这里的p还指在命令与文件名间的空格处,所以需要再向后移动一个位置才是文件名的首地址
//使用strcpy函数将p指针之后的字符复制给存储filename的数组 }
最后是main函数的调用：
int main(int argc , char *argv[]) { //0.首先判断传参是否格式正确 if(2 > argc) { printf(
"传入参数不够,请重新传参!"); return -1; } //1.连接服务器 int tcp_fd = -1; tcp_fd = tcp_connect(
argv[1] , atoi(argv[2])); //atoi()将传入的端口号[例如:8888]转化为网络字节序 //do_work
//2.和服务器端进行通信 tcp_client_communiction(tcp_fd); //3.关闭socket对象 close(tcp_fd);
return 0; }
<>为了模块化编写程序，我们还需要把各种库函数封装成一个.h文件
【net.h】
#ifndef _NET_H #define _NET_H #include<sys/types.h> #include<sys/socket.h> #
include<netinet/in.h> #include<netinet/ip.h> #include<string.h> #include
<unistd.h> #include<stdlib.h> #include<arpa/inet.h> #include<stdlib.h> #include
<fcntl.h> #endif
代码中用到了一些字符串处理函数：例如strstr()、atoi()、
以及网络IP地址转换函数：htonl()或是htons()
char *strstr(const *str1 , const char *str2) //从str1中寻找字符串str2第一次出现的位置
结果就是：程序会从第一个xiao处打印后面的字符串
//atoi() #include<stdio.h> #include<stdlib.h> int main() { char arr1[] =
"-1234"; char arr2[] = "len:569456"; printf("%d\n" , atoi(arr1)); printf("%d\n"
, atoi(arr2+4));//提取字符串中的数字 return 0; }
<>程序测试
在不同的文件夹中分别运行客户服务器端的程序，设定IP地址为本地回环地址：127.0.0.1
端口号：8888
分别在服务器目录下存放一张照片，在客户端目录下存放一个.txt文档，然后测试。
首先是客户端需要将服务器的图片下载至自己的目录下，然后再从自己目录上传一个文档至服务器。
<>连接成功
<>首先是图片下载成功
<>文件上传成功
结束！
一点点感悟，网编流程基本不变，服务器与客户端的搭建模式只要记清，剩下的就是文件操作了，只是需要考虑的一些细节很多，稍不注意可能会有Bug，没错，我的程序也有Bug，文件下载完成后客户端会进入最后的while死循环出不来，目前还没检查出来问题所在。TCP/IP这一块确实重要，需要认真学习。我自己也做了一点点笔记，如有需要程序源码和思维导图，请留言邮箱，我必回复。