Pouvez-vous bind() et connect (), les deux extrémités d'une connexion UDP

UDP sans connexion, donc il n'y a que peu de sens pour l'OS en fait une sorte de connexion.

Dans sockets BSD, on peut faire une connect sur un socket UDP, mais c'est fondamentalement juste définit la valeur par défaut adresse de destination pour send (au lieu de donner explicitement à send_to).

Lier sur un socket UDP indique au système d'exploitation pour lequel entrant adresse à accepter des paquets (tous les paquets à d'autres adresses sont supprimés), quel que soit le type de socket.

Lors de la réception, vous devez utiliser recvfrom pour identifier la source du paquet provient d'. Notez que si vous voulez une sorte d'authentification, puis en utilisant simplement les adresses concernées est aussi incertain que pas de serrure à tous. Les connexions TCP peut être détourné et nu UDP a littéralement usurpation d'adresse IP écrit sur sa tête. Vous devez ajouter une sorte de HMAC

Voici un programme qui montre comment bind() et connect() sur le même socket UDP à un ensemble spécifique de ports source et destination, respectivement. Le programme peut être compilé sur toute machine Linux et a l'utilisation suivante:

usage: ./<program_name> dst-hostname dst-udpport src-udpport

J'ai testé ce code d'ouverture de deux terminaux. Vous devriez être en mesure d'envoyer un message vers le nœud de destination et de recevoir des messages à partir de ce.

Dans le terminal 1 exécuter

./<program_name> 127.0.0.1 5555 5556

Dans le terminal 2 exécutez

./<program_name> 127.0.0.1 5556 5555

Même si je l'ai testé sur une seule machine, je pense qu'il devrait également travailler sur deux machines différentes, une fois que vous avez configuré l'corriger les paramètres du pare-feu

Voici une description du flux:

1. Conseils d'installation indiqué le type d'adresse de destination, comme celui d'une connexion UDP
2. Utilisation getaddrinfo pour obtenir l'adresse info structure dstinfo basé sur l'argument 1, qui est l'adresse de destination et l'argument 2, qui est le port de destination
3. Créer un socket avec la première entrée valide dans dstinfo
4. Utilisation getaddrinfo pour obtenir l'adresse info structure srcinfo principalement pour le port source des détails
5. Utilisation srcinfo à se lier à la socket obtenu
6. Maintenant se connecter à la première entrée en vigueur de dstinfo
7. Si tout va bien entrer dans la boucle
8. La boucle utilise un select sur le bloc de lecture du descripteur de liste qui se compose de l'entrée standard STDIN et socket sockfd créé
9. Si STDIN dispose d'une entrée, il est envoyé à la destination de connexion UDP en utilisant sendall fonction
10. Si MOE est reçu, la boucle est sortie.
11. Si sockfd a certaines données, il est possible de lire à travers recv
12. Si recv retourne -1, c'est une erreur, nous essayons de décoder avec perror
13. Si recv renvoie la valeur 0, cela signifie que le nœud distant a fermé la connexion. Mais je crois n'a pas de conséquence avec UDP, qui est sans connexion.

