UDP中使用connect

最新推荐文章于 2021-01-13 05:01:47 发布

gettogetto

最新推荐文章于 2021-01-13 05:01:47 发布

阅读量474

点赞数

UDP协议中是否可以使用connect，.整理一下.

1:UDP中可以使用connect系统调用

2:UDP中connect操作与TCP中connect操作有着本质区别.TCP中调用connect会引起三次握手,client与server建立连结.UDP中调用connect内核仅仅把对端ip&port记录下来.

3:UDP中可以多次调用connect,TCP只能调用一次connect.

UDP多次调用connect有两种用途:

1,指定一个新的ip&port连结.

2,断开和之前的ip&port的连结.指定新连结,直接设置connect第二个参数即可.断开连结,需要将connect第二个参数中的sin_family设置成 AF_UNSPEC即可.

4:UDP中使用connect可以提高效率.原因如下:

普通的UDP发送两个报文内核做了如下:#1:建立连结#2:发送报文#3:断开连结#4:建立连结#5:发送报文#6:断开连结

采用connect方式的UDP发送两个报文内核如下处理:#1:建立连结#2:发送报文#3:发送报文另外一点,每次发送报文内核都由可能要做路由查询.

5:采用connect的UDP发送接受报文可以调用send,write和recv,read操作.当然也可以调用sendto,recvfrom.调用sendto的时候第五个参数必须是NULL,第六个参数是0.调用recvfrom,recv,read系统调用只能获取到先前connect的ip&port发送的报文.

UDP中使用connect的好处:

1:会提升效率.前面已经描述了.

2:高并发服务中会增加系统稳定性.原因:假设client A 通过非connect的UDP与server B,C通信.B,C提供相同服务.为了负载均衡,我们让A与B,C交替通信.A 与 B通信IPa:PORTa <----> IPb:PORTbA 与 C通信IPa:PORTa' <---->IPc:PORTc

假设PORTa 与 PORTa'相同了(在大并发情况下会发生这种情况),那么就有可能出现A等待B的报文,却收到了C的报文.导致收报错误.解决方法内就是采用connect的UDP通信方式.在A中创建两个udp,然后分别connect到B,C.

=============================================================

标准的udp客户端开了套接口后，一般使用sendto和recvfrom函数来发数据，最近看到ntpclient的代码里面是使用send函数直接法的，就分析了一下，原来udp发送数据有两种方法供大家选用的，顺便把udp的connect用法也就解释清楚了。
方法一：
socket----->sendto()或recvfrom()
方法二：
socket----->connect()----->send()或recv()

首先从这里看出udp中也是可以使用connect的，但是这两种方法到底有什么区别呢？首先把这四个发送函数的定义列出来：
int send(int s, const void *msg, size_t len, int flags);
int sendto(int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen);

int recv(int s, void *buf, size_t len, int flags);
int recvfrom(int s, void *buf, size_t len, int flags,
struct sockaddr *from, socklen_t *fromlen);
从他们的定义可以看出，sendto和recvfrom在收发时指定地址，而send和recv则没有，那么他们的地址是在那里指定的呢，答案就在于connect.
int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t
addrlen);
在udp编程中，如果你只往一个地址发送，那么你可以使用send和recv，在使用它们之前用connect把它们的目的地址指定一下就可以了。connect函数在udp中就是这个作用，用它来检测udp端口的是否开放是没有用的。下面是ntpclient中的代码
struct sockaddr_in sa_dest;
bzero((char *) sa_dest, sizeof(*sa_dest));
sa_dest->sin_family=AF_INET;
if(StuffNetAddr(&(sa_dest->sin_addr),host))
return 1;

sa_dest->sin_port=htons(port);

if (connect(usd,(struct sockaddr *)&sa_dest,sizeof(sa_dest))==-1)
{perror("connect");return 1;}

return 0;

=================================

除非套接口已连接，否则异步错误是不会返回到UDP套接口的，我们确实可以给UDP套接口调用connect，然而这样做的结果却与TCP连接大相径庭：没有三路握手过程。

相反内核只是检查是否存在立即可知的错误(例如一个显然不可达的目的地)，记录对端的IP地址和端口号（取自传递给connect的套接口地址结构），然后立即返回到调用进程。

