UDP的编程

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<sys/types.h>  
4. #include<sys/socket.h>  
5. #include<arpa/inet.h>  
6. //#include<netinet/in.h>  
7. #include<string.h>  
8.   
9. static void usage(const char * str)  
10. {  
11.     printf("Usage:%s [IP] [PORT]\n",str);  
12. }  
13.   
14.   
15. //  ./server 127.0.0.1 8080  
16. int main(int argc,char *argv[])  
17. {  
18.     if(argc != 3)  
19.     {  
20.         usage(argv[0]);  
21.         return 1;  
22.     }  
23.   
24.     int sock = socket(AF_INET,SOCK_DGRAM,0);  
25.     if(sock < 0)  
26.     {  
27.         perror("sock");  
28.         return 2;  
29.     }  
30.   
31.     struct sockaddr_in serv_addr;  
32.     serv_addr.sin_family = AF_INET;  
33.     serv_addr.sin_port = htons( atoi(argv[2]) );  
34.     serv_addr.sin_addr.s_addr = inet_addr(argv[1]);  
35.   
36.     if( (bind(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) ) < 0  )  
37.     {  
38.         perror("bind");  
39.         return 3;  
40.     }  
41.   
42.   
43.     char buf[BUFSIZ]  ;  
44.     struct sockaddr_in clie_addr;  
45.     socklen_t len = sizeof(clie_addr);  
46.   
47.     while(1)  
48.     {  
49.         ssize_t s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&clie_addr,&len );//最后一个参数是输入输出参数，  
50.         if(s > 0)  
51.         {  
52.             buf[s] = 0;  //最后加上一个\0  
53.             printf("%s:%d say # %s\n",inet_ntoa(clie_addr.sin_addr),ntohs(clie_addr.sin_port),buf);  
54.             sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&clie_addr,sizeof(clie_addr));  
55.         }  
56.     }  
57.   
58.     close(sock);  
59.   
60.   
61.     return 0;  
62. }  

客户端：

[cpp] view plain copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<sys/types.h>  
4. #include<sys/socket.h>  
5. #include<arpa/inet.h>  
6. //#include<netinet/in.h>  
7. #include<string.h>  
8.   
9.   
10. static void usage(const char *str)  
11. {  
12.     printf("Usage:%s [IP] [PORT]\n",str);  
13. }  
14.   
15. int main(int argc ,char* argv[])  
16. {  
17.   
18.     if(argc != 3)  
19.     {  
20.         usage(argv[0]);  
21.         return 1;  
22.     }  
23.   
24.   
25.     int sock = socket(AF_INET,SOCK_DGRAM,0);  
26.     if(sock < 0)  
27.     {  
28.         perror("sock");  
29.         return 2;  
30.     }  
31.   
32.     struct sockaddr_in serv_addr;  
33.     serv_addr.sin_family = AF_INET;  
34.     serv_addr.sin_port = htons(atoi(argv[2]));  
35.     serv_addr.sin_addr.s_addr = inet_addr(argv[1]);  
36.   
37.   
38.     char buf[BUFSIZ] = { 0 };  
39.     socklen_t len = sizeof(serv_addr);  
40.   
41.     while(1)  
42.     {  
43.         printf("Please Enter# ");  
44.         fflush(stdout);  
45.   
46.         ssize_t s =  read(0,buf,sizeof(buf)-1);  
47.         if(s > 0)  
48.         {  
49.             buf[s - 1] = 0;  //去掉换行符。  
50.             sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&serv_addr,sizeof(serv_addr));  
51.            
52.             printf("server echo# %s\n",buf);  
53.   
54.         }  
55.     }  
56.   
57.     close(sock);  
58.     return 0;  
59. }  

UDP传输不可靠，如何实现可靠传输？

在应用层让UDP实现简单的超时重传