---

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define STDIN 0
int sendall(int s, char *buf, int *len)
{
int total = 0;        //how many bytes we've sent
int bytesleft = *len; //how many we have left to send
int n;
while(total < *len) {
n = send(s, buf+total, bytesleft, 0);
fprintf(stdout,"Sendall: %s\n",buf+total);
if (n == -1) { break; }
total += n;
bytesleft -= n;
}
*len = total; //return number actually sent here
return n==-1?-1:0; //return -1 on failure, 0 on success
} 
int main(int argc, char *argv[])
{
int sockfd;
struct addrinfo hints, *dstinfo = NULL, *srcinfo = NULL, *p = NULL;
int rv = -1, ret = -1, len = -1,  numbytes = 0;
struct timeval tv;
char buffer[256] = {0};
fd_set readfds;
//don't care about writefds and exceptfds:
//    select(STDIN+1, &readfds, NULL, NULL, &tv);
if (argc != 4) {
fprintf(stderr,"usage: %s dst-hostname dst-udpport src-udpport\n");
ret = -1;
goto LBL_RET;
}
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;        //UDP communication
/*For destination address*/
if ((rv = getaddrinfo(argv[1], argv[2], &hints, &dstinfo)) != 0) {
fprintf(stderr, "getaddrinfo for dest address: %s\n", gai_strerror(rv));
ret = 1;
goto LBL_RET;
}
//loop through all the results and make a socket
for(p = dstinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("socket");
continue;
}
/*Taking first entry from getaddrinfo*/
break;
}
/*Failed to get socket to all entries*/
if (p == NULL) {
fprintf(stderr, "%s: Failed to get socket\n");
ret = 2;
goto LBL_RET;
}
/*For source address*/
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;        //UDP communication
hints.ai_flags = AI_PASSIVE;     //fill in my IP for me
/*For source address*/
if ((rv = getaddrinfo(NULL, argv[3], &hints, &srcinfo)) != 0) {
fprintf(stderr, "getaddrinfo for src address: %s\n", gai_strerror(rv));
ret = 3;
goto LBL_RET;
}
/*Bind this datagram socket to source address info */
if((rv = bind(sockfd, srcinfo->ai_addr, srcinfo->ai_addrlen)) != 0) {
fprintf(stderr, "bind: %s\n", gai_strerror(rv));
ret = 3;
goto LBL_RET;
}
/*Connect this datagram socket to destination address info */
if((rv= connect(sockfd, p->ai_addr, p->ai_addrlen)) != 0) {
fprintf(stderr, "connect: %s\n", gai_strerror(rv));
ret = 3;
goto LBL_RET;
}
while(1){
FD_ZERO(&readfds);
FD_SET(STDIN, &readfds);
FD_SET(sockfd, &readfds);
/*Select timeout at 10s*/
tv.tv_sec = 10;
tv.tv_usec = 0;
select(sockfd + 1, &readfds, NULL, NULL, &tv);
/*Obey your user, take his inputs*/
if (FD_ISSET(STDIN, &readfds))
{
memset(buffer, 0, sizeof(buffer));
len = 0;
printf("A key was pressed!\n");
if(0 >= (len = read(STDIN, buffer, sizeof(buffer))))
{
perror("read STDIN");
ret = 4;
goto LBL_RET;
}
fprintf(stdout, ">>%s\n", buffer);
/*EOM\n implies user wants to exit*/
if(!strcmp(buffer,"EOM\n")){
printf("Received EOM closing\n");
break;
}
/*Sendall will use send to transfer to bound sockfd*/
if (sendall(sockfd, buffer, &len) == -1) {
perror("sendall");
fprintf(stderr,"%s: We only sent %d bytes because of the error!\n", argv[0], len);
ret = 5;
goto LBL_RET;
}  
}
/*We've got something on our socket to read */
if(FD_ISSET(sockfd, &readfds))
{
memset(buffer, 0, sizeof(buffer));
printf("Received something!\n");
/*recv will use receive to connected sockfd */
numbytes = recv(sockfd, buffer, sizeof(buffer), 0);
if(0 == numbytes){
printf("Destination closed\n");
break;
}else if(-1 == numbytes){
/*Could be an ICMP error from remote end*/
perror("recv");
printf("Receive error check your firewall settings\n");
ret = 5;
goto LBL_RET;
}
fprintf(stdout, "<<Number of bytes %d Message: %s\n", numbytes, buffer);
}
/*Heartbeat*/
printf(".\n");
}
ret = 0;
LBL_RET:
if(dstinfo)
freeaddrinfo(dstinfo);
if(srcinfo)
freeaddrinfo(srcinfo);
close(sockfd);
return ret;
}

Cette page contient quelques info sur connecté rapport de connexité sockets:
http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch08lev1sec11.html

Cette citation répond à votre question:

Normalement, c'est un client UDP que les appels se connecter, mais il y a des applications dans lesquelles l'UDP serveur communique avec un seul client pour une longue durée (par exemple, TFTP); dans ce cas, le client et le serveur peuvent appeler se connecter.

Il y a un problème dans votre code:

memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;        //UDP communication
/*For destination address*/
if ((rv = getaddrinfo(argv[1], argv[2], &hints, &dstinfo)) 

En utilisant AF_UNSPEC et SOCK_DGRAM seulement, vous permet d'obtenir une liste de tous les possibles addrs. Ainsi, lorsque vous appelez socket, l'adresse que vous utilisez peut-être pas prévu, UDP un. Vous devez utiliser

hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
hints.ai_flags = AI_PASSIVE;

au lieu de assurez-vous que le addrinfo vous obtenez est ce que vous vouliez.

En un mot, la prise que vous avez créé ne peut pas être une socket UDP, et c'est la raison pourquoi il ne fonctionne pas.

Je le regarde plus de l'idée de ce que UDP est à fournir. UDP est de 8 octets d'en-tête qui ajoute 2 octets d'envoyer et de recevoir des ports (4 octets au total). Ces ports interagir avec les Sockets Berkeley pour offrir à votre traditionnel socket interface. I. e. vous ne pouvez pas lier à une adresse sans un port ou vice-versa.

Généralement lorsque vous envoyez un paquet UDP de le recevoir côté port (source) est éphémère et le côté de l'envoi (port de destination) est votre port de destination sur l'ordinateur distant. Vous pouvez désactiver ce comportement par défaut en se liant d'abord et ensuite la connexion. Maintenant, votre port source et port destination serait la même aussi longtemps que les mêmes ports sont gratuits sur les deux ordinateurs.

En général, ce comportement (appelons-le port de détournement), c'est mal vu. C'est parce que vous avez juste limité envoyer votre côté à seulement capable de l'envoyer d'un processus, plutôt que de travailler au sein de l'éphémère modèle qui alloue dynamiquement envoyer du côté de la source de ports.

D'ailleurs, les quatre autres octets de huit octets UDP charge utile, de la longueur et de la CRC sont à peu près totalement inutile comme ils sont déjà fournis dans le paquet IP et UDP en-tête est de longueur fixe. Comme viennent sur les personnes, les ordinateurs sont assez bon à faire un peu de soustraction.