对于已连接UDP套接口，与缺省的未连接套接口相比，发生了三个变化：
1 我们再也不能给输出操作指定宿IP和端口号，也就是说我们不使用sendto，而改用write或send，写到已连接UDP套接口上的任何内容都自动发送到由connect指定的协议地址（例如IP地址和端口号）
2 我们不必使用recvfrom以获悉数据报的发送者，而改用read，recv或recvmsg，在一个已连接UDP套接口上由内核为输入操作返回的数据报仅仅是那些来自connect所指定协议地址的数据报。目的地为这个已连接UDP套接口的本地协议地址，发源地却不是该套接口早先connect到的协议地址的数据报，不会投递到该套接口。这样就限制了一个已连接UDP套接口而且仅能与一个对端交换数据报。
3 由已连接的UDP套接口引发的异步错误返回给他们所在的进程。

相反我们说过未连接UDP套接口不接收任何异步错误给一个UDP套接口多次调用connect拥有一个已连接UDP套接口的进程可以为下列2个目的之一：
a.指定新的IP地址和端口号；
b.断开套接口

第一个目的（即给一个已连接UDP套接口指定新的对端）不同于TCP套接口中connect的使用:对于TCP套接口，connect只能调用一次。

为了断开一个已connect的UDP套接口连接，我们再次调用connect时把套接口地址结构的地址簇成员（sin_family）设置为AF_UNSPEC。
这么做可能返回一个EAFNOSUPPORT错误，不过没有关系。
使得套接口断开连接的是在已连接UDP套接口上调用connect的进程。

=================================

有如下的一些好处：
1）选定了对端，内核只会将帮定对象的对端发来的数据报传给套接口，因此在一定环境下可以提升安全性；
2)会返回异步错误，如果对端没启动，默认情况下发送的包对应的ICMP回射包不会给调用进程，如果用了connect，嘿嘿
3）发送两个包间不要先断开再连接，提升了效率。

做个实验测试下吧

