C++实现局域网双向通信（socket）

如果想要实现两不同局域网之间的主机进程通信，即实现局域网内两个电脑之间的数据传输，那么就不能通过管道或者命名管道的方式来实现，这里的局域网通信是通过一种叫做socket套接字的方式来实现。

首先想要与同一局域网内部的另一个电脑进行数据传输，需要知道它的IP地址，因为IP是连接网络之后分配给个人主机的唯一标识，所以先找到想要建立连接的主机的地址，然后我们双方共同约定一个类似于管道的唯一出入口（也就是端口号port），这里的端口号一般分为公认端口号和注册端口号，约定好端口号传输的时候双方都需要遵守共同的网络协议（TCP（SOCK_STREAM），UDP（SOCK_DRAM），ICMP（SOCK_RAW））。

公认端口号：知名端口即众所周知的端口号，范围从0到1023，这些端口号一般固定分配给一些服务。比如21端口分配给FTP(文件传输协议)服务，25端口分配给SMTP（简单邮件传输协议）服务，80端口分配给HTTP服务，135端口分配给RPC（远程过程调用）服务等等

注册端口号：端口号从1025到49151。它们松散地绑定于一些服务。也是说有许多服务绑定于这些端口，这些端口同样用于许多其他目的。这些端口多数没有明确的定义服务对象，不同程序可根据实际需要自己定义，如后面要介绍的远程控制软件和木马程序中都会有这些端口的定义的。记住这些常见的程序端口在木马程序的防护和查杀上是非常有必要的。常见木马所使用的端口在后面将有详细的列表

一般选择端口号都是选择注册端口号，没有明确的定义 服务对象，不同的通信可以根据自己的需要进行定义。

实现过程如下：

server:

[cpp]  view plain  copy

1. #include <arpa/inet.h>//包含socket函数使用的各种协议族，send(),recv()  
2. #include <unistd.h>//调用linux系统函数的头文件(read(),write(),send()，select())  
3. #include <iostream>  
4. #include <thread>  
5. #include <list>  
6. #define PORT 7000  
7. #define IP "127.0.0.1"  
8.   
9. int s;  
10. struct sockaddr_in servaddr;  
11. socklen_t len;  
12. std::list<int> li;  
13.   
14. void getConn() {  
15.     while(1){  
16.         int conn = accept(s, (struct sockaddr*)&servaddr, &len);//第二个参数保存客户端套接字对应的IP地址和port 端口信息  
17.         li.push_back(conn);  
18.         printf("%d\n", conn);  
19.     }  
20. }  
21.   
22. void getData() {  
23.     struct timeval tv;  
24.     tv.tv_sec = 2;  
25.     tv.tv_usec = 0;  
26.     while(1) {  
27.         std::list<int>::iterator it;  
28.         for(it=li.begin(); it!=li.end(); ++it){  
29.             fd_set rfds;  
30.             FD_ZERO(&rfds);  
31.             int maxfd = 0;  
32.             int retval = 0;  
33.             FD_SET(*it, &rfds);  
34.             if(maxfd < *it){  
35.                 maxfd = *it;  
36.             }  
37.             retval = select(maxfd+1, &rfds, NULL, NULL, &tv);//实现非阻塞式的通信，即需要等待时间的发生，一旦执行一定返回，返回的结果不同以表示函数执行的结果  
38.             if(retval == -1){  
39.                 printf("select error\n");  
40.             }else if(retval == 0) {  
41.             }else{  
42.                 char buf[1024];  
43.                 memset(buf, 0 ,sizeof(buf));  
44.                 long len = recv(*it, buf, sizeof(buf), 0);  
45.                 printf("%s", buf);  
46.             }  
47.         }  
48.         sleep(1);  
49.           
50.     }  
51. }  
52.   
53. void sendMess() {  
54.     while(1) {  
55.         char buf[1024];  
56.         fgets(buf, sizeof(buf), stdin);//从文件流读取一行，送到缓冲区，使用时注意以下几点  
57.         std::list<int>::iterator it;  
58.         for(it=li.begin(); it!=li.end(); ++it){  
59.             send(*it, buf, sizeof(buf), 0);  
60.         }  
61.     }  
62. }  
63.   
64. int main() {  
65.     s = socket(AF_INET, SOCK_STREAM, 0);  
66.     memset(&servaddr, 0, sizeof(servaddr));  
67.     servaddr.sin_family = AF_INET;  
68.     servaddr.sin_port = htons(PORT);  
69.     servaddr.sin_addr.s_addr = inet_addr(IP);  
70.     if(bind(s, (struct sockaddr* ) &servaddr, sizeof(servaddr))==-1) {  
71.         perror("bind");  
72.         exit(1);  
73.     }  
74.     if(listen(s, 20) == -1) {  
75.         perror("listen");  
76.         exit(1);  
77.     }  
78.     len = sizeof(servaddr);  
79.     std::thread t(getConn);  
80.     t.detach();  
81.     std::thread t1(sendMess);  
82.     t1.detach();  
83.     std::thread t2(getData);  
84.     t2.detach();  
85.     while(1){  
86.           
87.     }  
88.     return 0;  
89. }  

