UDP中connet()的验证代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in servaddr, fromAddr;
socklen_t fromAddrLen;
char *addrBuf;

sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if(sockfd < 0){
perror("SOCKET :");
exit(1);
}

bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);/* INADDR_ANY 指定IP地址为本地主机上任意IP地址 */
servaddr.sin_port = htons(8888);             /* 端口为 8888 */

#if 1
/* 对于"服务器"来说，必须要要绑定一个客户端知道的端口号，客户端才能向该端口发送数据 */
if( bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0){
perror("BIND :");
exit(1);
}
#endif
int n;
char recvline[1024];
memset(recvline, 0, sizeof(recvline));

printf("wait receiving....\n");
while(1){

memset(&fromAddr, 0, sizeof(fromAddr));
fromAddrLen = sizeof(fromAddr);

/* 接收数据，所有到达本机的且端口号为8888的数据包都交由本进程处理
* 对方的地址会保存在fromAddr结构体中 */
if(recvfrom(sockfd, recvline, 1024, 0, (struct sockaddr *)&fromAddr, &fromAddrLen) < 0){
perror("Error :");
break;
}
addrBuf = inet_ntoa(fromAddr.sin_addr);
printf("A client from %s:%d\n", addrBuf, ntohs(fromAddr.sin_port));
printf("%s\n", recvline);
#if 1
strcpy(recvline, "ok");

if(sendto(sockfd, recvline, strlen(recvline), 0, (struct sockaddr *)&fromAddr, sizeof(fromAddr)) <= 0){
perror("Sendto : ");
}
#endif
}

printf("servce will exiting...\n");

close(sockfd);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char *argv[])
{
int sock, recvLen;
struct sockaddr_in toAddr, bindAddr, testAddr;
struct sockaddr_in fromAddr;
unsigned int fromLen;
char recvBuffer[128];
char sendBuffer[] = "hello this is udp broadcast";

sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
if(sock < 0){
fprintf(stderr,"socket():%s\n", strerror(errno));
exit(1);
}

memset(&toAddr,0,sizeof(toAddr));
toAddr.sin_family = AF_INET;
toAddr.sin_addr.s_addr = inet_addr("192.168.1.20");
toAddr.sin_port = htons(8888);

memset(&bindAddr, 0, sizeof(bindAddr));
bindAddr.sin_family = AF_INET;
bindAddr.sin_addr.s_addr = htonl(INADDR_ANY);
bindAddr.sin_port = htons(7777);

memset(&testAddr, 0, sizeof(testAddr));
testAddr.sin_family = AF_INET;
testAddr.sin_addr.s_addr = inet_addr("192.168.1.118");
testAddr.sin_port = htons(9999);

int opt = 1;
if(setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt)) != 0){
perror("setockopt() : \n");
close(sock);
exit(1);
}

#if 1
/* 要"被动"的接收数据，必须绑定一个客户端知道的地址和端口，以便客户端主动向该地址发送数据
* 若进程不绑定地址和端口，则由内核自动为其选择一个合适的地址和端口，这样也能监听，但是客户端不
* 知道地址和端口，很不方便连接 */
if(bind(sock, (struct sockaddr *)&bindAddr, sizeof(bindAddr)) != 0){
perror("Bind : ");
close(sock);
exit(1);
}
#endif

#if 1
/* 若想以后仅仅与一个主机通讯，则可以调用connect()指定目的地址，这样就可以调用recv(),send()
* 这样发送的数据会到达toAddr, 进程也只能接收到toAddr发送的数据包 ，调用connect()之后，对于错误状态可知的情况，
* 内核会返回到进程 */
if(connect(sock, (struct sockaddr *)&toAddr, sizeof(toAddr)) != 0){
perror("Connect : ");
close(sock);
exit(1);
}
#endif

#if 0
/* 调用connect()之后，进程可以使用send()来代替sendto() */
if(send(sock, sendBuffer, strlen(sendBuffer), 0) <= 0){
perror("Send : ");
close(sock);
exit(1);
}else{
printf("sent done!\n");
}
#endif

#if 1
/* 当然调用了connect()之后，进程仍然可以使用sendto(),但是第5、6个参数要么NULL，0，要么只能和原来的地址相同，
* 否则会调用失败 */
if(sendto(sock, sendBuffer,strlen(sendBuffer),0,(struct sockaddr*)&toAddr,sizeof(toAddr)) != strlen(sendBuffer)){
fprintf(stderr,"sendto():%s\n", strerror(errno));
close(sock);
exit(1);
}else{
printf("sent done!\n");
}
#endif

#if 0

/* 调用connect()之后，进程仍然可以使用recvfrom(),但此时只能收到connect()指定的地址的发来的数据包
* 对于已知的错误，内核会告知进程，例如进程调用recvfrom()接收本机回环口127.0.0.1:8888的数据，若127.0.0.1:8888
* 有进程在监听，那么recvfrom()会阻塞，直到收到数据，若127.0.0.1并没有进程在监听，那么recvfrom()会直接返回，并且
* errno错误号会表明: "connection refused"。
* 若调用recvfrom接收网络上另一个地址发来的数据，即使该地址上并没有进程在工作，而内核也不知道
* 是否该主机上的某某端口是否打开，因为内核并不为UDP向该主机的端口发送任何探测报文(TCP三次握手完成，内核当然知道对方的状态)，
* 那么本机的进程也不会被告知错误 (可以写个程序验证)*/
fromLen = sizeof(fromAddr);
memset(recvBuffer, 0, sizeof(recvBuffer));
if((recvLen = recvfrom(sock,recvBuffer,128,0,(struct sockaddr*)&fromAddr,&fromLen))<0){
fprintf(stderr,"recvfrom():%s\n", strerror(errno));
close(sock);
exit(1);
}

printf("recvfrom() result len : %d, content %s\n", recvLen, recvBuffer);

#endif

#if 1
/* 调用了connect()之后，可以使用recv()来代替recvfrom() */
printf("receiving...\n");
if((recvLen = recv(sock, recvBuffer, 128, 0)) < 0){
perror("recv() : ");
close(sock);
exit(1);
}

printf("recv() result len : %d, content %s\n", recvLen, recvBuffer);
#endif

close(sock);

return 0;
}