关闭

客户端调用bind的作用及UDP客户端调用connect的问题

584人阅读 评论(0) 收藏 举报
分类:

原文地址http://blog.chinaunix.net/uid-20401941-id-3178235.html

在水木上看到一个关于在客户端调用bind的讨论,


如果不调用bind,则客户端在向外发包时,会由系统自己决定使用的接口的源端口,而调用bind则可以指定相应的参数。

另外有个哥们提到“果是udp,使用bind以后,可以不使用sendto/recvform函数,而直接用write/read函数了,少去了写一个参数。”,这应该是调用connect后的效果。

关于UDP中客户端调用connect的好处,还有一个作用是能够捕获错误
由于UDP是无连接的,connect在调用时其实没有向外发包,只是在协议栈中记录了该状态,应该是生成了一个类似TCB的结构。之后如果发生网络异常,比如对端不可达,客户端在往对端写数据后,本机会收到一个ICMP回应,则回来的ICMP不可达的响应能够被协议栈处理,通知客户端进程;当客户端再次对该fd进行操作时,比如读数据时,read等调用会返回一个错误。而不调用connect时,对于返回的ICMP响应,协议栈不知道该传递给上层的哪个应用,所以客户端进程中捕获不到相应的错误。
在两种情况下,write或者sendto操作都是把数据放到协议栈的发送队列之后就返回成功,而相应的ICMP回应则要等数据到达对端后才能返回,所以通常这种情况叫做“异步错误”。

使用下列代码进行验证:

点击(此处)折叠或打开

  1. #include <sys/socket.h>
  2. #include <unistd.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <arpa/inet.h>
  6. #include <stdlib.h>

  7. #define MAXLINE 80
  8. #define SERV_PORT 8888

  9. struct sockaddr_in servaddr;

  10. void do_cli(FILE *fp,int sockfd,struct sockaddr *pservaddr,socklen_t servlen)
  11. {
  12.     int n;
  13.     char sendline[MAXLINE],recvline[MAXLINE + 1];

  14.     #ifdef UDP_CONNECT
  15.     /* connect to server */
  16.     if(connect(sockfd,(struct sockaddr *)pservaddr,servlen) == -1)
  17.     {
  18.         perror("connect error");
  19.         exit(1);
  20.     }
  21.     #endif

  22.     while(fgets(sendline,MAXLINE,fp) != NULL)
  23.     {
  24.         #ifdef UDP_CONNECT
  25.         /* read a line and send to server */
  26.         write(sockfd,sendline,strlen(sendline));
  27.         #else
  28.         sendto(sockfd, sendline, strlen(sendline), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
  29.         #endif

  30.         printf("write over\n");
  31.         /* receive data from server */
  32.         n = read(sockfd,recvline,MAXLINE);
  33.         if(== -1)
  34.         {

  35.             perror("read error");
  36.             exit(1);
  37.         }
  38.         recvline[n] = 0; /* terminate string */
  39.         fputs(recvline,stdout);
  40.     }
  41. }

  42. int main(int argc,char **argv)
  43. {
  44.     int sockfd;

  45.     /* check args */
  46.     if(argc != 2)
  47.     {
  48.         printf("usage: udpclient serverip\n");
  49.         exit(1);
  50.     }

  51.     /* init servaddr */
  52.     bzero(&servaddr,sizeof(servaddr));
  53.     servaddr.sin_family = AF_INET;
  54.     servaddr.sin_port = htons(SERV_PORT);
  55.     if(inet_pton(AF_INET,argv[1],&servaddr.sin_addr) <= 0)
  56.     {
  57.         printf("[%s] is not a valid IPaddress\n",argv[1]);
  58.         exit(1);
  59.     }
  60.     sockfd = socket(AF_INET,SOCK_DGRAM,0);
  61.     do_cli(stdin,sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
  62.     return 0;
  63. }


########################实验1,客户端进行connect######################
客户端执行:
mt@ubuntu:~/code$ gcc -o udpclient_connect -DUDP_CONNECT udpclient.c
mt@ubuntu:~/code$ ./udpclient_connect 192.168.0.1
abcd
write over
read error: Connection refused

在另一窗口抓包:
mt@ubuntu:~$ sudo tcpdump -i eth0 port 8888 or icmp -v
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes
21:49:40.300735 IP (tos 0x0, ttl 64, id 20973, offset 0, flags [DF], proto UDP (17), length 33)
    localhost.42774 > localhost.8888: UDP, length 5
21:49:40.303965 IP (tos 0x0, ttl 64, id 22696, offset 0, flags [none], proto ICMP (1), length 56)
    localhost > localhost: ICMP localhost udp port 8888 unreachable, length 36
        IP (tos 0x0, ttl 64, id 20973, offset 0, flags [DF], proto UDP (17), length 33)
    localhost.42774 > localhost.8888: UDP, length 5

可以看到,客户端发送数据之后,收到了ICMP不可达的回应,此时客户端进程的read()操作返回了错误,通过perror打印出来的错误信息为:Connection refused
##########################实验1 结束###################################

###########################实验2,客户端不进行connect###############
mt@ubuntu:~/code$ gcc -o udpclient udpclient.c
mt@ubuntu:~/code$ ./udpclient 192.168.0.1
abcd
write over

在另一窗口抓包:
mt@ubuntu:~$ sudo tcpdump -i eth0 port 8888 or icmp -v
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes
22:14:23.863178 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto UDP (17), length 33)
    localhost.46642 > localhost.8888: UDP, length 5
22:14:23.864000 IP (tos 0x0, ttl 64, id 22730, offset 0, flags [none], proto ICMP (1), length 56)
    localhost > localhost: ICMP localhost udp port 8888 unreachable, length 36
        IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto UDP (17), length 33)
    localhost.46642 > localhost.8888: UDP, length 5

