网络编程- 客户端（select） 服务端 epoll

服务端，收到客户端的消息转给另一个线程进行转发

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<sys/epoll.h>
#include<map>
#include<typeinfo>
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
#define BUFFER_SIZE 40
#define MAX_EVENTS 1234
#define DEFAULT_PORT 1231

queue<char *>q;
map<int ,int>flag_fd;
map<int ,int>fd_flag;

void *send_queue_to_client(void *)
{
    while(1)
    {
        while(!q.empty())
        {

            char *s=q.front();
            printf("------thread running now------    %s将要发送给%c\n",s,s[0]);
            int go=s[0]-'0';
            go=flag_fd[go];
            if(go==0)
            {
                printf("未指明要发送的对象，不做处理,直接舍弃\n");
            }
            else
            {
                int flag_send=send(go,s,strlen(s),0);
                if(flag_send<0)
                    printf("send失败");
                printf("发送%s到%c成功\n",s,s[0]);
            }
            delete []s;
            q.pop();
            sleep(3);
        }
        sleep(10);
    }
}


void thread_create(pthread_t send_buff_to_client )
{
    send_buff_to_client=pthread_create(&send_buff_to_client,NULL,send_queue_to_client,NULL);
    if(send_buff_to_client==0)
        printf("进程创建成功\n");
    else
        printf("进程创建失败\n");
}
void thread_wait(pthread_t send_buff_to_client)
{
    if(send_buff_to_client!=0)
    {
        pthread_join(send_buff_to_client,NULL);
        printf("该线程已经结束\n");
    }
}
int main(int argc ,char** argv )
{
    pthread_t send_buff_to_client;
    thread_create(send_buff_to_client);/create

    int server_sockfd,client_sockfd;
    //char buff[BUFFER_SIZE];
    int len;
    struct sockaddr_in my_addr,remote_addr;
    socklen_t  sin_size;


    memset(&my_addr,0,sizeof(my_addr));
    my_addr.sin_family=AF_INET;
    my_addr.sin_addr.s_addr=INADDR_ANY;
    my_addr.sin_port=htons(DEFAULT_PORT);


    server_sockfd=socket(AF_INET,SOCK_STREAM,0);//socket
    if(server_sockfd<0)
    {
        perror("socket\n");
        return 1;
    }
    unsigned int value = 1;//设置端口复用
    setsockopt(server_sockfd,SOL_SOCKET,SO_REUSEADDR,(void *)&value,sizeof(value));


    if(bind(server_sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))<0)//bind
    {
        perror("bind\n");
        return 1;

    }

    printf("----等待客户端请求中-----\n");
    listen(server_sockfd,55555);//listen
    sin_size=sizeof(struct sockaddr_in);


    int  epoll_fd;
    epoll_fd=epoll_create(MAX_EVENTS);//epoll_create
    if(epoll_fd==-1)
    {
        perror("epoll_create failed\n");
        exit(EXIT_FAILURE);
    }


    struct epoll_event ev;
    struct epoll_event events[MAX_EVENTS];
    ev.events=EPOLLIN|EPOLLET;
    ev.data.fd=server_sockfd;

    if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,server_sockfd,&ev)==-1)
    {
        perror("注册失败\n");
        exit(EXIT_FAILURE);
    }

    int flag=1;

    int fds;
    while(1)
    {
        fds=epoll_wait(epoll_fd,events,MAX_EVENTS,-1);
        if(fds==-1)
        {
            perror("启动epoll等待失败\n");
            exit(EXIT_FAILURE);
        }
        int i;
        for( i=0; i<fds; i++)
        {
            if(events[i].data.fd==server_sockfd)
            {

                //printf("events[i].data.fd:%d\n",events[i].data.fd);
                client_sockfd=accept(server_sockfd,(struct sockaddr *)&remote_addr,&sin_size);
                if(client_sockfd<0)
                {
                    perror("客户端接收失败\n");
                    exit(EXIT_FAILURE);
                }
                ev.events=EPOLLIN;
                ev.data.fd=client_sockfd;
                flag_fd[flag]=client_sockfd;
                fd_flag[client_sockfd]=flag;
                flag++;
                if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,client_sockfd,&ev)==-1)
                {
                    perror("客户端epoll注册失败\n");
                    exit(EXIT_FAILURE);
                }


                send(client_sockfd,inet_ntoa(remote_addr.sin_addr),sizeof(inet_ntoa(remote_addr.sin_addr))+1,0);
                sleep(2);
                send(client_sockfd,p,sizeof(int),0);

                printf("来自--%s-%d-的客户端\n",inet_ntoa(remote_addr.sin_addr),remote_addr.sin_port);


            }
            else
            {

                printf("events[i].data.fd:%d\n",events[i].data.fd);
                printf("已收到消息，准备接收------\n");
                char *buff=new char[100];
                len=recv(events[i].data.fd,buff,BUFFER_SIZE,0);
                if(len<0)
                {
                    perror("接收数据失败\n");
                    exit(EXIT_FAILURE);
                }
                printf("收到来自客户端的数据书：%s\n",buff);
                q.push(buff);
                //send(events[i].data.fd,"successful",12,0);

                //printf("已向客户端发送确认消息:%s\n","successful");
                printf("\n");
            }
        }
    }
    thread_wait(send_buff_to_client);
    return 0;
}

客户端：select的收发模式

#include<stdio.h>
#include<pthread.h>
#include<netinet/in.h>
#include <pthread.h>
#include <sys/poll.h>
#include<stdlib.h>
#include<string.h>
#include<strings.h>
#include<sys/types.h>
#include<sys/socket.h>
int main(int argc,char **argv)
{
    int socketfd,ret;
    fd_set fd;
    FD_ZERO(&fd);
    FD_SET(0,&fd);


    socketfd = socket(AF_INET,SOCK_STREAM,0);
    FD_SET(socketfd,&fd);
    ret = select(socketfd+1,&fd,NULL,NULL,NULL);
    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family = PF_INET;
    saddr.sin_port = htons(1231);
    saddr.sin_addr.s_addr = INADDR_ANY;

    if(connect(socketfd,(struct sockaddr *)&saddr,sizeof(struct sockaddr))<0)

        perror("connect() error!\n");//只要与服务器连上立马将自己的昵称发送过去

    //send(socketfd,argv[0],strlen(argv[0]),0);
    char buf[50],buf1[50];
    while(1)
    {
        
        bzero(buf,50);
        bzero(buf1,50);

        FD_SET(0,&fd);
        FD_SET(socketfd,&fd);
        ret = select(socketfd+1,&fd,NULL,NULL,NULL);
        if(FD_ISSET(socketfd,&fd))
        {
            printf("有数据发来，准备接收：");
            if(recv(socketfd,buf1,sizeof(buf1),0)<0)
                perror("recv() error!\n");
            printf("接收成功，收到的是：%s\n",buf1);

        printf("暂时没有数据发来，你可以尝试输入你想发往服务端的数据:\n");
            continue;
        }
        if(FD_ISSET(0,&fd))
        {   
            scanf("%s",buf);
            if(send(socketfd,buf,strlen(buf),0)<0)
                perror("send() error!\n");
            continue;
        }

    }
}