先明确一个问题，如果定义了一个数据结构，大小是，比方说 32 个字节，然后 UDP 客户端连续向服务端发了两个包。现在假设这两个包都已经到达了服务器，那么服务端调用 recvfrom 来接收数据，并且缓冲区开得远大于 64，例如，开了 1024 个字节，那么，服务端的 recvfrom 函数是会一次收到两个数据包呢，还是只能收到一个。
答案是只能收到一个。
来看代码：
struct.h
#ifndef STRUCT_H
#define STRUCT_H
typedef struct _UDP_MSG {
int add1;
int add2;
int sum;
char str1[16];
char str2[16];
char cat[32];
} UDP_MSG;
#endif /* STRUCT_H */
服务器的代码：
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include "struct.h"
#define MAX_LINE 1024
#define SERV_PORT 8080
int udp_serv();
int main() {
return udp_serv();
}
int udp_serv() {
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1) {
perror("socket");
return -1;
}
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(SERV_PORT);
if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
perror("bind");
return -1;
}
while (1) {
printf("sleeping\n");
sleep(10);
printf("akwaked\n");
char buf[BUFSIZ];
struct sockaddr_in cli_addr;
memset(&cli_addr, 0, sizeof(cli_addr));
socklen_t cli_addr_len = sizeof(cli_addr);
int recvn = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
printf("recv %d bytes\n", recvn);
UDP_MSG msg;
memset(&msg, 0, sizeof(msg));
printf("UDP_MSG size is %d\n", sizeof(msg));
memcpy(&msg, buf, sizeof(msg));
msg.sum = msg.add1 + msg.add2;
strcpy(msg.cat, msg.str1);
strcat(msg.cat, msg.str2);
printf("msg.add1 is: %d\n", msg.add1);
printf("msg.add2 is: %d\n", msg.add2);
printf("msg.sum is: %d\n", msg.sum);
printf("msg.str1 is: %s\n", msg.str1);
printf("msg.str2 is: %s\n", msg.str2);
printf("msg.cat is: %s\n", msg.cat);
sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
}
return 0;
}
客户端的：
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "struct.h"
#define MAX_LINE 1024
#define SERV_PORT 8080
int udp_cli(const char* serv_ip);
int main(int argc, char* argv[]) {
if (argc < 2) {
printf("Usage: %s serv_ip\n", argv[0]);
return 1;
}
return udp_cli(argv[1]);
}
int udp_cli(const char* serv_ip) {
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1) {
perror("socket");
return -1;
}
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
perror("inet_pton");
return -1;
}
while (1) {
UDP_MSG msg;
memset(&msg, 0, sizeof(msg));
msg.add1 = 1;
msg.add2 = 2;
scanf("%s%s", msg.str1, msg.str2);
if (sendto(sockfd, &msg, sizeof(msg), 0,
(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
perror("write");
return -1;
} else {
printf("send success\n");
}
if (sendto(sockfd, &msg, sizeof(msg), 0,
(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
perror("write2");
return -1;
} else {
printf("send2 success\n");
}
socklen_t serv_addr_len = sizeof(serv_addr);
if (recvfrom(sockfd, &msg, sizeof(msg), 0,
(struct sockaddr*)&serv_addr, &serv_addr_len) == -1) {
perror("read");
return -1;
}
printf("msg.add1 is: %d\n", msg.add1);
printf("msg.add2 is: %d\n", msg.add2);
printf("msg.sum is: %d\n", msg.sum);
printf("msg.str1 is: %s\n", msg.str1);
printf("msg.str2 is: %s\n", msg.str2);
printf("msg.cat is: %s\n", msg.cat);
break;
}
return 0;
}
运行起来后，服务端的输出如下：
sleeping akwaked recv 76 bytes UDP_MSG size is 76 msg.add1 is: 1 msg.add2 is: 2 msg.sum is: 3 msg.str1 is: 123 msg.str2 is: 456 msg.cat is: 123456 sleeping akwaked recv 76 bytes UDP_MSG size is 76 msg.add1 is: 1 msg.add2 is: 2 msg.sum is: 3 msg.str1 is: 123 msg.str2 is: 456 msg.cat is: 123456 sleeping
客户端如下：
123 456 send success send2 success msg.add1 is: 1 msg.add2 is: 2 msg.sum is: 3 msg.str1 is: 123 msg.str2 is: 456 msg.cat is: 123456
这里涉及到一个边界的问题。 TCP 是流式的数据传输，消息没有边界，需要应用层自己去定义消息边界，而 UDP 是数据报传输，所以协议保证了一次只能接收一个数据报。
详细的解释看到这里，http://hi.baidu.com/chongerfeia/item/c38f91e075d742226dabb8a4
2010-08-11 14:56 有关TCP和UDP 粘包 消息保护边界在socket网络程序中，TCP和UDP分别是面向连接和非面向连接的。因此TCP的socket编程，收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。
对于UDP，不会使用块的合并优化算法，这样，实际上目前认为，是由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了保护消息边界和流
那么什么是保护消息边界和流呢?保护消息边界，就是指传输协议把数据当作一条独立的消息在网上
传输,接收端只能接收独立的消息.也就是说存在保护消息边界,接收
端一次只能接收发送端发出的一个数据包.
而面向流则是指无保护消息保护边界的,如果发送端连续发送数据,
接收端有可能在一次接收动作中,会接收两个或者更多的数据包.我们举个例子来说,例如,我们连续发送三个数据包,大小分别是2k,
4k , 8k,这三个数据包,都已经到达了接收端的网络堆栈中,如果使
用UDP协议,不管我们使用多大的接收缓冲区去接收数据,我们必须有
三次接收动作,才能够把所有的数据包接收完.而使用TCP协议,我们
只要把接收的缓冲区大小设置在14k以上,我们就能够一次把所有的
数据包接收下来.只需要有一次接收动作.这就是因为UDP协议的保护消息边界使得每一个消息都是独立的.而
流传输,却把数据当作一串数据流,他不认为数据是一个一个的消息.所以有很多人在使用tcp协议通讯的时候,并不清楚tcp是基于流的
传输,当连续发送数据的时候,他们时常会认识tcp会丢包.其实不然,
因为当他们使用的缓冲区足够大时,他们有可能会一次接收到两个甚
至更多的数据包,而很多人往往会忽视这一点,只解析检查了第一个
数据包,而已经接收的其他数据包却被忽略了.所以大家如果要作这
类的网络编程的时候,必须要注意这一点.结论：
根据以上所说，可以这样理解，TCP为了保证可靠传输，尽量减少额外
开销（每次发包都要验证），因此采用了流式传输，面向流的传输，
相对于面向消息的传输，可以减少发送包的数量。从而减少了额外开
销。但是，对于数据传输频繁的程序来讲，使用TCP可能会容易粘包。
当然，对接收端的程序来讲，如果机器负荷很重，也会在接收缓冲里
粘包。这样，就需要接收端额外拆包，增加了工作量。因此，这个特
别适合的是数据要求可靠传输，但是不需要太频繁传输的场合（
两次操作间隔100ms，具体是由TCP等待发送间隔决定的，取决于内核
中的socket的写法）而UDP，由于面向的是消息传输，它把所有接收到的消息都挂接到缓冲
区的接受队列中，因此，它对于数据的提取分离就更加方便，但是，
它没有粘包机制，因此，当发送数据量较小的时候，就会发生数据包
有效载荷较小的情况，也会增加多次发送的系统发送开销（系统调用，
写硬件等）和接收开销。因此，应该最好设置一个比较合适的数据包
的包长，来进行UDP数据的发送。（UDP最大载荷为1472，因此最好能
每次传输接近这个数的数据量，这特别适合于视频，音频等大块数据
的发送，同时，通过减少握手来保证流媒体的实时性）