尽管有ICMP回应返回,但客户端没有捕获到该错误,此时阻塞在了read调用上。
##############################实验2 结束############################

另外,调用connect之后,会发现应用程序只会对调用了connect的fd进行相应的操作,如果它同时监听在某fd上,则不会响应该监听fd上的数据。比如参考资料2中提到一个程序先用UDP监听在机器B的9000上,同时用udp connect到另一台机器A的8000端口,结果发现使用其他机器往机器B的9000端口发送数据时,它不会做出响应。



参考:
 [3]www.cs.rpi.edu/~hollingd/netprog/notes/udp/udp.pdf

UDP编程中的connect(zt)

标准的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
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
int main()
{
int sockListener,nMsgLen;
char szBuf[1024];
struct sockaddr_in addrListener;
socklen_t addrLen;
addrLen=sizeof(struct sockaddr_in);
bzero(&addrListener,sizeof(addrListener));
addrListener.sin_family=AF_INET;
addrListener.sin_port=htons(8000);

if((sockListener=socket(AF_INET,SOCK_DGRAM,0))==-1)
{
perror("error in getting a socket");
exit(1);
}

if(bind(sockListener,(struct sockaddr*)&addrListener,sizeof(addrListener))==-1)
{
perror("bind a listener for a socket");
exit(2);
}

struct sockaddr_in addrClient;
cout<<"callback server begin to listen"<<endl;
while(true)
{
nMsgLen=recvfrom(sockListener,szBuf,1024,0,(struct sockaddr*)&addrClient,&addrLen);
if(nMsgLen>0)
{
szBuf[nMsgLen]='\0';
cout<<"send back:"<<szBuf<<endl;
sendto(sockListener,szBuf,nMsgLen,0,(struct sockaddr*)&addrClient,addrLen);
}
}

}


再写个客户端,绑定个端口,再连接服务器端。随时接受键盘输入并发送到服务器端,随时接受端口到来的数据并打印。如果没有连接 ,发送到此端口的数据会被接受,但是调用connect后会怎样呢?
a-desktop:~/d/lab$ cat udpclient.cpp
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/select.h>
using namespace std;
int main()
{
int sockClient,nMsgLen,nReady;
char szRecv[1024],szSend[1024],szMsg[1024];
struct sockaddr_in addrServer,addrClient,addrLocal;
socklen_t addrLen;
fd_set setHold,setTest;

sockClient=socket(AF_INET,SOCK_DGRAM,0);
addrLen=sizeof(struct sockaddr_in);
bzero(&addrServer,sizeof(addrServer));
addrServer.sin_family=AF_INET;
addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
addrServer.sin_port=htons(8000);

addrLocal.sin_family=AF_INET;//bind to a local port
addrLocal.sin_addr.s_addr=htonl(INADDR_ANY);
addrLocal.sin_port=htons(9000);
if(bind(sockClient,(struct sockaddr*)&addrLocal,sizeof(addrLocal))==-1)
{
perror("error in binding");
exit(2);
}

if(connect(sockClient,(struct sockaddr*)&addrServer,sizeof(addrServer))==-1)
{
perror("error in connecting");
exit(1);
}

FD_ZERO(&setHold);
FD_SET(STDIN_FILENO,&setHold);
FD_SET(sockClient,&setHold);
cout<<"you can type in sentences any time"<<endl;
while(true)
{
setTest=setHold;
nReady=select(sockClient+1,&setTest,NULL,NULL,NULL);
if(FD_ISSET(0,&setTest))
{
nMsgLen=read(0,szMsg,1024);
write(sockClient,szMsg,nMsgLen);
}
if(FD_ISSET(sockClient,&setTest))
{
nMsgLen=read(sockClient,szRecv,1024);
szRecv[nMsgLen]='\0';
cout<<"read:"<<szRecv<<endl;
}

}

}
最后来个“第三者”,向第二个的端口发数据报。看她会不会成为忠贞的感情守护人:
a@a-desktop:~/d/lab$ cat clienta.cpp
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;
int main()
{
socklen_t addrLen=sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
char szMsg[1024];
int sockClient;

addrServer.sin_family=AF_INET;
addrServer.sin_addr.s_addr=inet_addr("127.0.0.1");
addrServer.sin_port=htons(9000);

sockClient=socket(AF_INET,SOCK_DGRAM,0);
while(true)
{
static int id=0;
snprintf(szMsg,sizeof(szMsg),"this is %d",id++);
sendto(sockClient,szMsg,strlen(szMsg),0,(struct sockaddr*)&addrServer,sizeof(addrServer));
sleep(1);
}
}



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

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后,不甩第三个程序发来的数据包。对于感情,希望将来我的她也能这样。。。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:163799次
    • 积分:2705
    • 等级:
    • 排名:第14207名
    • 原创:87篇
    • 转载:98篇
    • 译文:0篇
    • 评论:28条
    文章分类
    最新评论