linux Epoll 发送函数的封装有关问题.
linux Epoll 发送函数的封装问题...
大概流程就是：main.c 主文件运行后，接受客户端连接，当客户端发相应命令过来后，在tcp.c 文件中解析后，调用function.c文件中的处理函数：Receive_Process（）。
原来我的想法是，在function处理完成后，通过Receive_Process()函数再把结果返回，
如果这样的话，就没这些问题了，处理的结果，我在tcp.c文件中，通过 “unsigned char* buff_w” 可以拿到，送给PC就完事了。
现在同事要求不这么干，即不通过Receive_Process（）进、出方式，把结果返回。而是要在fuction.c中（当然也可能其他文件中可以调用发送函数，把结果送给PC）把结果直接送给PC端...
（在另个帖子里可能没描述清楚）
主文件：
主要就是网上找到一段代码，简单调整了一下。
处理文件：function.c
TCP文件： tcp.c
tcp.h头文件
------解决思路----------------------
好奇为何不直接用libevent呢？
------解决思路----------------------
实现不好意思回这个贴了
上两次回贴都没帮到你。
发送数据跟 epoll 是没有关系的. 都可以直接 write(fd ,....)
Receive_Process(4,send_data_buffer_size_tcp ...)
write(events[n].data.fd, send_data_buffer_size_tcp, 4); // 直接发
下面的 所有关于EPOLLOUT 事件注册和处理都不要了
// ---------------------------------------
楼主是不是看了百度百科那份epoll 资料呀！？那份资料有点坑爹
大概流程就是：main.c 主文件运行后，接受客户端连接，当客户端发相应命令过来后，在tcp.c 文件中解析后，调用function.c文件中的处理函数：Receive_Process（）。
原来我的想法是，在function处理完成后，通过Receive_Process()函数再把结果返回，
void Receive_Process(int conn_fd,unsigned char* buff_r,unsigned char* buff_w)
如果这样的话，就没这些问题了，处理的结果，我在tcp.c文件中，通过 “unsigned char* buff_w” 可以拿到，送给PC就完事了。
现在同事要求不这么干，即不通过Receive_Process（）进、出方式，把结果返回。而是要在fuction.c中（当然也可能其他文件中可以调用发送函数，把结果送给PC）把结果直接送给PC端...
（在另个帖子里可能没描述清楚）
主文件：
主要就是网上找到一段代码，简单调整了一下。
#include "tcp.h"
int main(int argc, char * argv[])
{
tcp_initialize();
epoll_fd_tcp=create_epoll_tcp(MAX_EVENTS_TCP);
while(1)
{
do_process_tcp_nowhile();
sleep(1);
}
}
处理文件：function.c
#include "function.h"
void Receive_Process(int conn_fd,unsigned char* buff_r,unsigned char* buff_w)
{
unsigned char CmdKey;
unsigned char length;
int len,i;
len = buff_r[1];
CmdKey = buff_r[2];
printf("packet len is : %02X\n",buff_r[1]);
printf("cmdkey is : %02X\n",buff_r[2]);
for(i=0;i<len;i++)
buff_r[i]=buff_r[i+1];
for(i=0;i<len;i++)
printf("%02X ",buff_r[i]);
printf("\n");
switch(CmdKey)
{
case 0x02:
//write_spi_arm_to_fpga_array(5,buff_r,buff_w);
// 根据命令，与FPGA交互后，将返回结果送给PC端，下面是模拟的数据。
buff_w[0]=0x08;
buff_w[1]=0x03;
buff_w[2]=0x8c;
buff_w[3]=0x00;
buff_w[4]=0x00;
//send to pc
tcp_send_data_to_pc(5 buff_w);
// 无发完成发送任务，这个函数只能在tcp.c文件中能正常，出了tcp.c文件就不行了。
printf("CMD_GET_VERSION OK \n");
break;
default:
break;
}
}
TCP文件： tcp.c
#include "tcp.h"
struct epoll_event events[MAX_EVENTS_TCP];// 事件监听队列
int server_sock_fd_tcp;// 服务器端套接字
int client_sock_fd_tcp;// 客户端套接字
int nfds_tcp;// epoll监听事件发生的个数
int len_recv_data_tcp;
struct sockaddr_in host_addr_tcp; // 服务器网络地址结构体
struct sockaddr_in remote_addr_tcp; // 客户端网络地址结构体
int sin_size;
unsigned char send_data_buffer_size_tcp[BUFFER_SIZE_TCP]; // 数据传送的缓冲区
unsigned char retn_data_buffer_size_tcp[BUFFER_SIZE_TCP];
int m=0;
int len;
//设置句柄为非阻塞方式
int setnonblocking(int sockfd)
{
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)
{
return -1;
}
return 0;
}
int tcp_send_data_to_pc(int len,char* buffer)
{
printf("in while n == %d \n",n);
send(events[n].data.fd,buffer,4,0);
ev.events = EPOLLIN;
ev.data.fd = events[n].data.fd;
epoll_ctl(epoll_fd_tcp, EPOLL_CTL_MOD, ev.data.fd, &ev);
}
void tcp_initialize()
{
struct rlimit rt;
/* 设置每个进程允许打开的最大文件数 */
rt.rlim_max = rt.rlim_cur = 1024;
if (setrlimit(RLIMIT_NOFILE, &rt) == -1)
{
perror("setrlimit");
exit(1);
}
else
{
printf("setrlimit ok! \n");
}
// 创建服务器端套接字--IPv4协议，面向连接通信，TCP协议
if((server_sock_fd_tcp=socket(PF_INET,SOCK_STREAM,0))<0)
{
perror("socket");
//return 1;
}
else
{
printf("Tcp server socket ok...\n");
}
// 设置 socket属性，端口可以重用
int opt=SO_REUSEADDR;
setsockopt(server_sock_fd_tcp,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
setnonblocking(server_sock_fd_tcp);
memset(&host_addr_tcp,0,sizeof(host_addr_tcp)); // 数据初始化--清零
host_addr_tcp.sin_family=PF_INET; // 设置为IP通信
host_addr_tcp.sin_addr.s_addr=inet_addr(HOST_IP_ADDRESS_TCP);// 服务器IP地址--允许连接到所有本地地址上
host_addr_tcp.sin_port=htons(HOST_PORT_TCP); // 服务器端口号
// 将套接字绑定到服务器的网络地址上
if (bind(server_sock_fd_tcp,(struct sockaddr *)&host_addr_tcp,sizeof(struct sockaddr))<0)
{
perror("bind");
//return 1;
}
else
{
printf("Tcp server bind ok...\n");
printf("IP : %s \n", inet_ntoa(host_addr_tcp.sin_addr));
printf("port: %d \n",ntohs(host_addr_tcp.sin_port));
}
// 监听连接请求--监听队列长度为5
listen(server_sock_fd_tcp,64);
sin_size=sizeof(struct sockaddr_in);
}
// 创建一个epoll句柄
int create_epoll_tcp(unsigned int event_num)
{
int epoll_fd;
epoll_fd=epoll_create(event_num);
if(epoll_fd==-1)
{
perror("epoll_create failed");
}
ev.events=EPOLLIN | EPOLLET;
ev.data.fd=server_sock_fd_tcp;
// 向epoll注册server_sockfd监听事件
if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,server_sock_fd_tcp,&ev)==-1)
{
perror("epll_ctl:server_sock_fd_tcp register failed");
}
else
{
printf("socket adding in epoll success! \n");
}
return epoll_fd;
}
void do_process_tcp_nowhile()
{
// 等待事件发生
nfds_tcp=epoll_wait(epoll_fd_tcp,events,1024,-1);
if(nfds_tcp==-1)
{
perror("start epoll_wait failed");
//exit(EXIT_FAILURE);
}
else
{
printf(" epoll nfds_tcp = %d \n",nfds_tcp);
}
for(n=0;n<nfds_tcp;++n)
{
printf(" for loop epoll nfds_tcp = %d \n",nfds_tcp);
// 客户端有新的连接请求
if(events[n].data.fd == server_sock_fd_tcp)
{
// 等待客户端连接请求到达
if((client_sock_fd_tcp=accept(server_sock_fd_tcp,(struct sockaddr *)&remote_addr_tcp,&sin_size))<0)
{
perror("accept client_sock_fd_tcp failed");
exit(EXIT_FAILURE);
}
// 向epoll注册client_sockfd监听事件
setnonblocking(client_sock_fd_tcp);
ev.events=EPOLLIN | EPOLLET;
ev.data.fd=client_sock_fd_tcp;
if(epoll_ctl(epoll_fd_tcp,EPOLL_CTL_ADD,client_sock_fd_tcp,&ev)==-1)
{
perror("epoll_ctl:client_sock_fd_tcp register failed");
}
printf("accept client %s\n",inet_ntoa(remote_addr_tcp.sin_addr));
}
else if(events[n].events & EPOLLIN)
{
// 客户端有数据发送过来
sprintf(send_data_buffer_size_tcp,"");
//sin_size=sizeof(remote_addr_tcp);
len_recv_data_tcp=recv(events[n].data.fd,send_data_buffer_size_tcp,BUFFER_SIZE_TCP,0);
if(len_recv_data_tcp<=0)
{
printf("close id is : %d \n",events[n].data.fd);
if(epoll_ctl(epoll_fd_tcp,EPOLL_CTL_DEL,events[n].data.fd,&ev)==0)
{
printf("delete ok \n");
close(events[n].data.fd);
}
else
{
printf("delete error \n");
}
}
else
{//处理PC来的命令包，，调用fuction.c文件中的 Receive_Process（）函数
Receive_Process(4,send_data_buffer_size_tcp,retn_data_buffer_size_tcp);
ev.data.fd = events[n].data.fd;
ev.events = EPOLLOUT|EPOLLET;
epoll_ctl(epoll_fd_tcp, EPOLL_CTL_MOD, events[n].data.fd, &ev);
}
}
else if(events[n].events & EPOLLOUT)//发送
{
tcp_send_data_to_pc(4,send_data_buffer_size_tcp); //这个地方就正常
}
}
if(server_sock_fd_tcp>0)
{
printf("socket close \n");
shutdown(server_sock_fd_tcp,SHUT_RDWR);
close(server_sock_fd_tcp);
}
}
tcp.h头文件
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/time.h>
#include <sys/resource.h>
#define BUFFER_SIZE_TCP 40
#define MAX_EVENTS_TCP 10
#define HOST_IP_ADDRESS_TCP "192.168.1.200"
#define HOST_PORT_TCP 4530
int n;
struct epoll_event ev;// epoll事件结构体
int epoll_fd_tcp;
int tcp_send_data_to_pc(int len,char* buffer);
void tcp_initialize();
int create_epoll_tcp(unsigned int event_num);
void do_process_tcp_nowhile();
------解决思路----------------------
好奇为何不直接用libevent呢？
------解决思路----------------------
实现不好意思回这个贴了
上两次回贴都没帮到你。
发送数据跟 epoll 是没有关系的. 都可以直接 write(fd ,....)
Receive_Process(4,send_data_buffer_size_tcp ...)
write(events[n].data.fd, send_data_buffer_size_tcp, 4); // 直接发
下面的 所有关于EPOLLOUT 事件注册和处理都不要了
// ---------------------------------------
楼主是不是看了百度百科那份epoll 资料呀！？那份资料有点坑爹
相关推荐
- EPOLL 方式的 TCP 怎么封装一个发送函数，任意文件中可以定义
- linux上sem_init函数的使用有关问题
- 用vector实现字符串分割封装成函数不能实现的有关问题，谢谢
- linux Epoll 发送函数的封装有关问题.
- Linux下的strtof函数如何出有关问题了
- Linux下使用curl命令发送GET请求时多个参数截断的有关问题
- fread函数读入图片数据到内存及用send函数发送时的参数有关问题
- 请教一个封装函数的有关问题
- Linux下mmap函数的有关问题
- linux 上的函数copy_to_user()有关问题
- init.rc添加shell脚本无法自启动有关问题
-
android textView 中加载
标签中的网络图片，ImageGetter中 getDrawable(Str）str为null解决方法