第13章 TCP编程(4)_基于自定义协议的多线程模型
7. 基于自定义协议的多线程模型
(1)服务端编程
①主线程负责调用accept与客户端连接
②当接受客户端连接后,创建子线程来服务客户端,以处理多客户端的并发访问。
③服务端接到的客户端信息后,回显给客户端
(2)客户端编程
①从键盘输入信息,并发送给服务端
②接收来自服务端的信息
//msg.h与前一节相同
#ifndef __MSG_H__
#define __MSG_H__
#include <sys/types.h> //求结构体中成员变量的偏移地址
#define OFFSET(TYPE, MEMB) ((size_t) &((TYPE *)0)->MEMB) //自定义的协议(TLV:Type length Value)
typedef struct{
//协议头部
char head[];//TLV中的T
unsigned int checkNum; //校验码
unsigned int cbSizeContent; //协议体的长度
//协议体部
char buff[]; //数据
}MSG; //发送一个基于自定义协议的message,发送的数据存放在buff中
extern int write_msg(int sockfd, char* buff, size_t len); //读取一个基于自定义协议的message,读取的数据存放在buff中
extern int read_msg(int sockfd, char* buff, size_t len); #endif
//msg.c与前一节相同
#include "msg.h"
#include <unistd.h>
#include <string.h>
#include <memory.h>
#include <sys/types.h> //计算校验码
static unsigned int msg_check(MSG* msg)
{
unsigned int s = ;
int i = ;
for(; i<sizeof(msg->head); i++){
s += msg->head[i];
} for(i=; i<msg->cbSizeContent; i++){
s += msg->buff[i];
} return s;
} //接收规定字节的数据,如果缓冲区的数据不够则等待
//返回:0,连接中断或发生错误
// 非0:实际接收到的字节数
static int recvData(int sockfd, char* buff, int nBytes)
{
size_t nRecv = ; do
{
size_t nLen = ;
//接收数据,直到收到指定的字节数
nLen = read(sockfd, buff + nRecv, nBytes - nRecv);
nRecv += nLen; if(nLen == ){ //读完或对方的写端己关闭
nRecv = -;
break;
} }while(nRecv < nBytes); return nRecv;
} //发送指定字节数(数据量较大)的数据(采取分批发送的方法)
//当要发送的字节数超过send缓冲区大小时,要分批发送
static int sendData(int sockfd, char* buff, int nBytes)
{
size_t nSend = ; do
{
size_t nLen = ;
//接收数据,直到收到指定的字节数
nLen = write(sockfd, buff + nSend, nBytes - nSend);
nSend += nLen;
if(nLen < || nLen == ){ //当写完或对方读端己关闭
if(nLen == )
nSend = -;
break;
} }while(nSend < nBytes); return nSend;
} //发送一个基于自定义协议的message,发送的数据存放在buff中
int write_msg(int sockfd, char* buff, size_t len)
{
/*封装数据成自定义的格式*/
MSG msg;
memset(&msg, , sizeof(msg));
strcpy(msg.head, "msghead");
memcpy(msg.buff, buff, len);
msg.cbSizeContent = len;
msg.checkNum = msg_check(&msg); /*发送自定义消息*/
int nRet = sendData(sockfd, (char*)&msg, sizeof(msg)); return nRet;
} //读取一个基于自定义协议的message,读取的数据存放在buff中
int read_msg(int sockfd, char* buff, size_t len)
{
MSG msg;
memset(&msg, , sizeof(msg));
size_t size = ; //读取结构体
size = recvData(sockfd, (char*)&msg, sizeof(msg));
if(size == -){ //另一方socket被关闭
return ;
}else if(size != sizeof(msg)){
return -;
} //进行校验码验证
unsigned int s = msg_check(&msg);
if((s == (unsigned int)msg.checkNum)
&& (!strcmp("msghead", msg.head))){
memcpy(buff, msg.buff, len);
return size;
} return -;
}
//echo_tcp_client.c客户端程序与前一节相同
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>
#include <signal.h>
#include <errno.h>
#include "msg.h" /*基于自定义协议的多进程服务端和客户端通信*
测试:telnet 127.0.0.1 xxxx
http://xxx.xxx.xxx.xxx:端口号
注意:演示时可关闭服务器的防火墙,防火墙口被过滤
#service iptables status 查看防火墙
#service iptables stop 关闭防火墙
*/ int sockfd;
int bStop = ; void sig_handler(int signo)
{
if(signo == SIGINT){
bStop = ;
printf("server close\n"); exit();
} if(signo == SIGCHLD){
printf("child process deaded...\n");
wait();
}
} //显示客户端信息
void out_addr(struct sockaddr_in* addr)
{
//将端口从网络字节序转换成主机字节序
int port = ntohs(addr->sin_port);
//获得IP地址
char ip[] ={};
//将ip地址从网络字节序转换成点分十分制
inet_ntop(AF_INET, &addr->sin_addr.s_addr, ip, sizeof(ip)); printf("Client: %s(%d) connected\n", ip, port);
} //服务程序
void do_service(int fd)
{
/*服务端和客户端进行读写操作(双向通信)*/
char buff[];
while(){
memset(buff, , sizeof(buff));
printf("start read and write...\n");
size_t size; //读取客户端发送过来的消息
if((size = read_msg(fd, buff, sizeof(buff))) < ){
printf("%s\n", buff); //测试
perror("protocol error");
break;
}else if(size == ){
//当客户端断开连接时而服务器试图去读取其
//数据,socket就类似管道,相当于客户端写端被关闭,这里read_msg
//会返回0
printf("%s\n", buff); //测试
break;
}else{
printf("%s\n", buff);//显示客户端发送的消息
//写回客户端(回显功能)
if(write_msg(fd, buff, sizeof(buff)) < ){
perror("protocol error");
if(errno == EPIPE){
//如果客户端己被关闭(相当于管道的读端关闭),会产生SIGPIPE信号
//将并errno设置为EPIPE
break;
}
}
}
}
} int main(int argc, char* argv[])
{
if(argc < ){
printf("usage: %s port\n", argv[]);
} //按ctrl-c时中止服务端程序
if(signal(SIGINT, sig_handler) == SIG_ERR){
perror("signal sigint error");
exit();
}
//回收子进程
if(signal(SIGCHLD, sig_handler) == SIG_ERR){
perror("signal sigchld error");
exit();
} /*步骤1:创建socket(套接字)
*注:socket创建在内核中,是一个结构体
*AF_INET:IPv4
*SOCK_STREAM:tcp协议
*/
sockfd = socket(AF_INET, SOCK_STREAM, ); /*步骤2:将sock和地址(包括ip、port)进行绑定*/
struct sockaddr_in servAddr; //使用专用地址结构体
memset(&servAddr, , sizeof(servAddr));
//往地址中填入ip、port和Internet地址族类型
servAddr.sin_family = AF_INET;//IPv4
servAddr.sin_port = htons(atoi(argv[])); //port
servAddr.sin_addr.s_addr = INADDR_ANY; //任一可用的IP if(bind(sockfd, (struct sockaddr*)&servAddr, sizeof(servAddr)) < ){
perror("bind error");
exit();
} /*步骤3:调用listen函数启动监听
* 通知系统去接受来自客户端的连接请求
*/
if(listen(sockfd, ) < ){ //队列中最多允许10个连接请求
perror("listen error");
exit();
} /*步骤4:调用accept函数,从请求队列中获取一个连接
* 并返回新的socket描述符
* */
struct sockaddr_in clientAddr;
socklen_t clientAddr_len = sizeof(clientAddr);
while(!bStop){
//如果没有客户端连接,调用此函数后会阻塞,直至获得一个客户端连接
int fd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddr_len); if(fd < ){
perror("accept error");
continue;
} /*步骤5:启动子进程去和客户端进行双向通信*/
pid_t pid = fork();
if(pid < ){
continue;
}else if(pid == ){//child process
//输出客户端信息
out_addr(&clientAddr);
//处理客户端请求
do_service(fd);
close(fd);
break;
}else{ //parent process
/*步骤6: 关闭fd套接字*/
close(fd);
}
} close(sockfd); return ;
}
/*输出结果
* [root@localhost 13.TCP]# bin/echo_tcp_server 8888
* Client: 127.0.0.1(40664) connected
* start read and write...
* abcdefg
* start read and write...
* 1234567890
* start read and write...
* ^Cserver close
* child process deaded...
* server close
*/
//echo_tcp_server_th.c 服务端程序
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>
#include <pthread.h>
#include <signal.h>
#include <errno.h>
#include "msg.h" /*基于自定义协议的多线程服务端和客户端通信*
测试:telnet 127.0.0.1 xxxx
http://xxx.xxx.xxx.xxx:端口号
注意:演示时可关闭服务器的防火墙,防火墙口被过滤
#service iptables status 查看防火墙
#service iptables stop 关闭防火墙
*/ int sockfd;
int bStop = ; void sig_handler(int signo)
{
if(signo == SIGINT){
bStop = ;
printf("server close\n"); exit();
}
} //服务程序(与前一节例子几乎相同)
void do_service(int fd)
{
/*服务端和客户端进行读写操作(双向通信)*/
char buff[];
while(){
memset(buff, , sizeof(buff));
size_t size; //读取客户端发送过来的消息
if((size = read_msg(fd, buff, sizeof(buff))) < ){
perror("protocol error");
break;
}else if(size == ){
//当客户端断开连接时而服务器试图去读取其
//数据,socket就类似管道,相当于客户端写端被关闭,这里read_msg
//会返回0
break;
}else{
printf("%s\n", buff);//显示客户端发送的消息
//写回客户端(回显功能)
if(write_msg(fd, buff, sizeof(buff)) < ){
perror("protocol error");
if(errno == EPIPE){
//如果客户端己被关闭(相当于管道的读端关闭),会产生SIGPIPE信号
//将并errno设置为EPIPE
break;
}
}
}
}
} /*显示客户端信息(注意:与前一节的例子不同)
*注意:fd指向一个socket,本质上socket是一个结构体
*其包含了通讯双方的IP、端口等信息
*/
void out_fd(int fd)
{
struct sockaddr_in addr;
socklen_t len = sizeof(addr); //从fd中获得客户端的相关信息并放置到sockaddr_in结构体中
if(getpeername(fd, (struct sockaddr*)&addr, &len) < ){
perror("getpeername error");
return;
} char ip[];
memset(ip, , sizeof(ip));
int port = ntohs(addr.sin_port);
//将网络字节序的IP地址转为点分十进制的字符串
inet_ntop(AF_INET, &addr.sin_addr.s_addr, ip, sizeof(ip));
printf("%16s(%5d) closed!\n", ip, port);
} //线程函数
void* th_fn(void* arg)
{
int fd = (int)arg; do_service(fd);
out_fd(fd); close(fd); return (void*);
} int main(int argc, char* argv[])
{
if(argc < ){
printf("usage: %s port\n", argv[]);
} //按ctrl-c时中止服务端程序
if(signal(SIGINT, sig_handler) == SIG_ERR){
perror("signal sigint error");
exit();
} /*步骤1:创建socket(套接字)
*注:socket创建在内核中,是一个结构体
*AF_INET:IPv4
*SOCK_STREAM:tcp协议
*/
sockfd = socket(AF_INET, SOCK_STREAM, ); /*步骤2:将sock和地址(包括ip、port)进行绑定*/
struct sockaddr_in servAddr; //使用专用地址结构体
memset(&servAddr, , sizeof(servAddr));
//往地址中填入ip、port和Internet地址族类型
servAddr.sin_family = AF_INET;//IPv4
servAddr.sin_port = htons(atoi(argv[])); //port
servAddr.sin_addr.s_addr = INADDR_ANY; //任一可用的IP if(bind(sockfd, (struct sockaddr*)&servAddr, sizeof(servAddr)) < ){
perror("bind error");
exit();
} /*步骤3:调用listen函数启动监听
* 通知系统去接受来自客户端的连接请求
*/
if(listen(sockfd, ) < ){ //队列中最多允许10个连接请求
perror("listen error");
exit();
} /*步骤4:调用accept函数,从请求队列中获取一个连接
* 并返回新的socket描述符
* */ //设置线程的分离属性
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); while(!bStop){
//主线程负责调用accept去获得客户端的连接
//如果没有客户端连接,调用此函数后会阻塞,直至获得一个客户端连接
int fd = accept(sockfd, NULL, NULL); if(fd < ){
perror("accept error");
continue;
} /*步骤5:以分离方式启动子线程去和客户端进行双向通信
*注意:是以分离方式启动的,从而可以在子线程服务客户端结束时,由子
*线程自己回收其所占的资源
*/
pthread_t th;
int err;
//以分离状态启动子线程
if((err = pthread_create(&th, &attr, th_fn, (void*)fd)) != ){
perror("pthread create error");
}
} pthread_attr_destroy(&attr); close(sockfd); return ;
}
/*输出结果
* [root@localhost 13.TCP]# bin/echo_tcp_server_th 8888
* asdfasdf
* asdfas
* asdfasd
* aaa
* 127.0.0.1(40683) closed!
* asdfasf
* ads
* 127.0.0.1(40682) closed!
*^Cserver close
*/
第13章 TCP编程(4)_基于自定义协议的多线程模型的更多相关文章
- 第13章 TCP编程(3)_基于自定义协议的多进程模型
5. 自定义协议编程 (1)自定义协议:MSG //自定义的协议(TLV:Type length Value) typedef struct{ //协议头部 ];//TLV中的T unsigned i ...
- 第13章 TCP编程(1)_socket套接字
1. socket套接字 (1)套接字简介 ①socket是一种通讯机制,它包含一整套的调用接口和数据结构的定义,它给应用进程提供了使用如TCP/UDP等网络协议进行网络通讯的手段. ②Linux中的 ...
- 第13章 TCP编程(2)_TCP的连接和关闭过程
4. TCP的连接和关闭过程 4.1 TCP连接的三次握手和四次挥手 (1)三次握手 ①第1次握手:建立连接.客户端发送连接请求报文段(SYN=1,sequence Number=x):然后客户端进入 ...
- 我的Android进阶之旅------>Android基于HTTP协议的多线程断点下载器的实现
一.首先写这篇文章之前,要了解实现该Android多线程断点下载器的几个知识点 1.多线程下载的原理,如下图所示 注意:由于Android移动设备和PC机的处理器还是不能相比,所以开辟的子线程建议不要 ...
- 网络编程[第二篇]基于udp协议的套接字编程
udp协议下的套接字编程 一.udp是无链接的 不可靠的 而上篇的tcp协议是可靠的,会有反馈信息来确认信息交换的完成与否 基于udp协议写成的服务端与客户端,各司其职,不管对方是否接收到信息, ...
- 网络编程应用:基于UDP协议【实现文件下载】--练习
要求: 基于UDP协议实现文件下载 发送方–请求–接收方发送文件–发送方接收文件 代码: 发送方: package Homework1; import java.io.File; import jav ...
- jQuery 第四章 实例方法 DOM操作_基于jQuery对象增删改查相关方法
.next() .prev() .nextAll() .prevAll() .prevUntil() .nextUntli() .siblings() .children() .parent() .p ...
- Linux(例如CentOS 7)打开TCP 22端口,基于SSH协议
SSH 为 Secure Shell 的缩写,由 IETF 的网络工作小组(Network Working Group)所制定:SSH 为建立在应用层和传输层基础上的安全协议.SSH 是目前较可靠,专 ...
- 网络编程应用:基于UDP协议【实现聊天程序】--练习
要求: 使用UDP协议实现一个聊天程序 代码: 发送端: package UDP聊天程序; import java.io.IOException; import java.net.DatagramPa ...
随机推荐
- 【转】react的高阶组件
React进阶之高阶组件 前言 本文代码浅显易懂,思想深入实用.此属于react进阶用法,如果你还不了解react,建议从文档开始看起. 我们都知道高阶函数是什么, 高阶组件其实是差不多的用法,只 ...
- 第三课 操作系统开发之x86模拟环境搭建
前面我们讲解了主引导程序的加载过程,并且制作了虚拟软盘a.img,最终这个主引导程序也在机器中成功运行了,但是实际开发的时候,并不会如此简单,免不了调试过程,如果还像上一节中直接将软盘放到机器中去加载 ...
- DBWR进程
--查询dbwr进程号 select pname,spid from v$process where pname like 'DBW%'; PNAME SPID----- -------------- ...
- dfs、遍历与for
dfs实际上就是若干个递归式连续使用,从而把所有情况全部遍历的方法 首先是递归式的连用,然后注意参数的选取以及变化就行了 1.参数一般有状态参数与开关参数 最简单的dfs就是每次选择只是改变自身状态( ...
- 《DSP using MATLAB》 Problem 3.22
代码: %% ------------------------------------------------------------------------ %% Output Info about ...
- 【java规则引擎】《Drools7.0.0.Final规则引擎教程》第4章 4.2 lock-on-active
转载至:https://blog.csdn.net/wo541075754/article/details/75208955 lock-on-active 当在规则上使用ruleflow-group属 ...
- 使用Visual Studio Code开发Asp.Net Core WebApi学习笔记(三)-- Logger
本篇是在上一篇的基础上添加日志功能,并记录NLog在Asp.Net Core里的使用方法. 第一部分:默认Logger支持 一.project.json添加日志包引用,并在cmd窗口使用 dotnet ...
- Start Developing iOS Apps (Swift) 开始开发iOS应用(Swift)
http://www.cnblogs.com/tianjian/category/704953.html 构建基础的用户界面 Build a Basic UI http://www.cnblogs.c ...
- ZH奶酪:【数据结构与算法】基础排序算法总结与Python实现
1.冒泡排序(BubbleSort) 介绍:重复的遍历数列,一次比较两个元素,如果他们顺序错误就进行交换. 2016年1月22日总结: 冒泡排序就是比较相邻的两个元素,保证每次遍历最后的元素最大. 排 ...
- 基于server broker 的数据实时更新
Service Broker介绍:SQL Server Service Broker 为消息和队列应用程序提供 SQL Server 数据库引擎本机支持.这使开发人员可以轻松地创建使用数据库引擎组件在 ...