众所周知～UDP是一个无连接协议，因此靠它来传输的话是不可靠的，即使是数据包丢失也不会报错。但是，在编写Linux上的socket程序时,却可以用简单的方法,在应用层实现超时重传，让UDP可靠一些。（这次说的方法最好用于两个程序间通信——也许只能用于两台机器通信）首先～我介绍一下Linux下，I/O操作的阻塞模式：
在Linux下，I/O操作有四种模式，分别为：阻塞式I/O，非阻塞式I/O，多路复用I/O，一击信号驱动I/O，这次需要用到的是阻塞式I/O。阻塞式I/O是最简单，最常用但也是效率最低的一个。在默认模式下，所有的套接字都是阻塞模式，即：当用户调用这些函数时，函数将一直阻塞下去，直至有某个事件发生。具体事件依函数而定，比如：调用读函数，由于缓存中还没有数据，而使得读函数发生读阻塞；同理，也可能在调用写函数的时候发生写阻塞；除此之外，还有调accept函数的时候，由于没有客户连接服务器，使得其发生阻塞；调用connect函数时，由于三次握手没有结束，使得其发生阻塞等等。也就是说～在没有特定事件发生的情况下，函数将什么也不干而等待事件发生，事件发生后则继续执行程序。而有些时候，由于某些原因，会使得函数永远处于阻塞模式（比如：客户用UDP给服务器传送数据的数据丢失，使得服务器端的recvfrom函数始终处于阻塞模式）这就需要调用某些函数使这些函数不再阻塞，具体方法有：
1、使用信号：比如调用alarm函数
2、在套接字上设置SO_RCVTIMEO和SO_SNDTIMEO选项，使得其阻塞有时间限制
3、时间选择通过select函数来实现
好啦～阻塞式I/O就说到这里，言归正传～继续讨论相对可靠一些的UDP～
前面已经说了，假如使用阻塞模式，那么，当一个数据包还没有到达目的地时，那么数据包的目的端程序就会处于阻塞状态，因此不能调用sendto函数给发送端，而发送端此时也在recvfrom下阻塞了，等待对方传来消息。
由于前面已经说了，这是只有两个程序间通信，因此，双方程序的生死之大事、前途、命运……都掌握在传输的那个数据包上了，如果那个数据包不争气（没准是路由问题，线路问题等等），中途数据包丢失了，那么，双方都将永远处于阻塞状态：发送端阻塞在recvfrom上，等待接收端回话；接收端也阻塞在recvfrom上，等待发送端传来的消息。可偏偏那消息不争气，传不过来……难道这俩程序就这么挂了？
如果只有sendto，recvfrom函数而没有超时机制，那……就为这俩程序祈祷吧……大约他们俩就得挂这等关机或者被处以极刑（就是kill啊～）…………不过～听了我下面说的～就可以解决这问题～同时，让UDP层上面的应用层有超时重传的能力～（晕～我这不是作广告啊………………）
其实看到这里，大家已经多半想到了如何处理这问题：只要有一方退出阻塞模式，发个数据包，那两个程序就都解放了～怎么让一个程序退出阻塞模式呢～其实很简单啦～没错～可以用alarm函数～一旦到时间～给程序传一个SIGALRM的中断消息就可以啦～让程序先处理这消息，然后拦一下SIGALRM消息，爱怎么处理怎么处理～解决～
/****************函数：alarm函数（知道的可以不用看）****************/
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
功能：从调用该函数算起，seconds秒后返回向调用进程传送一个SIGALRM消息
参数：seconds以秒为单位的整数
/****************************************************************/
看到这里也许你以为一切都解决了，但是还有一个容易被人忽视的问题：在Linux中，默认处理中断的方式是：
当从中断调用返回时，继续执行被中断的系统调用（用在刚才说的例子上就是：继续redvfrom……）这中默认处理方式大多数时候很有用，但是我们这里就不行了，那这个问题怎么解决呢？要解决这个问题，就不能单纯的用signal函数去设置中断处理程序了，而是要用另一个函数：sigactiong，
sigaction函数如下：
/***********函数：sigaction函数（知道的可以不用看****************/
#include <signal.h>
#include <types.h>
int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact);
功能：拦截下signum消息，用act所给的方式处理，将原来的处理方式存在oldact（一般oldact设为NULL）;
参数：signum：需要拦截的消息，这里是SIGALRM；
act：处理中断的方式，是一个结构体，后面会介绍这结构体；
oldact：用来存储原来的处理方式，一般为NULL，表示忽略；
/****************************************************************/
/***********结构体：struct sigaction（知道的可以不用看）*******/
struct sigaction
{
void (*sa_handler)(int);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
}
成员：第一个sa_handler就是中断处理程序的入口，比如：要用alarm程序处理这个中断，就讲此值设为alarm；
sa_mask：表示在中断处理中要屏蔽的中断；
sa_flags：这是很关键的东西～它包含了一些影响中断处理过程方式的标志，具体取值如下：
SA_NOCLDSTOP：这表示如果所处理的中断是SIGCHLD，由于收到其他信号而导致了子进程终止，将不发送SIG_CHLD;
SA_ONESHOT or SA_RESETHAND：sa_handler所指向的中断处理程序只被执行一次，之后将设为默认的中断处理程序；
SA_RESTART：让被处理的系统调用在中断返回后重新执行；
SA_NOMASK or SA_NODEFFER（这就是我们要用的）：在中断处理程序执行时，不平比自己的中断信号；