android udp 服务端和客户端 udp客户端需要bind吗

udp 与 connect()

标准的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_taddrlen);在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

1. 以获悉数据报的发送者，而改用read，recv或recvmsg，在一个已连接UDP套接口上由内核为输入操作返回的数据 报仅仅是那些来自connect所指定协议地址的数据报。目的地为这个已连接UDP套接口的本地协议地址，发源地却不是该套接口早先connect到的协 议地址的数据报，不会投递到该套接口。这样就限制了一个已连接UDP套接口而且仅能与一个对端交换数据报。
2. 由已连接的UDP套接口引发的异步错误返回给他们所在的进程。

相反我们说过未连接UDP套接口不接收任何异步错误给一个UDP套接口多次调用connect拥有一个已连接UDP套接口的进程可以为下列2个目的之一：

1. 指定新的IP地址和端口号；
2. 断开套接口

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

为了断开一个已connect的UDP套接口连接，我们再次调用connect时把套接口地址结构的地址簇成员（sin_family）设置为AF_UNSPEC。

这么做可能返回一个EAFNOSUPPORT错误，不过没有关系。

使得套接口断开连接的是在已连接UDP套接口上调用connect的进程。

有如下的一些好处：

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

做个实验测试下吧

先弄个UDP回射服务器，把所有收到的数据报回射回去：

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 << "start listenning" << 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后会怎样呢？

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;
        }
    }
}

最后来个“第三者”，向第二个的端口发数据报。看她会不会成为忠贞的感情守护人:

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);
    }
}

现运行第一个程序，再运行第三个程序，然后运行第二个程序。

服务器端：

callback server begin to listen
send back:xinheblue likes playing
 
send back:and listenning to music

第二个程序：

you can type in sentences any time
xinheblue likes playing
read:xinheblue likes playing
 
and listenning to music
read:and listenning to music

实现结果证明，第二个程序调用connect后，不接收第三个程序发来的数据包。

udp客户端 用不用 bind 的区别

原文:

无连接的socket的客户端和服务端以及面向连接socket的服务端通过调用bind函数来配置本地信息。使用bind函数时，通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。
Bind()函数在成功被调用时返回0；出现错误时返回"-1"并将errno置为相应的错误号。需要注意的是，在调用bind函数时一般不要将端口号置为小于1024的值，因为1到1024是保留端口号，你可以选择大于1024中的任何一个没有被占用的端口号。

有连接的socket客户端通过调用Connect函数在socket数据结构中保存本地和远端信息，无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候打开端口。（当然也有特殊情况，linux系统中rlogin命令应当调用bind函数绑定一个未用的保留端口号，还有当客户端需要用指定的网络设备接口和端口号进行通信等等）
总之：

1. 需要在建连前就知道端口的话，需要 bind
2. 需要通过指定的端口来通讯的话，需要 bind

具体到上面那两个程序，本来用的是TCP，客户端就不用绑定端口了，绑定之后只能运行一个client的程序属于自己人为设定的障碍，而从服务器那边得到的客户机连接端口号（是系统自动分配的）与这边客户机绑定的端口号根本是不相关的，所以客户端绑定也就失去了意义。

首先，服务器和客户端都可以bind，bind并不是服务器的专利。
客户端进程bind端口： 由进程选择一个端口去连服务器，（如果默认情况下，调用bind函数时，内核指定的端口是同一个，那么调用多个调用了bind（）的client程序，会出现端口被占用的错误）注意这里的端口是客户端的端口。如果不分配就表示交给内核去选择一个可用端口。
客户端进程bind IP地址：相当于为发送出去的IP数据报分配了源IP地址，但交给进程分配IP地址的时候（就是这样写明了bind IP地址的时候）这个IP地址必须是主机的一个接口，不能分配一个不存在的IP。如果不分配就表示由内核根据所用的输出接口来选择源IP地址。

一般情况下客户端是不用调用bind函数的，一切都交给内核搞定，YES！

服务端进程bind端口：基本是必须要做的事情，比如一个服务器启动时（比如freebsd），它会一个一个的捆绑众所周知的端口来提供服务，同样，如果bind了一个端口就表示我这个服务器会在这个端口提供一些“特殊服务”。
服务端进程bind IP地址：目的是限制了服务端进程创建的socket只接受那些目的地为此IP地址的客户链接，一般一个服务器程序里都有

servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 只是针对IP4，IP6代码不太一样

这样一句话，意思就是：我不指定客户端的IP，随便连，来者不拒！

总之只要你bind时候没有指定哪一项（置为0），内核会帮你选择。