基于tcp协议的网络程序流程图如下:
tcp协议网络程序流程图
服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态
客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答
服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。
一. 协议流程分析
建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答，服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求，客户端收到后从read()返回，发送下一条请求，如此循环下去。
如果客户端没有更多的请求了，就调用close()关闭连接，就像写端关闭的管道一样，服务器的read()返回0，这样服务器就知道客户端关闭了连接，也调用close()关闭连接。注意，任何一方调用close()后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用shutdown()则连接处于半关闭状态，仍可接收对方发来的数据。
在学习socket API时要注意应用程序和TCP协议层是如何交互的： *应用程序调用某个socket函数时TCP协议层完成什么动作，比如调用connect()会发出SYN段 *应用程序如何知道TCP协议层的状态变化，比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段，再比如read()返回0就表明收到了FIN段
二. 简单例子(单线程实现客户端与服务端的简单通信)
实现功能: 客户端连接服务端后,不断从控制台读取字符串,发给服务端,服务端接收后则在控制台界面输出
/*
* @Author: D-lyw
* @Date: 2018-10-25 00:48:44
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-16 12:36:34
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVADDR_PORT 8800
const char *LOCALIP = "127.0.0.1";
int main(int argc, char const *argv[])
{
// 定义变量存储生成或接收的套接字描述符
int listenfd, recvfd;
// 定义一个数据结构用来存储套接字的协议,ip,端口等地址结构信息
struct sockaddr_in servaddr, clientaddr;
// 定义接收的套接字的数据结构的大小
unsigned int cliaddr_len, recvLen;
char recvBuf[1024];
//创建用于帧听的套接字
listenfd = socket(AF_INET, SOCK_STREAM, 0);
// 给套接字数据结构赋值,指定ip地址和端口号
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERVADDR_PORT);
servaddr.sin_addr.s_addr = inet_addr(LOCALIP);
// 绑定套接字
if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){
fprintf(stderr, "绑定套接字失败,%s\n", strerror(errno));
exit(errno);
}
// 监听请求
if(listen(listenfd, 10) == -1){
fprintf(stderr, "绑定套接字失败,%s\n", strerror(errno));
exit(errno);
}
cliaddr_len = sizeof(struct sockaddr);
// 等待连接请求
while (1){
// 接受由客户机进程调用connet函数发出的连接请求
recvfd = accept(listenfd, (struct sockaddr *)&clientaddr, &cliaddr_len);
printf("接收到请求套接字描述符: %d\n", recvfd);
while(1){
// 在已建立连接的套接字上接收数据
if((recvLen = recv(recvfd, recvBuf, 1024, 0)) == -1){
fprintf(stderr,"接收数据错误, %s\n",strerror(errno));
}
printf("%s", recvBuf);
}
}
close(recvfd);
return 0;
}
/*
* @Author: D-lyw
* @Date: 2018-10-26 14:06:32
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-16 12:34:08
* @name tcp_client.c
* @descripe 实现最基本的创建套接字, 填充客户端信息,connet连接服务端, 可连续向服务端发送消息
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
extern int errno;
#define SERVERPORT 8800
int main(int argc, char const *argv[])
{
// 定义变量存储本地套接字描述符
int clifd;
// 设置本地ip地址
const char serverIp[] = "127.0.0.1";
// 定义套接字结构存储套接字的ip,port等信息
struct sockaddr_in cliaddr_in;
// 定义发送,接收缓冲区大小
char sendBuf[1024], recvBuf[1024];
// 创建套接字
if((clifd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
fprintf(stderr, "创建套接字失败,%s\n", strerror(errno));
exit(errno);
}
// 填充 服务器端结构体信息
cliaddr_in.sin_family = AF_INET;
cliaddr_in.sin_addr.s_addr = inet_addr(serverIp);
cliaddr_in.sin_port = htons(SERVERPORT);
// 请求连接服务器进程
if(connect(clifd, (struct sockaddr *)&cliaddr_in, sizeof(struct sockaddr)) == -1){
fprintf(stderr,"请求连接服务器失败, %s\n", strerror(errno));
exit(errno);
}
strcpy(sendBuf, "hi,hi, severs!\n");
// 发送打招呼消息
if(send(clifd, sendBuf, 1024, 0) == -1){
fprintf(stderr, "send message error:(, %s\n", strerror(errno));
exit(errno);
}
// 阻塞等待输入,发送消息
while(1){
fgets(sendBuf, 1024, stdin);
if(send(clifd, sendBuf, 1024, 0) == -1){
fprintf(stderr, "send message error:(, %s\n", strerror(errno));
}
}
close(clifd);
return 0;
}
三. 聊天室功能实现(多线程)
服务器端代码
/*
* @Author: D-lyw
* @Date: 2018-11-22 20:37:05
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-23 00:19:42
* @Describe Chating Room Coded by linux c .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
const unsigned short LOCALPORT = 3003;
const char *LOCALIP = "127.0.0.1";
#define MAXMSGSIZE 1024*5
#define MAXCONNECT 100
char sendbuf[MAXMSGSIZE];
char recvbuf[MAXMSGSIZE];
struct msgHdr{
int fd; // 套接字描述符
ushort tip; // 0 进入聊天室, 1 离开聊天室 2 发送消息
ushort onLineNum; // 在线人数
};
// 线程描述符
pthread_t Precv;
pthread_t Psend;
int clientFdarray[MAXCONNECT];
struct msgHdr *sendMsgHdr, *recvMsgHdr;
int onLineNum = 0; // 在线人数
void rmFd(int dealfd){
for(int i = 0; i < (onLineNum+1); i++){
if(clientFdarray[i] == dealfd){
for(; i < onLineNum; i++){
clientFdarray[i] = clientFdarray[i+1];
}
printf("当前所有用户:\n");
for(int j = 0; j < onLineNum; j++){
printf(" 用户:%d\n", clientFdarray[j]);
}
}
}
}
// 服务器发送消息线程
void sendToClient(char *buf, int dealfd){
for(int j = 0; j < onLineNum; j++){
if(clientFdarray[j] == dealfd){
continue;
}
if(send(clientFdarray[j], buf, MAXMSGSIZE, 0) == -1){
fprintf(stderr, "%s\n", strerror(errno));
}
}
bzero(buf, MAXMSGSIZE);
}
// 接收客户端消息线程
void *recvMsg(void *recvfd){
int dealfd = *(int *)recvfd;
while(1){
if(recv(dealfd, recvbuf, MAXMSGSIZE, 0) == -1){
fprintf(stderr, "Receive msg err: %s\n", strerror(errno));
}
recvMsgHdr = (struct msgHdr *)recvbuf;
recvMsgHdr->fd = dealfd;
if(recvMsgHdr->tip == 1){
onLineNum–;
recvMsgHdr->onLineNum = onLineNum;
// 将离开的套接字描述符移开在线列表数组
rmFd(dealfd);
printf("用户:%d 离开了聊天室\n", dealfd);
sendToClient(recvbuf, dealfd);
close(dealfd);
return NULL;
}
// 将此用户的消息发给其他用户
sendToClient(recvbuf, dealfd);
}
close(dealfd);
return NULL;
}
int main(int argc, char const *argv[])
{
int serverfd, recvfd;
socklen_t sockleng;
struct sockaddr_in serveraddr, clientaddr;
pid_t childid;
int perrno;
if( (serverfd = socket(AF_INET, SOCK_STREAM, 0) ) == -1){
fprintf(stderr, "创建服务器套接字错误, %s\n", strerror(errno));
exit(0);
}
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(LOCALPORT);
serveraddr.sin_addr.s_addr = inet_addr(LOCALIP);
if(bind(serverfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr)) == -1){
fprintf(stderr, "绑定套接字错误, %s\n", strerror(errno));
exit(0);
}
if(listen(serverfd, 100) == -1){
fprintf(stderr, "监听套接字错误, %s\n", strerror(errno));
}
printf("\nListening at %d port, wating connection…..\n", LOCALPORT);
while(1){
if((recvfd = accept(serverfd, (struct sockaddr *)&clientaddr, &sockleng)) == 0){
fprintf(stderr, "连接错误, %s\n", strerror(errno));
continue;
}
// 将该套接字描述符保存进数组
clientFdarray[onLineNum++] = recvfd;
printf("客户端套接字:%d 已开启\n", recvfd);
sendMsgHdr = (struct msgHdr *)sendbuf;
sendMsgHdr->fd = recvfd;
sendMsgHdr->tip = 0;
sendMsgHdr->onLineNum = onLineNum;
// 当有用户加入时,通知聊天室中的所有人
for(int j = 0; j < onLineNum; j++){
if(send(clientFdarray[j], sendbuf, MAXMSGSIZE, 0) == -1){
fprintf(stderr, "%s\n", strerror(errno));
}
}
bzero(sendbuf, MAXMSGSIZE);
// 创建接收用户消息处理线程
if((perrno = pthread_create(&Precv, NULL, recvMsg, &recvfd)) != 0){
fprintf(stderr, "创建子消息接收线程失败, %s\n", strerror(perrno));
exit(perrno);
}
}
close(serverfd);
return 0;
}
客户端代码
/*
* @Author: D-lyw
* @Date: 2018-11-22 21:47:58
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-23 00:37:01
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
extern int errno;
#define MAXSIZE 1024*5
#define SERVER_PORT 3003
const char *SERVERIP = "127.0.0.1";
// const char *SERVERIP = "120.78.156.5";
char sendbuf[MAXSIZE];
char recvbuf[MAXSIZE];
struct msgHdr{
int fd; // 套接字描述符
ushort tip; // 0 进入聊天室, 1 离开聊天室 2 发送消息
ushort onLineNum; // 在线人数
};
int sockfd;
struct msgHdr *mySendMsgHdr, *myRecvMsgHdr;
void *sendMsg(void *msg){
while(1){
mySendMsgHdr = (struct msgHdr *)sendbuf;
mySendMsgHdr->fd = sockfd;
fgets(sendbuf + sizeof(struct msgHdr), MAXSIZE – sizeof(struct msgHdr), stdin);
if(strncmp(sendbuf + sizeof(struct msgHdr), "end", 3) == 0){ // 用户离开聊天室
mySendMsgHdr->tip = 1;
if(send(sockfd, sendbuf, MAXSIZE, 0) == -1){
fprintf(stderr, "%s\n", strerror(errno));
}
close(sockfd);
exit(0);
}else{
mySendMsgHdr->tip = 2; // 用户发送数据
}
if(send(sockfd, sendbuf, MAXSIZE, 0) == -1){
fprintf(stderr, "%s\n", strerror(errno));
}
bzero(sendbuf, MAXSIZE);
}
return NULL;
}
int main(int argc, char const *argv[])
{
ssize_t sendLen;
struct sockaddr_in seraddr, recvaddr;
pthread_t Psend;
// 创建一个客户端的套接字
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
fprintf(stderr, "%s\n", strerror(errno));
exit(errno);
}
bzero(&seraddr, sizeof(struct sockaddr_in));
// 服务器端地址信息
seraddr.sin_family = AF_INET;
seraddr.sin_addr.s_addr = inet_addr(SERVERIP);
seraddr.sin_port = htons(SERVER_PORT);
// 请求连接服务器进程
if(connect(sockfd, (struct sockaddr *)&seraddr, sizeof(struct sockaddr)) == -1){
fprintf(stderr,"请求连接服务器失败, %s\n", strerror(errno));
exit(errno);
}
printf("——–Successful connect to %s:%d——–\n", inet_ntoa(seraddr.sin_addr), ntohs(seraddr.sin_port));
// 新建线程发送消息
pthread_create(&Psend, NULL, sendMsg, NULL);
// 接收其他用户消息
while(1){
// 清空缓存区
bzero(recvbuf, MAXSIZE);
if(recv(sockfd, recvbuf, MAXSIZE, 0) == -1){
fprintf(stderr, "%s\n", strerror(errno));
}
myRecvMsgHdr = (struct msgHdr *)recvbuf;
if(myRecvMsgHdr->tip == 0){
fprintf(stdout, " **用户 %d 加入聊天室 当前用户: %d 人** \n", myRecvMsgHdr->fd, myRecvMsgHdr->onLineNum);
}else if(myRecvMsgHdr->tip == 1){
printf(" **用户 %d 离开聊天室 当前用户: %d 人** \n", myRecvMsgHdr->fd, myRecvMsgHdr->onLineNum);
}else if(myRecvMsgHdr->tip == 2){
fprintf(stdout, "#%d> %s\n", myRecvMsgHdr->fd, recvbuf+sizeof(struct msgHdr));
}
}
return 0;
}