先弄个UDP回射服务器，把所有收到的数据报回射回去：
a@a-desktop:~/d/lab$ cat rollbackserver.cpp

  1 #include<iostream>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #include<unistd.h>
  5 #include<sys/socket.h>
  6 #include<netinet/in.h>
  7 #include<arpa/inet.h>
  8 using namespace std;
  9 int main()
 10 {
 11 int sockListener,nMsgLen;
 12 char szBuf[1024];
 13 struct sockaddr_in addrListener;
 14 socklen_t addrLen;
 15 addrLen=sizeof(struct sockaddr_in);
 16 bzero(&addrListener,sizeof(addrListener));
 17 addrListener.sin_family=AF_INET;
 18 addrListener.sin_port=htons(8000);
 19 
 20 if((sockListener=socket(AF_INET,SOCK_DGRAM,0))==-1)
 21 {
 22 perror("error in getting a socket");
 23 exit(1);
 24 }
 25 
 26 if(bind(sockListener,(struct sockaddr*)&addrListener,sizeof(addrListener))==-1)
 27 {
 28 perror("bind a listener for a socket");
 29 exit(2);
 30 }
 31 
 32 struct sockaddr_in addrClient;
 33 cout<<"callback server begin to listen"<<endl;
 34 while(true)
 35 {
 36 nMsgLen=recvfrom(sockListener,szBuf,1024,0,(struct sockaddr*)&addrClient,&addrLen);
 37 if(nMsgLen>0)
 38 {
 39 szBuf[nMsgLen]='\0';
 40 cout<<"send back:"<<szBuf<<endl;
 41 sendto(sockListener,szBuf,nMsgLen,0,(struct sockaddr*)&addrClient,addrLen);
 42 }
 43 }
 44 
 45 }
 46 
 47 
 48 再写个客户端，绑定个端口，再连接服务器端。随时接受键盘输入并发送到服务器端，随时接受端口到来的数据并打印。如果没有连接 ，发送到此端口的数据会被接受，但是调用connect后会怎样呢？
 49 a-desktop:~/d/lab$ cat udpclient.cpp
 50 #include<iostream>
 51 #include<stdlib.h>
 52 #include<string.h>
 53 #include<unistd.h>
 54 #include<sys/socket.h>
 55 #include<netinet/in.h>
 56 #include<arpa/inet.h>
 57 #include<sys/select.h>
 58 using namespace std;
 59 int main()
 60 {
 61 　　int sockClient,nMsgLen,nReady;
 62 　　char szRecv[1024],szSend[1024],szMsg[1024];
 63 　　struct sockaddr_in addrServer,addrClient,addrLocal;
 64 　　socklen_t addrLen;
 65 　　fd_set setHold,setTest;
 66 
 67 　　sockClient=socket(AF_INET,SOCK_DGRAM,0);
 68 　　addrLen=sizeof(struct sockaddr_in);
 69 　　bzero(&addrServer,sizeof(addrServer));
 70 　　addrServer.sin_family=AF_INET;
 71 　　addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
 72 　　addrServer.sin_port=htons(8000);
 73 
 74 　　addrLocal.sin_family=AF_INET;//bind to a local port
 75 　　addrLocal.sin_addr.s_addr=htonl(INADDR_ANY);
 76 　　addrLocal.sin_port=htons(9000);
 77 　　if(bind(sockClient,(struct sockaddr*)&addrLocal,sizeof(addrLocal))==-1)
 78 　　{
 79 　　　　perror("error in binding");
 80 　　　　exit(2);
 81 　　}
 82 
 83 　　if(connect(sockClient,(struct sockaddr*)&addrServer,sizeof(addrServer))==-1)
 84 　　{
 85 　　　　perror("error in connecting");
 86 　　　　exit(1);
 87 　　}
 88 
 89 　　FD_ZERO(&setHold);
 90 　　FD_SET(STDIN_FILENO,&setHold);
 91 　　FD_SET(sockClient,&setHold);
 92 　　cout<<"you can type in sentences any time"<<endl;
 93 　　while(true)
 94 　　{
 95 　　　　setTest=setHold;
 96 　　　　nReady=select(sockClient+1,&setTest,NULL,NULL,NULL);
 97 　　　　if(FD_ISSET(0,&setTest))
 98 　　　　{
 99 　　　　　　nMsgLen=read(0,szMsg,1024);
100 　　　　　　write(sockClient,szMsg,nMsgLen);
101 　　　　}
102 　　　　if(FD_ISSET(sockClient,&setTest))
103 　　　　{
104 　　　　　　nMsgLen=read(sockClient,szRecv,1024);
105 　　　　　　szRecv[nMsgLen]='\0';
106 　　　　　　cout<<"read:"<<szRecv<<endl;
107 　　　　}
108 
109 　　}
110 
111 }

最后来个“第三者”，向第二个的端口发数据报。看她会不会成为忠贞的感情守护人:
a@a-desktop:~/d/lab$ cat clienta.cpp

 1 #include<string.h>
 2 #include<iostream>
 3 #include<stdlib.h>
 4 #include<unistd.h>
 5 #include<sys/socket.h>
 6 #include<netinet/in.h>
 7 #include<arpa/inet.h>
 8 using namespace std;
 9 int main()
10 {
11 　　socklen_t addrLen=sizeof(struct sockaddr_in);
12 　　struct sockaddr_in addrServer;
13 　　char szMsg[1024];
14 　　int sockClient;
15 
16 　　addrServer.sin_family=AF_INET;
17 　　addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
18 　　addrServer.sin_port=htons(9000);
19 
20 　　sockClient=socket(AF_INET,SOCK_DGRAM,0);
21 　　while(true)
22 　　{
23 　　　　static int id=0;
24 　　　　snprintf(szMsg,sizeof(szMsg),"this is %d",id++);
25 　　　　sendto(sockClient,szMsg,strlen(szMsg),0,(struct sockaddr*)&addrServer,sizeof(addrServer));
26 　　　　sleep(1);
27 　　}
28 }

实验结果：
现运行第一个程序，再运行第三个程序，然后运行第二个程序。
服务器端：

a@a-desktop:~/d/lab$ ./rollback
callback server begin to listen
send back:xinheblue likes playing

send back:and listenning to music

第二个程序：
a@a-desktop:~/d/lab$ ./udpclient
you can type in sentences any time
xinheblue likes playing
read:xinheblue likes playing

and listenning to music
read:and listenning to music

实现结果证明，第二个程序调用connect后，不甩第三个程序发来的数据包。对于感情，希望将来我的她也能这样。。。