c++——正向代理

c++——正向代理

• 代理端作为客户端的监听端口、目的端的客户端口
• 正向代理B就像中转站，只做信息转发

实现思路

1. 监听客户端的连接,如果有客户端连上来,代理程序向目标端发起连接请求，建立连接。
2. 不管哪个socket连接收到了报文，原封不动的发给对端。

/*inetd.cpp*/
#include <sys/epoll.h>
#include <signal.h>
#include <string.h>
#include <sys/socket.h>
#include <iostream>
#include <fcntl.h>
#include <vector>
#include <poll.h>
#include <unistd.h>
#include  <netdb.h>

struct st_route{ // 正向代理路由结构体
        int listenport;	// 监听端口
        char* dstip;	// 目的ip
        int dstport;	// 目的端口
        int listensock;	// 监听sock文件描述符
} stroute;

int epollfd;
// vector<struct st_route> vroute; // 如果有多个转发需求

int initsocket(int port);

int conntodst(char* ip, int port);

int clientvec[2048]; // 建立端口对
/* 如 客户端fd：clientfd		目的端fd:dspfd
	clientvec[clientfd] = dspfd
	clientvec[dspfd] = clientfd
*/

void EXIT(int sig);

int main(int argv, char** argc){

        for(int i = 0; i < 64; i++){signal(i, SIG_IGN);}
        signal(2, EXIT); signal(15, EXIT);

        if(argv != 4){printf("Error argc! ./inetd listenport dstip dstport \n"); return -1;}
        stroute.listenport = atoi(argc[1]);
        stroute.dstip = argc[2];
        stroute.dstport = atoi(argc[3]);
        if((stroute.listensock = initsocket(stroute.listenport)) < 0){perror("failed listen.\n"); return -1;}
        epollfd = epoll_create(1);
        struct epoll_event ev;
        ev.events = EPOLLIN;
        ev.data.fd = stroute.listensock;
        epoll_ctl(epollfd, EPOLL_CTL_ADD, stroute.listensock, &ev);
        struct epoll_event Evs[10];
        while(true){
                int infds = epoll_wait(epollfd, Evs, 10, -1);
                if(infds < 0){printf("epoll failed\n"); return -1;}
                for(int i = 0; i < infds; i++){
                        if(Evs[i].data.fd == stroute.listensock){ // 监听事件
                            	// 连接客户端
                                struct sockaddr_in client_addr;
                                socklen_t len = sizeof(client_addr);
                                int srcsockfd;
                                if ((srcsockfd = accept(Evs[i].data.fd, (struct sockaddr*)&client_addr, &len)) < 0){perror("error accept.\n"); return -1;}
								
                            	// 向目的端发送连接
                                int dstsockfd;
                                if((dstsockfd = conntodst(stroute.dstip, stroute.dstport)) < 0) {perror("error conntodst\n"); return -1;}
                            
                            	// 加入epoll
                                ev.data.fd = srcsockfd; ev.events = EPOLLIN;
                                epoll_ctl(epollfd, EPOLL_CTL_ADD, srcsockfd, &ev);
                                ev.data.fd = dstsockfd; ev.events = EPOLLIN;
                                epoll_ctl(epollfd, EPOLL_CTL_ADD, dstsockfd, &ev);
                            	// 加入clientvec
                                clientvec[srcsockfd] = dstsockfd; clientvec[dstsockfd] = srcsockfd;
                        }else{
                            	// 接收一端信息并发送给另一端
                                char buffer[2048];
                                int buflen = 0;
                                memset(&buffer, 0, sizeof(buffer));
                                if((buflen = recv(Evs[i].data.fd, buffer, sizeof(buffer), 0)) <= 0){ // 连接断开，关闭连接
                                        printf("client(%d, %d) disconnect\n", Evs[i].data.fd, clientvec[Evs[i].data.fd]);
                                        close(Evs[i].data.fd);
                                        close(clientvec[Evs[i].data.fd]);
                                        clientvec[clientvec[Evs[i].data.fd]] = 0;
                                        clientvec[Evs[i].data.fd] = 0;
                                        continue;
                                }
                                send(clientvec[Evs[i].data.fd], buffer, buflen, 0);

                        }
                }
        }


        return 0;
}


int initsocket(int port){ // 初始化监听端口
        int sockfd;
        int opt = 1;
        if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){return -1;}
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
        struct sockaddr_in serveraddr;
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
        serveraddr.sin_port = htons(port);
        if(bind(sockfd, (struct sockaddr *)& serveraddr, sizeof(struct sockaddr)) < 0){perror("bind failed.\n");close(sockfd);return -1;}
        if(listen(sockfd, 10) != 0) {perror("listen failed.\n");close(sockfd);return -1;}
        fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK); // sock非阻塞
        return sockfd;
}


int conntodst(char* ip, int port){ // 连接目的端口

        int sockfd;
        int opt = 1;
        if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){return -1;}
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(port);
        struct hostent *h;
        if((h = gethostbyname(ip)) == 0){close(sockfd); return -1;}
        memcpy(&servaddr.sin_addr, h->h_addr, h->h_length);
        if(connect(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr)) < 0){
                perror("error connect.\n");
                close(sockfd);
                return -1;
        }
        fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK); // sock非阻塞
        return sockfd;
}

void EXIT(int sig){ // 信号处理函数
        printf("Exit! Signal=%d\n", sig);
        for(int i = 0; i < 2048; i++){
                if(clientvec[i]>0){close(clientvec[i]);}
        }
        if(stroute.listensock>0){close(stroute.listensock);}
        close(epollfd);
        exit(0);
}

结果

• 代理端
  
• 远程目的端
  
• 本地客户端