client:

[cpp]  view plain  copy

1. #include <arpa/inet.h>  
2. #include <unistd.h>  
3. #include <iostream>  
4. #define MYPORT  7000  
5. #define BUFFER_SIZE 1024  
6. int main(int argc,char *argv[])  
7. {  
8.     int sock_cli;  
9.     fd_set rfds;  
10.     struct timeval tv;//设置时间  
11.     int retval, maxfd;  
12.       
13.     ///定义sockfd  
14.     sock_cli = socket(AF_INET,SOCK_STREAM, 0);  
15.     ///定义sockaddr_in  
16.     struct sockaddr_in servaddr;  
17.     memset(&servaddr, 0, sizeof(servaddr));  
18.     servaddr.sin_family = AF_INET;  
19.     char s[1024];  
20.     int a;  
21.     std::cout << "输入想要建立连接的端口号以及IP地址:" << std::endl;  
22.     scanf("%d",&a);  
23.     getchar();  
24.     scanf("%s",s);  
25.     servaddr.sin_port = htons(a);  ///服务器端口，利用htons将主机字节顺序转换为网路字节数序从而进行数据包的传送  
26.     servaddr.sin_addr.s_addr = inet_addr(s);  ///服务器ip  
27.       
28.     //连接服务器，成功返回0，错误返回-1  
29.     if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
30.     {  
31.         perror("connect");  
32.         exit(1);  
33.     }  
34.       
35.     while(1){  
36.         /*把可读文件描述符的集合清空*/  
37.         FD_ZERO(&rfds);  
38.         /*把标准输入的文件描述符加入到集合中*/  
39.         FD_SET(0, &rfds);  
40.         maxfd = 0;  
41.         /*把当前连接的文件描述符加入到集合中*/  
42.         FD_SET(sock_cli, &rfds);  
43.         /*找出文件描述符集合中最大的文件描述符*/  
44.         if(maxfd < sock_cli)  
45.             maxfd = sock_cli;  
46.         /*设置超时时间*/  
47.         tv.tv_sec = 5;  
48.         tv.tv_usec = 0;  
49.         /*等待聊天*/  
50.         retval = select(maxfd+1, &rfds, NULL, NULL, &tv);//int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval*timeout);  监视我们需要的文件的文件描述符的变化情况——读写或是异常  
51.         if(retval == -1){  
52.             printf("select出错，客户端程序退出\n");  
53.             break;  
54.         }else if(retval == 0){//超时  
55.             printf("客户端没有任何输入信息，并且服务器也没有信息到来，waiting...\n");  
56.             continue;  
57.         }else{//文件可进行读写或者出错  
58.             /*服务器发来了消息*/  
59.             if(FD_ISSET(sock_cli,&rfds)){  
60.                 char recvbuf[BUFFER_SIZE];  
61.                 long len;  
62.                 len = recv(sock_cli, recvbuf, sizeof(recvbuf),0);  
63.                 printf("%s", recvbuf);  
64.                 memset(recvbuf, 0, sizeof(recvbuf));  
65.             }  
66.             /*用户输入信息了,开始处理信息并发送*/  
67.             if(FD_ISSET(0, &rfds)){  
68.                 char sendbuf[1024];  
69. //                scanf("%s",sendbuf);  
70.                 fgets(sendbuf, sizeof(sendbuf), stdin);  
71.                 send(sock_cli, sendbuf, strlen(sendbuf),0); //发送  
72.                 memset(sendbuf, 0, sizeof(sendbuf));  
73.             }  
74.         }  
75.     }  
76.       
77.     close(sock_cli);  
78.     return 0;  
79. }